Testing¶

Blink includes a comprehensive test suite to ensure reliability and correctness. This page describes how to run the tests and how to write new tests.

Running Tests¶

You can run the tests using the Makefile:

# Run all tests
make test

# Run tests without integration tests
make test-short

# Generate test coverage
make coverage

Or you can use the Go test command directly:

# Run all tests
go test -v ./...

# Run tests without integration tests
go test -v -short ./...

# Generate test coverage
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out

Test Structure¶

The tests are organized as follows:

Unit Tests: Test individual functions and methods
Integration Tests: Test the interaction between components
Benchmarks: Measure the performance of critical functions

Unit Tests¶

Unit tests are located in the same package as the code they test, with a _test.go suffix. For example, the tests for blink.go are in blink_test.go.

Example unit test:

func TestShouldIgnoreFile(t *testing.T) {
 tests := []struct {
  name     string
  filename string
  want     bool
 }{
  {"Normal file", "file.txt", false},
  {"Hidden file", ".hidden", true},
  {"Underscore file", "_temp", true},
  {"Normal directory", "dir", false},
  {"Hidden directory", ".git", true},
  {"Underscore directory", "_build", true},
 }

 for _, tt := range tests {
  t.Run(tt.name, func(t *testing.T) {
   if got := ShouldIgnoreFile(tt.filename); got != tt.want {
    t.Errorf("ShouldIgnoreFile(%q) = %v, want %v", tt.filename, got, tt.want)
   }
  })
 }
}

Integration Tests¶

Integration tests test the interaction between components. They are also located in _test.go files, but they test multiple components together.

Example integration test:

func TestEventServer(t *testing.T) {
 // Skip in short mode as this is an integration test
 if testing.Short() {
  t.Skip("Skipping integration test in short mode")
 }

 // Create a temporary directory for testing
 tempDir, err := ioutil.TempDir("", "blink-server-test-")
 if err != nil {
  t.Fatalf("Failed to create temp dir: %v", err)
 }
 defer os.RemoveAll(tempDir)

 // Start the event server in a goroutine
 go func() {
  EventServer(
   tempDir,
   "*",
   ":0", // Use port 0 to get a random available port
   "/events",
   100*time.Millisecond,
  )
 }()

 // Give the server time to start
 time.Sleep(500 * time.Millisecond)

 // Create a file in the watched directory to trigger an event
 testFile := filepath.Join(tempDir, "test.txt")
 if err := ioutil.WriteFile(testFile, []byte("test"), 0644); err != nil {
  t.Fatalf("Failed to create test file: %v", err)
 }

 // Wait for the event to be processed
 time.Sleep(200 * time.Millisecond)
}

Benchmarks¶

Benchmarks measure the performance of critical functions. They are located in _test.go files with a Benchmark prefix.

Example benchmark:

func BenchmarkShouldIgnoreFile(b *testing.B) {
 filenames := []string{
  "file.txt",
  ".hidden",
  "_temp",
  "dir",
  ".git",
  "_build",
 }

 b.ResetTimer()
 for i := 0; i < b.N; i++ {
  for _, filename := range filenames {
   ShouldIgnoreFile(filename)
  }
 }
}

Writing Tests¶

When writing tests for Blink, follow these guidelines:

Test Coverage: Aim for high test coverage, especially for critical functions
Test Edge Cases: Test edge cases and error conditions
Test Performance: Write benchmarks for performance-critical functions
Test Integration: Write integration tests for component interactions
Test Isolation: Tests should be isolated and not depend on each other
Test Readability: Tests should be readable and maintainable

Example Test¶

Here's an example of a good test:

func TestRemoveOldEvents(t *testing.T) {
 // Create a TimeEventMap with events at different times
 events := make(TimeEventMap)
 now := time.Now()

 // Add events at different times
 events[now.Add(-10*time.Minute)] = Event{}
 events[now.Add(-5*time.Minute)] = Event{}
 events[now.Add(-1*time.Minute)] = Event{}
 events[now] = Event{}

 // Remove events older than 2 minutes
 maxAge := 2 * time.Minute
 RemoveOldEvents(&events, maxAge)

 // Check that only the recent events remain
 if len(events) != 2 {
  t.Errorf("Expected 2 events after removal, got %d", len(events))
 }

 // Check that the old events were removed
 for timestamp := range events {
  if now.Sub(timestamp) > maxAge {
   t.Errorf("Event at %v should have been removed (older than %v)", timestamp, maxAge)
  }
 }
}

Test Coverage¶

Blink aims for high test coverage. You can check the current test coverage with:

make coverage

This will generate a coverage report and open it in your browser.

Continuous Integration¶

Blink uses continuous integration to run tests automatically on every pull request and push to the main branch. This ensures that the code always passes tests and maintains quality.