feat: standardize tree-sitter test implementations

Standardized tree-sitter test implementations across all supported languages:
- Removed debugLog calls from test files
- Implemented consistent line number pattern matching
- Ensured proper test structure and execution order
- Added comprehensive test coverage for supported structures
- Maintained 1:1 mapping between queries, tests and samples
- Documented unsupported features in TODO sections

Signed-off-by: Eric Wheeler <[email protected]>

Author: Eric Wheeler

src/services/tree-sitter/__tests__/helpers.ts

@@ -4,6 +4,7 @@ import * as fs from "fs/promises"
 import * as path from "path"
 import Parser from "web-tree-sitter"
 import tsxQuery from "../queries/tsx"
+import goQuery from "../queries/go"
 // Mock setup
 jest.mock("fs/promises")
 export const mockedFs = jest.mocked(fs)

src/services/tree-sitter/__tests__/inspectCSS.test.ts

@@ -3,23 +3,25 @@ import { inspectTreeStructure, testParseSourceCodeDefinitions } from "./helpers"
 import { cssQuery } from "../queries"
 import sampleCSSContent from "./fixtures/sample-css"
 
-describe("inspectCSS", () => {
+describe("CSS Tree-sitter Parser", () => {
 	const testOptions = {
 		language: "css",
 		wasmFile: "tree-sitter-css.wasm",
 		queryString: cssQuery,
 		extKey: "css",
-		debug: true,
 	}
 
-	it("should inspect CSS tree structure", async () => {
+	it("should properly parse CSS structures", async () => {
+		// First run inspectTreeStructure to get query structure output
 		await inspectTreeStructure(sampleCSSContent, "css")
-	})
 
-	it("should parse CSS definitions", async () => {
+		// Then run testParseSourceCodeDefinitions to get line numbers
 		const result = await testParseSourceCodeDefinitions("test.css", sampleCSSContent, testOptions)
+		expect(result).toBeDefined()
 		if (!result) {
 			throw new Error("No result returned from parser")
 		}
+		expect(result).toMatch(/\d+--\d+ \|/)
+		expect(result.split("\n").length).toBeGreaterThan(1)
 	})
 })

src/services/tree-sitter/__tests__/inspectCSharp.test.ts

@@ -12,10 +12,13 @@ describe("inspectCSharp", () => {
 	}
 
 	it("should inspect C# tree structure", async () => {
-		await inspectTreeStructure(sampleCSharpContent, "c_sharp")
+		// Should execute without throwing
+		await expect(inspectTreeStructure(sampleCSharpContent, "c_sharp")).resolves.not.toThrow()
 	})
 
 	it("should parse C# definitions", async () => {
-		await testParseSourceCodeDefinitions("test.cs", sampleCSharpContent, testOptions)
+		const result = await testParseSourceCodeDefinitions("test.cs", sampleCSharpContent, testOptions)
+		expect(result).toBeDefined()
+		expect(result).toMatch(/\d+--\d+ \|/)
 	})
 })

src/services/tree-sitter/__tests__/inspectCpp.test.ts

@@ -1,21 +1,23 @@
-import { describe, it } from "@jest/globals"
+import { describe, it, expect } from "@jest/globals"
 import { inspectTreeStructure, testParseSourceCodeDefinitions } from "./helpers"
 import { cppQuery } from "../queries"
 import sampleCppContent from "./fixtures/sample-cpp"
 
-describe("inspectCpp", () => {
+describe("C++ Tree-sitter Parser", () => {
 	const testOptions = {
 		language: "cpp",
 		wasmFile: "tree-sitter-cpp.wasm",
 		queryString: cppQuery,
 		extKey: "cpp",
 	}
 
-	it("should inspect C++ tree structure", async () => {
+	it("should properly parse structures", async () => {
+		// First run inspectTreeStructure to get query structure output
 		await inspectTreeStructure(sampleCppContent, "cpp")
-	})
 
-	it("should parse C++ definitions", async () => {
-		await testParseSourceCodeDefinitions("test.cpp", sampleCppContent, testOptions)
+		// Then run testParseSourceCodeDefinitions to get line numbers
+		const result = await testParseSourceCodeDefinitions("test.cpp", sampleCppContent, testOptions)
+		expect(result).toBeDefined()
+		expect(result).toMatch(/\d+--\d+ \|/)
 	})
 })

src/services/tree-sitter/__tests__/inspectElisp.test.ts

@@ -11,11 +11,19 @@ describe("inspectElisp", () => {
 		extKey: "el",
 	}
 
-	it("should inspect Elisp tree structure", async () => {
-		await inspectTreeStructure(sampleElispContent, "elisp")
+	it("should validate Elisp tree structure inspection", async () => {
+		const result = await inspectTreeStructure(sampleElispContent, "elisp")
+		expect(result).toBeDefined()
+		expect(result.length).toBeGreaterThan(0)
 	})
 
-	it("should parse Elisp definitions", async () => {
-		await testParseSourceCodeDefinitions("test.el", sampleElispContent, testOptions)
+	it("should validate Elisp definitions parsing", async () => {
+		const result = await testParseSourceCodeDefinitions("test.el", sampleElispContent, testOptions)
+		expect(result).toBeDefined()
+		expect(result).toMatch(/\d+--\d+ \|/) // Verify line number format
+
+		// Verify some sample content is parsed
+		expect(result).toMatch(/defun test-function/)
+		expect(result).toMatch(/defmacro test-macro/)
 	})
 })

src/services/tree-sitter/__tests__/inspectElixir.test.ts

@@ -12,10 +12,15 @@ describe("inspectElixir", () => {
 	}
 
 	it("should inspect Elixir tree structure", async () => {
-		await inspectTreeStructure(sampleElixirContent, "elixir")
+		const result = await inspectTreeStructure(sampleElixirContent, "elixir")
+		expect(result).toBeDefined()
+		expect(result.length).toBeGreaterThan(0)
 	})
 
 	it("should parse Elixir definitions", async () => {
-		await testParseSourceCodeDefinitions("test.ex", sampleElixirContent, testOptions)
+		const result = await testParseSourceCodeDefinitions("test.ex", sampleElixirContent, testOptions)
+		expect(result).toBeDefined()
+		expect(result).toContain("--")
+		expect(result).toMatch(/\d+--\d+ \|/)
 	})
 })

src/services/tree-sitter/__tests__/inspectEmbeddedTemplate.test.ts

@@ -8,14 +8,17 @@ describe("inspectEmbeddedTemplate", () => {
 		language: "embedded_template",
 		wasmFile: "tree-sitter-embedded_template.wasm",
 		queryString: embeddedTemplateQuery,
-		extKey: "embedded_template",
+		extKey: "erb", // Match the file extension we're using
 	}
 
 	it("should inspect embedded template tree structure", async () => {
-		await inspectTreeStructure(sampleEmbeddedTemplateContent, "embedded_template")
+		const result = await inspectTreeStructure(sampleEmbeddedTemplateContent, "embedded_template")
+		expect(result).toBeTruthy()
 	})
 
 	it("should parse embedded template definitions", async () => {
-		await testParseSourceCodeDefinitions("test.erb", sampleEmbeddedTemplateContent, testOptions)
+		const result = await testParseSourceCodeDefinitions("test.erb", sampleEmbeddedTemplateContent, testOptions)
+		expect(result).toBeTruthy()
+		expect(result).toMatch(/\d+--\d+ \|/) // Verify line number format
 	})
 })

src/services/tree-sitter/__tests__/inspectGo.test.ts

@@ -1,9 +1,24 @@
-import { describe, test } from "@jest/globals"
-import { inspectTreeStructure } from "./helpers"
+import { describe, it, expect } from "@jest/globals"
+import { inspectTreeStructure, testParseSourceCodeDefinitions } from "./helpers"
 import sampleGoContent from "./fixtures/sample-go"
+import goQuery from "../queries/go"
 
-describe("Go Structure Tests", () => {
-	test("should output Go structures", async () => {
+describe("Go Tree-sitter Parser", () => {
+	// Test 1: Get query structure output
+	it("should inspect tree structure", async () => {
 		await inspectTreeStructure(sampleGoContent, "go")
 	})
+
+	// Test 2: Get line numbers
+	it("should parse source code definitions", async () => {
+		const testOptions = {
+			language: "go",
+			wasmFile: "tree-sitter-go.wasm",
+			queryString: goQuery,
+			extKey: "go",
+		}
+
+		const result = await testParseSourceCodeDefinitions("file.go", sampleGoContent, testOptions)
+		expect(result).toBeDefined()
+	})
 })

src/services/tree-sitter/__tests__/inspectHtml.test.ts

@@ -12,10 +12,13 @@ describe("inspectHtml", () => {
 	}
 
 	it("should inspect HTML tree structure", async () => {
-		await inspectTreeStructure(sampleHtmlContent, "html")
+		// Should execute without error
+		await expect(inspectTreeStructure(sampleHtmlContent, "html")).resolves.not.toThrow()
 	})
 
 	it("should parse HTML definitions", async () => {
-		await testParseSourceCodeDefinitions("test.html", sampleHtmlContent, testOptions)
+		const result = await testParseSourceCodeDefinitions("test.html", sampleHtmlContent, testOptions)
+		expect(result).toBeDefined()
+		expect(result).toMatch(/\d+--\d+ \| </)
 	})
 })

src/services/tree-sitter/__tests__/inspectJava.test.ts

@@ -12,10 +12,13 @@ describe("inspectJava", () => {
 	}
 
 	it("should inspect Java tree structure", async () => {
-		await inspectTreeStructure(sampleJavaContent, "java")
+		const result = await inspectTreeStructure(sampleJavaContent, "java")
+		expect(result).toBeTruthy()
 	})
 
 	it("should parse Java definitions", async () => {
-		await testParseSourceCodeDefinitions("test.java", sampleJavaContent, testOptions)
+		const result = await testParseSourceCodeDefinitions("test.java", sampleJavaContent, testOptions)
+		expect(result).toBeTruthy()
+		expect(result).toMatch(/\d+--\d+ \| /) // Verify line number format
 	})
 })