bench_test.go

package gogenfilter

import (
	"fmt"
	"io"
	"maps"
	"strings"
	"testing"
	"testing/fstest"
)

const (
	sqlcGeneratedContent     = "// Code generated by sqlc. DO NOT EDIT.\npackage db\n\ntype User struct {\n\tID int64\n\tName string\n}"
	protobufGeneratedContent = "// Code generated by protoc-gen-go. DO NOT EDIT.\npackage pb\n"
	genericGeneratedContent  = "// Code generated by some-tool. DO NOT EDIT.\npackage main\n"
)

func benchmarkFilter(b *testing.B, enabled bool) {
	b.Helper()

	fsys := fstest.MapFS{
		dbModelsGo: &fstest.MapFile{
			Data: []byte(sqlcGeneratedContent),
		},
	}

	var (
		filter *Filter
		err    error
	)

	if enabled {
		opts, optErr := WithFilterOptions(FilterAll)
		if optErr != nil {
			b.Fatal(optErr)
		}

		filter, err = NewFilter(opts, WithFS(fsys))
		if err != nil {
			b.Fatal(err)
		}
	} else {
		filter, err = NewFilter(WithFS(fsys))
		if err != nil {
			b.Fatal(err)
		}
	}

	for b.Loop() {
		_, _ = filter.Filter("db/models.go")
	}
}

func BenchmarkFilter(b *testing.B) {
	tests := []struct {
		name    string
		enabled bool
	}{
		{name: "enabled", enabled: true},
		{name: "disabled", enabled: false},
	}

	for _, tt := range tests {
		b.Run(tt.name, func(b *testing.B) {
			benchmarkFilter(b, tt.enabled)
		})
	}
}

func BenchmarkDetectGenerated(b *testing.B) {
	opts := optionsMap(FilterAll)

	for b.Loop() {
		_, _ = getFilenameBasedReasonWithTrace(dbModelsGo, opts)
	}
}

func benchmarkIsGenerated(b *testing.B, content string, fn func(string, string) bool) {
	b.Helper()

	for b.Loop() {
		_ = fn("file.go", content)
	}
}

func BenchmarkIsSQLCGenerated(b *testing.B) {
	benchmarkIsGenerated(
		b,
		sqlcGeneratedContent,
		IsSQLCGenerated,
	)
}

func BenchmarkIsProtobufGenerated(b *testing.B) {
	benchmarkIsGenerated(
		b,
		protobufGeneratedContent,
		IsProtobufGenerated,
	)
}

func BenchmarkIsGenericGenerated(b *testing.B) {
	benchmarkIsGenerated(
		b,
		genericGeneratedContent,
		IsGenericGenerated,
	)
}

func BenchmarkMatchPattern(b *testing.B) {
	tests := []struct {
		name    string
		path    string
		pattern string
	}{
		{name: "exact", path: fileGo, pattern: fileGo},
		{name: "wildcard", path: "test.go", pattern: wildcardGo},
		{name: "doublestar", path: "a/b/c/file.go", pattern: "**/*.go"},
		{name: "question", path: aGo, pattern: questionGo},
		{name: "no_match", path: "other.txt", pattern: wildcardGo},
	}

	for _, tt := range tests {
		b.Run(tt.name, func(b *testing.B) {
			for b.Loop() {
				_ = MatchPattern(tt.path, tt.pattern)
			}
		})
	}
}

func BenchmarkDetectReason(b *testing.B) {
	tests := []struct {
		name    string
		path    string
		content string
	}{
		{
			name:    "filename_only",
			path:    dbModelsGo,
			content: sqlcGeneratedContentTest,
		},
		{
			name:    "content_based",
			path:    customGenGo,
			content: myToolGenContentTest,
		},
	}

	for _, tt := range tests {
		b.Run(tt.name, func(b *testing.B) {
			for b.Loop() {
				_ = DetectReason(tt.path, tt.content, FilterAll)
			}
		})
	}

	b.Run("not_filtered", func(b *testing.B) {
		for b.Loop() {
			_ = DetectReason("main.go", "package main\n", FilterAll)
		}
	})
}

func BenchmarkDetectReasonReader(b *testing.B) {
	tests := []struct {
		name    string
		path    string
		content string
	}{
		{
			name:    "sqlc_filename",
			path:    dbModelsGo,
			content: sqlcGeneratedContent,
		},
		{
			name:    "not_filtered",
			path:    mainGo,
			content: packageMainFunc,
		},
	}

	for _, tt := range tests {
		b.Run(tt.name, func(b *testing.B) {
			for b.Loop() {
				reader := io.NopCloser(strings.NewReader(tt.content))
				_, _ = DetectReasonReader(tt.path, reader, FilterAll)
			}
		})
	}
}

