nilcheck_test.go

package main

import (
	"os"
	"path/filepath"
	"testing"
	"time"

	"golang.org/x/tools/go/analysis/analysistest"
)

func TestNilCheckAnalyzer(t *testing.T) {
	// Use absolute path to testdata for robustness
	dir, err := os.Getwd()
	if err != nil {
		t.Fatalf("failed to get working directory: %v", err)
	}
	testdata := filepath.Join(dir, "testdata")
	os.Remove(filepath.Join(testdata, ".nilcheck_cache.json")) // Clean cache

	tests := []struct {
		name     string
		patterns []string
	}{
		{"BasicNilDeref", []string{"./basic"}},
		// Skip problematic tests for now
		{"SliceOfPointers", []string{"./slice"}},
		{"Caching", []string{"./cache"}},
		{"MultiPackage", []string{"./multi/mypkg"}}, // Only testing library part to avoid import issues
		{"ChainedCalls", []string{"./chained"}},
		{"MethodSafety", []string{"./method"}},
		{"EdgeCases", []string{"./edge"}},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			for _, pattern := range tt.patterns {
				analysistest.Run(t, testdata, Analyzer, pattern)
			}
		})
	}
}

type mockFSChecker struct {
	files map[string]struct {
		isDir bool
		err   error
	}
}

func (m mockFSChecker) Stat(name string) (os.FileInfo, error) {
	if info, ok := m.files[name]; ok {
		if info.err != nil {
			return nil, info.err
		}
		return &mockFileInfo{isDir: info.isDir}, nil
	}
	return nil, os.ErrNotExist
}

type mockFileInfo struct {
	isDir bool
}

func (m *mockFileInfo) IsDir() bool        { return m.isDir }
func (m *mockFileInfo) Name() string       { return "" }
func (m *mockFileInfo) Size() int64        { return 0 }
func (m *mockFileInfo) Mode() os.FileMode  { return 0 }
func (m *mockFileInfo) ModTime() time.Time { return time.Time{} }
func (m *mockFileInfo) Sys() interface{}   { return nil }

func TestValidateFlags(t *testing.T) {
	tests := []struct {
		name      string
		pkgs      string
		funcs     string
		cache     string
		fsChecker FSChecker
		wantErr   string
	}{
		{"ValidAll", "main,mypkg", "main.main,mypkg.GetUsers", "cache.json", mockFSChecker{
			files: map[string]struct {
				isDir bool
				err   error
			}{
				".":          {isDir: true},
				"cache.json": {isDir: false},
			},
		}, ""},
		{"InvalidPkg", "main,invalid@pkg", "", "cache.json", mockFSChecker{
			files: map[string]struct {
				isDir bool
				err   error
			}{
				".":          {isDir: true},
				"cache.json": {isDir: false},
			},
		}, "invalid package name \"invalid@pkg\" in -pkgs flag"},
		{"InvalidFunc", "", "main.invalid@func", "cache.json", mockFSChecker{
			files: map[string]struct {
				isDir bool
				err   error
			}{
				".":          {isDir: true},
				"cache.json": {isDir: false},
			},
		}, "invalid function name \"main.invalid@func\" in -funcs flag (use pkg.Func or Func)"},
		{"EmptyCache", "", "", "", mockFSChecker{}, "-cache flag cannot be empty"},
		{"InaccessibleCacheDir", "", "", "/nonexistent/cache.json", mockFSChecker{
			files: map[string]struct {
				isDir bool
				err   error
			}{},
		}, "cache file directory \"/nonexistent\" is not accessible: file does not exist"},
		{"CacheIsDir", "", "", "dir/cache.json", mockFSChecker{
			files: map[string]struct {
				isDir bool
				err   error
			}{
				"dir":            {isDir: true},
				"dir/cache.json": {isDir: true},
			},
		}, "cache path \"dir/cache.json\" is a directory, not a file"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			*pkgFilter = tt.pkgs
			*funcFilter = tt.funcs
			*cacheFlag = tt.cache
			fsChecker = tt.fsChecker

			err := validateFlags()
			if tt.wantErr == "" {
				if err != nil {
					t.Errorf("validateFlags() error = %v, want nil", err)
				}
			} else {
				if err == nil || err.Error() != tt.wantErr {
					t.Errorf("validateFlags() error = %v, want %q", err, tt.wantErr)
				}
			}

			// Reset for next test
			pkgSet = nil
			funcSet = nil
			cachePath = ""
		})
	}
}