snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

tools/mattermost-govet/concurrentIndex/concurrentIndex_test.go

@@ -0,0 +1,208 @@
+package concurrentIndex
+
+import (
+	"go/token"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/tools/go/analysis"
+	"golang.org/x/tools/go/analysis/analysistest"
+)
+
+func TestGoFiles(t *testing.T) {
+	testdata := analysistest.TestData()
+	analysistest.Run(t, testdata, Analyzer, "a")
+}
+
+func TestSQLDir(t *testing.T) {
+	testdata := analysistest.TestData()
+	migrationsDir := filepath.Join(testdata, "migrations")
+
+	fset := token.NewFileSet()
+	var diags []analysis.Diagnostic
+	pass := &analysis.Pass{
+		Analyzer: Analyzer,
+		Fset:     fset,
+		Report: func(d analysis.Diagnostic) {
+			diags = append(diags, d)
+		},
+	}
+
+	err := scanSQLDir(pass, migrationsDir)
+	require.NoError(t, err)
+
+	var files []string
+	for _, d := range diags {
+		pos := fset.Position(d.Pos)
+		files = append(files, filepath.Base(pos.Filename)+":"+d.Message)
+	}
+
+	createCount := 0
+	dropCount := 0
+	for _, f := range files {
+		switch {
+		case strings.Contains(f, diagCreateIndex):
+			createCount++
+		case strings.Contains(f, diagDropIndex):
+			dropCount++
+		}
+	}
+	assert.Equal(t, 4, createCount, "expected 4 CREATE INDEX diagnostics")
+	assert.Equal(t, 2, dropCount, "expected 2 DROP INDEX diagnostics")
+
+	badCount := 0
+	nestedCount := 0
+	multilineCount := 0
+	multistmtCount := 0
+	for _, f := range files {
+		switch {
+		case strings.HasPrefix(f, "000002_bad"):
+			badCount++
+		case strings.HasPrefix(f, "000003_nested"):
+			nestedCount++
+		case strings.HasPrefix(f, "000004_multiline"):
+			multilineCount++
+		case strings.HasPrefix(f, "000005_multistmt"):
+			multistmtCount++
+		}
+	}
+	assert.Equal(t, 3, badCount, "expected 3 diagnostics from 000002_bad.up.sql")
+	assert.Equal(t, 1, nestedCount, "expected 1 diagnostic from sub/000003_nested.up.sql")
+	assert.Equal(t, 1, multilineCount, "expected 1 diagnostic from 000004_multiline.up.sql")
+	assert.Equal(t, 1, multistmtCount, "expected 1 diagnostic from 000005_multistmt.up.sql")
+
+	for _, f := range files {
+		assert.NotContains(t, f, "000001_good",
+			"good migration file should not have diagnostics")
+	}
+}
+
+func TestSQLDirBadPath(t *testing.T) {
+	fset := token.NewFileSet()
+	pass := &analysis.Pass{
+		Analyzer: Analyzer,
+		Fset:     fset,
+		Report:   func(d analysis.Diagnostic) {},
+	}
+
+	err := scanSQLDir(pass, "/nonexistent/path")
+	assert.NoError(t, err)
+}
+
+func TestSQLDirMinMigration(t *testing.T) {
+	testdata := analysistest.TestData()
+	migrationsDir := filepath.Join(testdata, "migrations")
+
+	old := minMigration
+	t.Cleanup(func() { minMigration = old })
+	minMigration = 5
+
+	fset := token.NewFileSet()
+	var diags []analysis.Diagnostic
+	pass := &analysis.Pass{
+		Analyzer: Analyzer,
+		Fset:     fset,
+		Report: func(d analysis.Diagnostic) {
+			diags = append(diags, d)
+		},
+	}
+
+	err := scanSQLDir(pass, migrationsDir)
+	require.NoError(t, err)
+
+	for _, d := range diags {
+		pos := fset.Position(d.Pos)
+		base := filepath.Base(pos.Filename)
+		n := getMigrationNumberFromFilename(base)
+		require.GreaterOrEqual(t, n, 0, "expected numeric prefix in %s", base)
+		assert.GreaterOrEqual(t, n, 5,
+			"expected only migrations >= 5, got diagnostic from %s", base)
+	}
+	assert.Equal(t, 1, len(diags), "expected 1 diagnostic from migration 5+")
+}
+
+func TestCheckLine(t *testing.T) {
+	tests := []struct {
+		name    string
+		line    string
+		wantMsg string
+	}{
+		{
+			name:    "CREATE INDEX without CONCURRENTLY",
+			line:    "CREATE INDEX IF NOT EXISTS idx_foo_bar ON foo (bar);",
+			wantMsg: diagCreateIndex,
+		},
+		{
+			name:    "CREATE UNIQUE INDEX without CONCURRENTLY",
+			line:    "CREATE UNIQUE INDEX IF NOT EXISTS idx_foo_bar ON foo (bar);",
+			wantMsg: diagCreateIndex,
+		},
+		{
+			name:    "DROP INDEX without CONCURRENTLY",
+			line:    "DROP INDEX IF EXISTS idx_foo_bar;",
+			wantMsg: diagDropIndex,
+		},
+		{
+			name:    "lowercase create index",
+			line:    "create index if not exists idx_foo on foo (bar);",
+			wantMsg: diagCreateIndex,
+		},
+		{
+			name:    "lowercase drop index",
+			line:    "drop index if exists idx_foo;",
+			wantMsg: diagDropIndex,
+		},
+		{
+			name: "CREATE INDEX CONCURRENTLY is fine",
+			line: "CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_foo_bar ON foo (bar);",
+		},
+		{
+			name: "CREATE UNIQUE INDEX CONCURRENTLY is fine",
+			line: "CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS idx_foo_bar ON foo (bar);",
+		},
+		{
+			name: "DROP INDEX CONCURRENTLY is fine",
+			line: "DROP INDEX CONCURRENTLY IF EXISTS idx_foo_bar;",
+		},
+		{
+			name: "unrelated SQL",
+			line: "CREATE TABLE foo (id int);",
+		},
+		{
+			name: "SELECT statement",
+			line: "SELECT * FROM indexes;",
+		},
+		{
+			name: "plain string",
+			line: "just a regular string",
+		},
+		{
+			name:    "multi-statement with unsafe and safe",
+			line:    "CREATE INDEX idx_a ON t (c); CREATE INDEX CONCURRENTLY idx_b ON t (c);",
+			wantMsg: diagCreateIndex,
+		},
+		{
+			name:    "multi-statement with safe then unsafe drop",
+			line:    "DROP INDEX CONCURRENTLY IF EXISTS idx_a; DROP INDEX IF EXISTS idx_b;",
+			wantMsg: diagDropIndex,
+		},
+		{
+			name: "multi-statement all safe",
+			line: "CREATE INDEX CONCURRENTLY idx_a ON t (c); DROP INDEX CONCURRENTLY IF EXISTS idx_b;",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			msg := checkLine(tt.line)
+			if tt.wantMsg == "" {
+				assert.Empty(t, msg)
+			} else {
+				assert.Equal(t, tt.wantMsg, msg)
+			}
+		})
+	}
+}