func BenchmarkDetectReasonFileFS(b *testing.B) {
	fsys := fstest.MapFS{
		pageTemplGo: &fstest.MapFile{
			Data: []byte("package main\nfunc main() {}\n"),
		},
		"custom_gen.go": &fstest.MapFile{
			Data: []byte(genericGeneratedContent),
		},
		mainGo: &fstest.MapFile{
			Data: []byte(packageMainFunc),
		},
	}

	b.Run("filename_only", func(b *testing.B) {
		for b.Loop() {
			_, _ = DetectReasonFileFS(fsys, "page_templ.go", FilterAll)
		}
	})

	b.Run("content_based", func(b *testing.B) {
		for b.Loop() {
			_, _ = DetectReasonFileFS(fsys, "custom_gen.go", FilterAll)
		}
	})

	b.Run("not_filtered", func(b *testing.B) {
		for b.Loop() {
			_, _ = DetectReasonFileFS(fsys, mainGo, FilterAll)
		}
	})
}

// BenchmarkSQLCDerivedConfigForFS measures the cost of lazily discovering and
// parsing sqlc configs by walking a large filesystem with many directories.
// The "no_config" variant walks a large FS with zero sqlc.yaml files.
// The "with_config" variant includes a single sqlc.yaml at the root.
func BenchmarkSQLCDerivedConfigForFS(b *testing.B) {
	const numDirs = 200

	// Build a large MapFS with many directories and .go files, no sqlc config.
	largeFS := make(fstest.MapFS, numDirs*2+5)

	for i := range numDirs {
		dir := fmt.Sprintf("pkg/depth%d/file.go", i)
		largeFS[dir] = &fstest.MapFile{Data: []byte("package pkg\n")}
	}

	// Variant with a sqlc config at root.
	configFS := make(fstest.MapFS, len(largeFS)+1)
	maps.Copy(configFS, largeFS)

	configFS["sqlc.yaml"] = &fstest.MapFile{Data: []byte(sqlcConfigV2YAML())}

	b.Run("no_config_large_fs", func(b *testing.B) {
		for b.Loop() {
			_, _ = sqlcDerivedConfigForFS(largeFS, []string{"."})
		}
	})

	b.Run("with_config_large_fs", func(b *testing.B) {
		for b.Loop() {
			_, _ = sqlcDerivedConfigForFS(configFS, []string{"."})
		}
	})

	b.Run("empty_fs", func(b *testing.B) {
		emptyFS := fstest.MapFS{}
		for b.Loop() {
			_, _ = sqlcDerivedConfigForFS(emptyFS, []string{"."})
		}
	})
}

// BenchmarkFilterSQLCDerivedConfigCached measures the cost of the cached
// derived config lookup (second+ call should be O(1) via atomic.Pointer.Load).
func BenchmarkFilterSQLCDerivedConfigCached(b *testing.B) {
	fsys := fstest.MapFS{
		"sqlc.yaml":    &fstest.MapFile{Data: []byte(sqlcConfigV2YAML())},
		"db/models.go": &fstest.MapFile{Data: []byte("package db\n")},
	}

	opts, err := WithFilterOptions(FilterSQLC)
	if err != nil {
		b.Fatal(err)
	}

	filter, err := NewFilter(opts, WithFS(fsys))
	if err != nil {
		b.Fatal(err)
	}

	// Prime the cache with one call.
	result, _, _ := filter.FilterDetailedAndContent("db/models.go")
	_ = result

	b.ResetTimer()

	for b.Loop() {
		_ = filter.sqlcDerivedConfig()
	}
}

// BenchmarkFilterDetailedAndContent measures the cost of FilterDetailedAndContent
// including file reading and content return, for both filename-match (no content
// read) and content-match (content read and returned) paths.
func BenchmarkFilterDetailedAndContent(b *testing.B) {
	fsys := fstest.MapFS{
		"db/query.sql.go": &fstest.MapFile{Data: []byte(sqlcGeneratedContent)},
		"repository.go":   &fstest.MapFile{Data: []byte(genericGeneratedContent)},
		"main.go":         &fstest.MapFile{Data: []byte("package main\nfunc main() {}\n")},
	}

	opts, err := WithFilterOptions(FilterAll)
	if err != nil {
		b.Fatal(err)
	}

	filter, err := NewFilter(opts, WithFS(fsys))
	if err != nil {
		b.Fatal(err)
	}

	b.Run("filename_match_no_content", func(b *testing.B) {
		b.ResetTimer()

		for b.Loop() {
			_, _, _ = filter.FilterDetailedAndContent("db/query.sql.go")
		}
	})

	b.Run("content_match_returns_content", func(b *testing.B) {
		b.ResetTimer()

		for b.Loop() {
			_, _, _ = filter.FilterDetailedAndContent("repository.go")
		}
	})

	b.Run("not_filtered_reads_content", func(b *testing.B) {
		b.ResetTimer()

		for b.Loop() {
			_, _, _ = filter.FilterDetailedAndContent("main.go")
		}
	})
}