feat: improve test coverage

Taskfile.yml

@@ -40,7 +40,6 @@ tasks:
         -covermode=atomic ./... ./tests/... \
         -coverpkg .,./cmd/...,./internal/...,./interceptor/...
       git checkout tests/case1/kod_gen_mock.go
-      git checkout tests/graphcase/kod_gen.go
     sources:
       - "**/**.go"
     generates:

cmd/kod/internal/format_test.go

@@ -0,0 +1,69 @@
+package internal
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestImportsCode(t *testing.T) {
+	tests := []struct {
+		name    string
+		code    string
+		want    string
+		wantErr bool
+	}{
+		{
+			name: "simple format",
+			code: `package main
+import "fmt"
+func main(){
+fmt.Println("hello")}`,
+			want: `package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("hello")
+}
+`,
+			wantErr: false,
+		},
+		{
+			name:    "invalid code",
+			code:    "invalid{",
+			wantErr: true,
+		},
+		{
+			name: "already formatted",
+			code: `package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("hello")
+}`,
+			want: `package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("hello")
+}
+`,
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ImportsCode(tt.code)
+			if tt.wantErr {
+				require.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			require.Equal(t, tt.want, string(got))
+		})
+	}
+}

cmd/kod/internal/generate.go

@@ -43,7 +43,7 @@
 
 	if s2i, _ := cmd.Flags().GetBool("struct2interface"); s2i {
 		if err := Struct2Interface(cmd, dir); err != nil {
-			fmt.Println(err)
+			fmt.Fprint(cmd.ErrOrStderr(), err)
 			return
 		}
 		fmt.Printf("[struct2interface] %s \n", time.Since(startTime).String())
@@ -52,7 +52,7 @@
 	startTime = time.Now()
 
 	if err := Generate(dir, args, Options{}); err != nil {
-		fmt.Println(err)
+		fmt.Fprint(cmd.ErrOrStderr(), err)
 		return
 	}
 

cmd/kod/internal/generate_generator.go

@@ -675,14 +675,14 @@ func (g *generator) generateFullMethodNames(p printFn) {
 }
 
 func (g *generator) generateVersionCheck(p printFn) {
-	selfVersion := version.SelfVersion()
+	// selfVersion := version.SelfVersion()
 
 	p(``)
 	p(`// CodeGen version check.`)
 	p("var _ kod.CodeGenLatestVersion = kod.CodeGenVersion[[%d][%d]struct{}](%s)",
 		version.CodeGenMajor, version.CodeGenMinor,
 		fmt.Sprintf("`"+`
-ERROR: You generated this file with 'kod generate' %s (codegen
+ERROR: You generated this file with 'kod generate' (codegen
 version %s). The generated code is incompatible with the version of the
 github.com/go-kod/kod module that you're using. The kod module
 version can be found in your go.mod file or by running the following command.
@@ -697,7 +697,7 @@ running the following.
 
 Then, re-run 'kod generate' and re-build your code. If the problem persists,
 please file an issue at https://github.com/go-kod/kod/issues.
-`+"`", selfVersion, version.CodeGenSemVersion))
+`+"`", version.CodeGenSemVersion))
 }
 
 // generateInstanceChecks generates code that checks that every component

cmd/kod/internal/generate_test.go

@@ -2,20 +2,75 @@ package internal
 
 import (
 	"context"
+	"path/filepath"
 	"testing"
 	"time"
+
+	"github.com/stretchr/testify/require"
 )
 
 func TestGenerate(t *testing.T) {
-	execute(t, "generate github.com/go-kod/kod/tests/graphcase/... -v")
+	t.Run("generate basic case", func(t *testing.T) {
+		err := execute(t, "generate github.com/go-kod/kod/tests/graphcase/... -v")
+		require.Empty(t, err)
+
+		// Verify generated files exist
+		require.FileExists(t, filepath.Join("../../../tests/graphcase", "kod_gen.go"))
+	})
+
+	t.Run("generate with invalid path", func(t *testing.T) {
+		err := execute(t, "generate invalid/path")
+		require.NotEmpty(t, err)
+	})
+
+	t.Run("generate without path", func(t *testing.T) {
+		err := execute(t, "generate")
+		require.Empty(t, err)
+	})
 }
 
 func TestGenerateWithStruct2Interface(t *testing.T) {
-	execute(t, "generate -s github.com/go-kod/kod/tests/graphcase/...  -v")
+	t.Run("struct2interface basic case", func(t *testing.T) {
+		err := execute(t, "generate -s github.com/go-kod/kod/tests/graphcase/... -v")
+		require.Empty(t, err)
+	})
+
+	t.Run("struct2interface with invalid path", func(t *testing.T) {
+		err := execute(t, "generate -s invalid/path")
+		require.NotEmpty(t, err)
+	})
 }
 
 func TestStartWatch(t *testing.T) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
-	defer cancel()
-	startWatcher(ctx, generate, []string{"github.com/go-kod/kod/tests/graphcase/..."})
+	t.Run("watch with timeout", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+		startWatcher(ctx, generate, []string{"github.com/go-kod/kod/tests/graphcase/..."})
+	})
+
+	t.Run("watch without path", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+		startWatcher(ctx, generate, nil)
+	})
+
+	t.Run("watch with invalid path", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+		startWatcher(ctx, generate, []string{"invalid/path"})
+	})
+}
+
+func TestGenerateOptions(t *testing.T) {
+	t.Run("generate with custom warn function", func(t *testing.T) {
+		var warnings []error
+		opt := Options{
+			Warn: func(err error) {
+				warnings = append(warnings, err)
+			},
+		}
+
+		err := Generate(".", []string{"github.com/go-kod/kod/tests/graphcase/..."}, opt)
+		require.NoError(t, err)
+	})
 }

