chore: release v1.0.2 with critical fixes and test improvements

- fix: add missing ClickHouse driver dependency
- fix: resolve race condition in orchestrator (single goroutine per source)
- feat: add explicit source_type config for Unix socket sources
- test: improve coverage from 50.6% to 62.0%
- docs: add CHANGELOG.md with release notes
- build: update version to 1.0.2 in build scripts and Dockerfiles

Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>

internal/adapters/outbound/clickhouse/sink.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	_ "github.com/ClickHouse/clickhouse-go/v2"
 	"github.com/logcorrelator/logcorrelator/internal/domain"
 )
 

internal/adapters/outbound/file/sink_test.go

@@ -94,3 +94,98 @@ func TestFileSink_Name(t *testing.T) {
 		t.Errorf("expected name 'file', got %s", sink.Name())
 	}
 }
+
+func TestFileSink_ValidateFilePath(t *testing.T) {
+	tests := []struct {
+		name    string
+		path    string
+		wantErr bool
+	}{
+		{"empty path", "", true},
+		{"valid /var/log/logcorrelator", "/var/log/logcorrelator/test.log", false},
+		{"valid /var/log", "/var/log/test.log", false},
+		{"valid /tmp", "/tmp/test.log", false},
+		{"path traversal", "/var/log/../etc/passwd", true},
+		{"invalid directory", "/etc/logcorrelator/test.log", true},
+		{"relative path", "test.log", false}, // Allowed for testing
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateFilePath(tt.path)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("validateFilePath(%q) error = %v, wantErr %v", tt.path, err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestFileSink_OpenFile(t *testing.T) {
+	tmpDir := t.TempDir()
+	testPath := filepath.Join(tmpDir, "subdir", "test.log")
+
+	sink := &FileSink{
+		config: Config{Path: testPath},
+	}
+
+	err := sink.openFile()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	defer sink.Close()
+
+	if sink.file == nil {
+		t.Error("expected file to be opened")
+	}
+	if sink.writer == nil {
+		t.Error("expected writer to be initialized")
+	}
+}
+
+func TestFileSink_WriteBeforeOpen(t *testing.T) {
+	tmpDir := t.TempDir()
+	testPath := filepath.Join(tmpDir, "test.log")
+
+	sink, err := NewFileSink(Config{Path: testPath})
+	if err != nil {
+		t.Fatalf("failed to create sink: %v", err)
+	}
+	defer sink.Close()
+
+	// Write should open file automatically
+	log := domain.CorrelatedLog{SrcIP: "192.168.1.1", SrcPort: 8080}
+	err = sink.Write(context.Background(), log)
+	if err != nil {
+		t.Fatalf("failed to write: %v", err)
+	}
+
+	// Verify file was created
+	if _, err := os.Stat(testPath); os.IsNotExist(err) {
+		t.Error("expected file to be created")
+	}
+}
+
+func TestFileSink_FlushBeforeOpen(t *testing.T) {
+	tmpDir := t.TempDir()
+	testPath := filepath.Join(tmpDir, "test.log")
+
+	sink, err := NewFileSink(Config{Path: testPath})
+	if err != nil {
+		t.Fatalf("failed to create sink: %v", err)
+	}
+	defer sink.Close()
+
+	// Flush before any write should not error
+	err = sink.Flush(context.Background())
+	if err != nil {
+		t.Errorf("expected no error on flush before open, got %v", err)
+	}
+}
+
+func TestFileSink_InvalidPath(t *testing.T) {
+	// Test with invalid path (path traversal)
+	_, err := NewFileSink(Config{Path: "/etc/../passwd"})
+	if err == nil {
+		t.Error("expected error for invalid path")
+	}
+}

internal/adapters/outbound/multi/sink_test.go

@@ -112,3 +112,115 @@ func TestMultiSink_AddSink(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 }
+
+func TestMultiSink_Name(t *testing.T) {
+	ms := NewMultiSink()
+	if ms.Name() != "multi" {
+		t.Errorf("expected name 'multi', got %s", ms.Name())
+	}
+}
+
+func TestMultiSink_Flush(t *testing.T) {
+	flushed := false
+	sink := &mockSink{
+		name: "test",
+		writeFunc: func(log domain.CorrelatedLog) error { return nil },
+		flushFunc: func() error {
+			flushed = true
+			return nil
+		},
+		closeFunc: func() error { return nil },
+	}
+
+	ms := NewMultiSink(sink)
+	err := ms.Flush(context.Background())
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !flushed {
+		t.Error("expected sink to be flushed")
+	}
+}
+
+func TestMultiSink_Flush_Error(t *testing.T) {
+	sink := &mockSink{
+		name: "test",
+		writeFunc: func(log domain.CorrelatedLog) error { return nil },
+		flushFunc: func() error { return context.Canceled },
+		closeFunc: func() error { return nil },
+	}
+
+	ms := NewMultiSink(sink)
+	err := ms.Flush(context.Background())
+	if err != context.Canceled {
+		t.Errorf("expected context.Canceled error, got %v", err)
+	}
+}
+
+func TestMultiSink_Close(t *testing.T) {
+	closed := false
+	sink := &mockSink{
+		name: "test",
+		writeFunc: func(log domain.CorrelatedLog) error { return nil },
+		flushFunc: func() error { return nil },
+		closeFunc: func() error {
+			closed = true
+			return nil
+		},
+	}
+
+	ms := NewMultiSink(sink)
+	err := ms.Close()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !closed {
+		t.Error("expected sink to be closed")
+	}
+}
+
+func TestMultiSink_Close_Error(t *testing.T) {
+	sink := &mockSink{
+		name: "test",
+		writeFunc: func(log domain.CorrelatedLog) error { return nil },
+		flushFunc: func() error { return nil },
+		closeFunc: func() error { return context.Canceled },
+	}
+
+	ms := NewMultiSink(sink)
+	err := ms.Close()
+	if err != context.Canceled {
+		t.Errorf("expected context.Canceled error, got %v", err)
+	}
+}
+
+func TestMultiSink_Write_EmptySinks(t *testing.T) {
+	ms := NewMultiSink()
+	log := domain.CorrelatedLog{SrcIP: "192.168.1.1"}
+	err := ms.Write(context.Background(), log)
+	if err != nil {
+		t.Fatalf("unexpected error with empty sinks: %v", err)
+	}
+}
+
+func TestMultiSink_Write_ContextCancelled(t *testing.T) {
+	sink := &mockSink{
+		name: "test",
+		writeFunc: func(log domain.CorrelatedLog) error {
+			<-context.Background().Done()
+			return nil
+		},
+		flushFunc: func() error { return nil },
+		closeFunc: func() error { return nil },
+	}
+
+	ms := NewMultiSink(sink)
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	
+	log := domain.CorrelatedLog{SrcIP: "192.168.1.1"}
+	err := ms.Write(ctx, log)
+	if err != context.Canceled {
+		t.Errorf("expected context.Canceled error, got %v", err)
+	}
+}