Function TestSQLAnalyzer_AnalyzeFixtures

cmd/gosqlx/cmd/sql_analyzer_test.go:65–166

(t *testing.T)

}

func TestSQLAnalyzer_AnalyzeFixtures(t *testing.T) {
	for testName, fixture := range testSQLFixtures {
		t.Run(testName, func(t *testing.T) {
			// Parse the SQL query
			tkz := tokenizer.GetTokenizer()
			defer tokenizer.PutTokenizer(tkz)

			tokens, err := tkz.Tokenize([]byte(fixture.sql))
			if err != nil {
				t.Fatalf("Tokenization failed: %v", err)
			}

			p := parser.NewParser()
			astObj := ast.NewAST()
			defer ast.ReleaseAST(astObj)

			result, err := p.ParseFromModelTokens(tokens)
			if err != nil {
				t.Fatalf("Parsing failed for %s: %v", fixture.name, err)
			}

			astObj.Statements = result.Statements

			// Analyze with our unified analyzer
			analyzer := NewSQLAnalyzer()
			report, err := analyzer.Analyze(astObj)
			if err != nil {
				t.Fatalf("Analysis failed for %s: %v", fixture.name, err)
			}

			// Verify expected issues are detected
			detectedIssueIDs := make(map[string]bool)
			for _, issue := range report.Issues {
				detectedIssueIDs[issue.ID] = true
			}

			// Check all expected issues are found
			for _, expectedID := range fixture.expectedIssues {
				if !detectedIssueIDs[expectedID] {
					t.Errorf("Expected issue %s not detected in %s", expectedID, fixture.name)
				}
			}

			// Check for unexpected issues (only if we expect a clean query)
			if len(fixture.expectedIssues) == 0 && len(report.Issues) > 0 {
				var issueIDs []string
				for _, issue := range report.Issues {
					issueIDs = append(issueIDs, issue.ID)
				}
				t.Errorf("Unexpected issues detected in clean query %s: %v", fixture.name, issueIDs)
			}

			// Verify score expectations
			if report.OverallScore < fixture.expectedScore {
				t.Errorf("Score too low for %s: got %d, expected at least %d",
					fixture.name, report.OverallScore, fixture.expectedScore)
			}