unusedsqlc_test.go

package unusedsqlc_test

import (
	"go/ast"
	"go/parser"
	"go/token"
	"path/filepath"
	"strings"
	"testing"

	"github.com/malpou/unusedsqlc"
)

func TestUnusedSQLc(t *testing.T) {
	tests := []struct {
		name     string
		dir      string
		expected []string
	}{
		{
			name: "basic - should find UnusedQuery",
			dir:  "fixtures/basic",
			expected: []string{
				"UnusedQuery",
			},
		},
		{
			name: "crosspackage - should find DeleteProduct",
			dir:  "fixtures/crosspackage",
			expected: []string{
				"DeleteProduct",
			},
		},
		{
			name:     "noissues - all queries used",
			dir:      "fixtures/noissues",
			expected: []string{},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			messages, err := runLinter(tt.dir)
			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}

			// Check that we found the expected unused queries
			foundQueries := make(map[string]bool)
			for _, msg := range messages {
				// Extract query name from message
				if idx := strings.Index(msg.Message, `unused sqlc query "`); idx >= 0 {
					start := idx + len(`unused sqlc query "`)
					end := strings.Index(msg.Message[start:], `"`)
					if end > 0 {
						queryName := msg.Message[start : start+end]
						foundQueries[queryName] = true
					}
				}
			}

			// Verify expected queries were found
			for _, expectedQuery := range tt.expected {
				if !foundQueries[expectedQuery] {
					t.Errorf("expected to find unused query %q, but didn't", expectedQuery)
				}
				delete(foundQueries, expectedQuery)
			}

			// Check for unexpected queries
			for query := range foundQueries {
				t.Errorf("found unexpected unused query %q", query)
			}
		})
	}
}

func TestQueryParser(t *testing.T) {
	tests := []struct {
		name          string
		dir           string
		expectedCount int
		expectedNames []string
	}{
		{
			name:          "basic queries",
			dir:           "fixtures/basic",
			expectedCount: 6,
			expectedNames: []string{"GetUser", "ListUsers", "CreateUser", "UpdateUser", "DeleteUser", "UnusedQuery"},
		},
		{
			name:          "crosspackage queries",
			dir:           "fixtures/crosspackage",
			expectedCount: 3,
			expectedNames: []string{"GetProduct", "ListProducts", "DeleteProduct"},
		},
		{
			name:          "noissues queries",
			dir:           "fixtures/noissues",
			expectedCount: 2,
			expectedNames: []string{"GetAllUsers", "CountUsers"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			parser := unusedsqlc.NewQueryParser(nil)
			queries, err := parser.ParseDirectory(tt.dir)
			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}

			if len(queries) != tt.expectedCount {
				t.Errorf("expected %d queries, got %d", tt.expectedCount, len(queries))
			}

			queryMap := make(map[string]bool)
			for _, q := range queries {
				queryMap[q.Name] = true
			}

			for _, name := range tt.expectedNames {
				if !queryMap[name] {
					t.Errorf("expected to find query %q", name)
				}
			}
		})
	}
}

func TestGolangciLintMode(t *testing.T) {
	tests := []struct {
		name             string
		dir              string
		golangciLintMode bool
		expectedQueries  []string
		checkPositions   bool
	}{
		{
			name:             "basic - standalone mode",
			dir:              "fixtures/basic",
			golangciLintMode: false,
			expectedQueries:  []string{"UnusedQuery"},
			checkPositions:   true,
		},
		{
			name:             "basic - golangci-lint mode",
			dir:              "fixtures/basic",
			golangciLintMode: true,
			expectedQueries:  []string{"UnusedQuery"},
			checkPositions:   true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			fset := token.NewFileSet()

			// Parse Go files in the directory
			pkgs, err := parser.ParseDir(fset, tt.dir, nil, parser.ParseComments)
			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}

			var files []*ast.File
			for _, pkg := range pkgs {
				for _, file := range pkg.Files {
					files = append(files, file)
				}
			}

			// Create linter with specified mode
			config := unusedsqlc.DefaultConfig()
			config.GolangciLintMode = tt.golangciLintMode
			linter := unusedsqlc.New(config)

			absDir, _ := filepath.Abs(tt.dir)
			messages, err := linter.Run(files, fset, absDir)
			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}

			// Check that we found the expected unused queries
			foundQueries := make(map[string]bool)
			for _, msg := range messages {
				// Extract query name from message
				if idx := strings.Index(msg.Message, `unused sqlc query "`); idx >= 0 {
					start := idx + len(`unused sqlc query "`)
					end := strings.Index(msg.Message[start:], `"`)
					if end > 0 {
						queryName := msg.Message[start : start+end]
						foundQueries[queryName] = true

						// Check position based on mode
						if tt.checkPositions {
							if tt.golangciLintMode {
								// In golangci-lint mode, position should be in a Go file
								if strings.HasSuffix(msg.Pos.Filename, ".sql") {
									t.Errorf("In golangci-lint mode, position should not be in SQL file, got: %s",
										msg.Pos.Filename)
								}
							} else {
								// In standalone mode, position should be in SQL file
								if !strings.HasSuffix(msg.Pos.Filename, ".sql") {
									t.Errorf("In standalone mode, position should be in SQL file, got: %s", msg.Pos.Filename)
								}
							}
						}
					}
				}
			}

			// Verify expected queries were found
			for _, expectedQuery := range tt.expectedQueries {
				if !foundQueries[expectedQuery] {
					t.Errorf("expected to find unused query %q, but didn't", expectedQuery)
				}
			}
		})
	}
}

func TestConfig(t *testing.T) {
	t.Run("default config", func(t *testing.T) {
		config := unusedsqlc.DefaultConfig()
		if !config.IgnoreGenerated {
			t.Error("expected IgnoreGenerated to be true by default")
		}
		if len(config.ExcludeQueries) != 0 {
			t.Error("expected no excluded queries by default")
		}
		if config.GolangciLintMode {
			t.Error("expected GolangciLintMode to be false by default")
		}
	})

	t.Run("exclude queries", func(t *testing.T) {
		config := unusedsqlc.DefaultConfig()
		config.ExcludeQueries = []string{"TestQuery1", "TestQuery2"}

		if !config.IsQueryExcluded("TestQuery1") {
			t.Error("expected TestQuery1 to be excluded")
		}
		if config.IsQueryExcluded("TestQuery3") {
			t.Error("expected TestQuery3 not to be excluded")
		}
	})

	t.Run("exclude patterns", func(t *testing.T) {
		config := unusedsqlc.DefaultConfig()
		config.ExcludePatterns = []string{"Test*", "*Internal", "*_test"}

		testCases := []struct {
			query    string
			excluded bool
		}{
			{"TestQuery", true},
			{"TestAnything", true},
			{"QueryInternal", true},
			{"query_test", true},
			{"NormalQuery", false},
		}

		for _, tc := range testCases {
			if config.IsQueryExcluded(tc.query) != tc.excluded {
				t.Errorf("expected IsQueryExcluded(%q) to be %v", tc.query, tc.excluded)
			}
		}
	})
}

func runLinter(dir string) ([]unusedsqlc.Message, error) {
	fset := token.NewFileSet()

	// Parse Go files in the directory
	pkgs, err := parser.ParseDir(fset, dir, nil, parser.ParseComments)
	if err != nil {
		return nil, err
	}

	var files []*ast.File
	for _, pkg := range pkgs {
		for _, file := range pkg.Files {
			files = append(files, file)
		}
	}

	// Run the linter using the exported Run function
	absDir, _ := filepath.Abs(dir)
	return unusedsqlc.Run(files, fset, absDir)
}