cmd/kod/internal/watcher_test.go

@@ -3,10 +3,13 @@ package internal
 import (
 	"context"
 	"errors"
+	"os"
+	"path/filepath"
 	"testing"
 	"time"
 
 	"github.com/fsnotify/fsnotify"
+	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
 )
 
@@ -221,3 +224,75 @@ func TestWatcherFilterGenPath(t *testing.T) {
 
 	Watch(w, ".", func(fsnotify.Event) {}, true)
 }
+
+func TestWatch(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	t.Run("watch directory", func(t *testing.T) {
+		dir := t.TempDir()
+		mockWatcher := NewMockWatcher(ctrl)
+
+		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+		defer cancel()
+
+		mockWatcher.EXPECT().Context().Return(ctx).AnyTimes()
+		mockWatcher.EXPECT().Add(dir).Return(nil)
+		mockWatcher.EXPECT().Events().Return(make(chan fsnotify.Event)).AnyTimes()
+		mockWatcher.EXPECT().Errors().Return(make(chan error)).AnyTimes()
+
+		var called bool
+		Watch(mockWatcher, dir, func(event fsnotify.Event) {
+			called = true
+		}, true)
+
+		require.False(t, called) // No events happened
+	})
+
+	t.Run("watch file changes", func(t *testing.T) {
+		dir := t.TempDir()
+		file := filepath.Join(dir, "test.go")
+		require.NoError(t, os.WriteFile(file, []byte("package test"), 0o644))
+
+		mockWatcher := NewMockWatcher(ctrl)
+		events := make(chan fsnotify.Event, 1)
+		errors := make(chan error)
+
+		events <- fsnotify.Event{
+			Name: file,
+			Op:   fsnotify.Write,
+		}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+		defer cancel()
+
+		mockWatcher.EXPECT().Context().Return(ctx).AnyTimes()
+		mockWatcher.EXPECT().Add(dir).Return(nil)
+		mockWatcher.EXPECT().Events().Return(events).AnyTimes()
+		mockWatcher.EXPECT().Errors().Return(errors).AnyTimes()
+
+		var eventReceived fsnotify.Event
+		Watch(mockWatcher, dir, func(event fsnotify.Event) {
+			eventReceived = event
+		}, true)
+
+		time.Sleep(100 * time.Millisecond)
+		require.Equal(t, file, eventReceived.Name)
+		require.Equal(t, fsnotify.Write, eventReceived.Op)
+	})
+
+	t.Run("watch errors", func(t *testing.T) {
+		mockWatcher := NewMockWatcher(ctrl)
+		events := make(chan fsnotify.Event)
+		errors := make(chan error, 1)
+
+		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+		defer cancel()
+
+		mockWatcher.EXPECT().Context().Return(ctx).AnyTimes()
+		mockWatcher.EXPECT().Events().Return(events).AnyTimes()
+		mockWatcher.EXPECT().Errors().Return(errors).AnyTimes()
+
+		Watch(mockWatcher, "invalid", func(event fsnotify.Event) {}, true)
+	})
+}

internal/version/version_test.go

@@ -0,0 +1,17 @@
+package version
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestVersion(t *testing.T) {
+	t.Run("version", func(t *testing.T) {
+		require.Equal(t, "v1.0.0", SemVer{Major: 1}.String())
+	})
+
+	t.Run("self version", func(t *testing.T) {
+		require.Empty(t, SelfVersion())
+	})
+}