xtrm-tools 2.0.0

package/project-skills/tdd-guard/reporters/go/internal/parser/mixed_reader_test.go

@@ -0,0 +1,198 @@
+package parser
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestMixedReader_PassesJSONToParser(t *testing.T) {
+	input := `{"Action":"pass","Package":"example.com/pkg","Test":"TestExample"}`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if len(mr.JSONLines) != 1 {
+		t.Fatalf("Expected 1 JSON line, got %d", len(mr.JSONLines))
+	}
+
+	if mr.JSONLines[0] != input {
+		t.Errorf("Expected JSON line to be %q, got %q", input, mr.JSONLines[0])
+	}
+}
+
+func TestMixedReader_ReadsActualInput(t *testing.T) {
+	input := `{"Action":"fail","Package":"test/pkg","Test":"TestFail"}`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if mr.JSONLines[0] != input {
+		t.Errorf("Expected JSON line to be %q, got %q", input, mr.JSONLines[0])
+	}
+}
+
+func TestMixedReader_BuffersNonJSONLines(t *testing.T) {
+	input := "# command-line-arguments\n"
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if len(mr.NonJSONLines) != 1 {
+		t.Fatalf("Expected 1 non-JSON line, got %d", len(mr.NonJSONLines))
+	}
+
+	if mr.NonJSONLines[0] != "# command-line-arguments" {
+		t.Errorf("Expected non-JSON line to be %q, got %q", "# command-line-arguments", mr.NonJSONLines[0])
+	}
+}
+
+func TestMixedReader_SeparatesJSONFromNonJSON(t *testing.T) {
+	input := `{"Action":"pass","Package":"test"}
+# error line
+{"Action":"fail","Package":"test2"}`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if len(mr.JSONLines) != 2 {
+		t.Fatalf("Expected 2 JSON lines, got %d", len(mr.JSONLines))
+	}
+
+	if len(mr.NonJSONLines) != 1 {
+		t.Fatalf("Expected 1 non-JSON line, got %d", len(mr.NonJSONLines))
+	}
+
+	if mr.NonJSONLines[0] != "# error line" {
+		t.Errorf("Expected non-JSON line to be %q, got %q", "# error line", mr.NonJSONLines[0])
+	}
+}
+
+func TestMixedReader_DetectsCompilationError(t *testing.T) {
+	input := `# command-line-arguments
+single_import_error_test.go:5:2: no required module provides package github.com/non-existent/module
+FAIL	command-line-arguments [setup failed]`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if mr.CompilationError == nil {
+		t.Fatal("Expected compilation error to be detected")
+	}
+}
+
+func TestMixedReader_NoCompilationErrorForNormalOutput(t *testing.T) {
+	input := `{"Action":"pass","Package":"test","Test":"TestSomething"}`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if mr.CompilationError != nil {
+		t.Fatal("Expected no compilation error for normal JSON output")
+	}
+}
+
+func TestMixedReader_ExtractsPackageName(t *testing.T) {
+	input := `# command-line-arguments
+single_import_error_test.go:5:2: no required module provides package github.com/non-existent/module
+FAIL	command-line-arguments [setup failed]`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if mr.CompilationError == nil {
+		t.Fatal("Expected compilation error")
+	}
+	if mr.CompilationError.Package != "command-line-arguments" {
+		t.Errorf("Expected package name %q, got %q", "command-line-arguments", mr.CompilationError.Package)
+	}
+}
+
+func TestMixedReader_ExtractsDifferentPackageName(t *testing.T) {
+	input := `# github.com/example/pkg
+error.go:10:5: undefined: SomeFunction`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if mr.CompilationError == nil {
+		t.Fatal("Expected compilation error")
+	}
+	if mr.CompilationError.Package != "github.com/example/pkg" {
+		t.Errorf("Expected package name %q, got %q", "github.com/example/pkg", mr.CompilationError.Package)
+	}
+}
+
+func TestMixedReader_GetCompilationErrorMessage(t *testing.T) {
+	input := `# command-line-arguments
+single_import_error_test.go:5:2: no required module provides package github.com/non-existent/module
+FAIL	command-line-arguments [setup failed]`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if mr.CompilationError == nil {
+		t.Fatal("Expected compilation error")
+	}
+	expected := "single_import_error_test.go:5:2: no required module provides package github.com/non-existent/module"
+	if len(mr.CompilationError.Messages) != 1 || mr.CompilationError.Messages[0] != expected {
+		t.Errorf("Expected error message %q, got %v", expected, mr.CompilationError.Messages)
+	}
+}
+
+func TestMixedReader_GetDifferentCompilationErrorMessage(t *testing.T) {
+	input := `# github.com/example/pkg
+main.go:10:5: undefined: SomeFunction`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if mr.CompilationError == nil {
+		t.Fatal("Expected compilation error")
+	}
+	expected := "main.go:10:5: undefined: SomeFunction"
+	if len(mr.CompilationError.Messages) != 1 || mr.CompilationError.Messages[0] != expected {
+		t.Errorf("Expected error message %q, got %v", expected, mr.CompilationError.Messages)
+	}
+}
+
+func TestMixedReader_CapturesMultipleErrorLines(t *testing.T) {
+	// Test that multiple error lines are captured
+	input := `# example.com/pkg
+example.go:9:8: undefined: NewFormatter
+example.go:10:12: undefined: TestEvent
+{"Action":"fail","Package":"example.com/pkg","Elapsed":0}`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	if mr.CompilationError == nil {
+		t.Fatal("Expected compilation error")
+	}
+
+	// Should capture both error lines
+	if len(mr.CompilationError.Messages) != 2 {
+		t.Fatalf("Expected 2 error messages, got %d", len(mr.CompilationError.Messages))
+	}
+
+	if mr.CompilationError.Messages[0] != "example.go:9:8: undefined: NewFormatter" {
+		t.Errorf("Expected first error message to be 'example.go:9:8: undefined: NewFormatter', got %q", mr.CompilationError.Messages[0])
+	}
+
+	if mr.CompilationError.Messages[1] != "example.go:10:12: undefined: TestEvent" {
+		t.Errorf("Expected second error message to be 'example.go:10:12: undefined: TestEvent', got %q", mr.CompilationError.Messages[1])
+	}
+}
+
+func TestMixedReader_HandlesShortLines(t *testing.T) {
+	// This could cause a panic if we try to access line[:4] on "OK"
+	input := `# pkg
+OK`
+	reader := strings.NewReader(input)
+
+	mr := NewMixedReader(reader)
+
+	// Should not panic
+	if mr.CompilationError != nil {
+		// OK is not an error message, just checking it doesn't panic
+	}
+}

package/project-skills/tdd-guard/reporters/go/internal/parser/parser.go

@@ -0,0 +1,245 @@
+package parser
+
+import (
+	"bufio"
+	"encoding/json"
+	"io"
+	"strings"
+)
+
+// TestEvent represents a test event from go test -json
+type TestEvent struct {
+	Action      string  `json:"Action"`
+	Package     string  `json:"Package"`
+	Test        string  `json:"Test"`
+	Elapsed     float64 `json:"Elapsed"`
+	Output      string  `json:"Output"`
+	ImportPath  string  `json:"ImportPath"`
+	FailedBuild string  `json:"FailedBuild"`
+}
+
+// TestState represents the state of a test
+type TestState string
+
+const (
+	StatePassed  TestState = "passed"
+	StateFailed  TestState = "failed"
+	StateSkipped TestState = "skipped"
+)
+
+// PackageResults holds test results for a package
+type PackageResults map[string]TestState
+
+// Results holds all package results
+type Results map[string]PackageResults
+
+// Parser parses go test JSON output
+type Parser struct {
+	results       Results
+	errorOutputs  map[string]string
+	testOutputs   map[string]map[string]string // Track test output content
+	buildFailures map[string]string            // Track build failures and their output
+}
+
+// NewParser creates a new parser
+func NewParser() *Parser {
+	return &Parser{
+		results:       make(Results),
+		errorOutputs:  make(map[string]string),
+		testOutputs:   make(map[string]map[string]string),
+		buildFailures: make(map[string]string),
+	}
+}
+
+// Parse reads from the provided reader
+func (p *Parser) Parse(reader io.Reader) error {
+	scanner := bufio.NewScanner(reader)
+
+	for scanner.Scan() {
+		var event TestEvent
+		if err := json.Unmarshal(scanner.Bytes(), &event); err != nil {
+			continue // Skip malformed JSON
+		}
+
+		p.processEvent(&event)
+	}
+
+	return scanner.Err()
+}
+
+// processEvent handles a single test event
+func (p *Parser) processEvent(event *TestEvent) {
+	// Handle build events (they have ImportPath instead of Package)
+	if event.ImportPath != "" && event.Action == "build-output" {
+		p.buildFailures[event.ImportPath] += event.Output
+		return
+	}
+
+	// Handle build failure events
+	if event.Action == "fail" && event.FailedBuild != "" {
+		p.ensurePackageExists(event.Package)
+		p.results[event.Package]["CompilationError"] = StateFailed
+		return
+	}
+
+	// Skip events without package
+	if event.Package == "" {
+		return
+	}
+
+	p.ensurePackageExists(event.Package)
+
+	if event.Test == "" {
+		p.processPackageEvent(event)
+		return
+	}
+
+	p.processTestEvent(event)
+}
+
+// ensurePackageExists creates package maps if they don't exist
+func (p *Parser) ensurePackageExists(pkg string) {
+	if p.results[pkg] == nil {
+		p.results[pkg] = make(PackageResults)
+	}
+}
+
+// processPackageEvent handles package-level events (no test name)
+func (p *Parser) processPackageEvent(event *TestEvent) {
+	if event.Action == "output" {
+		p.errorOutputs[event.Package] += event.Output
+	}
+	// Handle package-level fail (build failure without FailedBuild flag)
+	if event.Action == "fail" {
+		// Package failed but has no tests - this is a build failure
+		if len(p.results[event.Package]) == 0 {
+			p.results[event.Package]["CompilationError"] = StateFailed
+		}
+	}
+}
+
+// processTestEvent handles test-specific events
+func (p *Parser) processTestEvent(event *TestEvent) {
+	switch event.Action {
+	case "output":
+		p.captureTestOutput(event)
+	case "pass", "fail", "skip":
+		p.recordTestState(event)
+	}
+}
+
+// captureTestOutput captures output for a specific test
+func (p *Parser) captureTestOutput(event *TestEvent) {
+	if p.testOutputs[event.Package] == nil {
+		p.testOutputs[event.Package] = make(map[string]string)
+	}
+
+	// Skip RUN and FAIL lines
+	if strings.HasPrefix(event.Output, "=== RUN") || strings.HasPrefix(event.Output, "--- FAIL") {
+		return
+	}
+
+	// Trim leading whitespace and append to existing output
+	p.testOutputs[event.Package][event.Test] += strings.TrimLeft(event.Output, " \t")
+}
+
+// recordTestState records the final state of a test
+func (p *Parser) recordTestState(event *TestEvent) {
+	var state TestState
+	switch event.Action {
+	case "pass":
+		state = StatePassed
+		p.ensureTestOutputExists(event.Package, event.Test)
+	case "fail":
+		state = StateFailed
+	case "skip":
+		state = StateSkipped
+	}
+
+	p.results[event.Package][event.Test] = state
+}
+
+// ensureTestOutputExists ensures test output map exists for passed tests
+func (p *Parser) ensureTestOutputExists(pkg, test string) {
+	if p.testOutputs[pkg] == nil {
+		p.testOutputs[pkg] = make(map[string]string)
+	}
+	if _, exists := p.testOutputs[pkg][test]; !exists {
+		p.testOutputs[pkg][test] = ""
+	}
+}
+
+// GetResults returns the parsed results with parent tests filtered out
+func (p *Parser) GetResults() Results {
+	filtered := make(Results)
+
+	for pkg, tests := range p.results {
+		filtered[pkg] = filterParentTests(tests)
+	}
+
+	return filtered
+}
+
+// filterParentTests removes tests that have subtests from the results
+func filterParentTests(tests PackageResults) PackageResults {
+	filtered := make(PackageResults)
+
+	for testName, testState := range tests {
+		if !hasSubtests(testName, tests) {
+			filtered[testName] = testState
+		}
+	}
+
+	return filtered
+}
+
+// hasSubtests checks if a test has any subtests
+func hasSubtests(testName string, allTests PackageResults) bool {
+	for otherTest := range allTests {
+		if isSubtestOf(otherTest, testName) {
+			return true
+		}
+	}
+	return false
+}
+
+// isSubtestOf checks if child is a subtest of parent
+func isSubtestOf(child, parent string) bool {
+	return len(child) > len(parent) &&
+		child[:len(parent)] == parent &&
+		child[len(parent)] == '/'
+}
+
+// GetErrorOutput returns captured error output for a package
+func (p *Parser) GetErrorOutput(pkg string) string {
+	return p.errorOutputs[pkg]
+}
+
+// GetTestOutput returns captured output for a specific test
+func (p *Parser) GetTestOutput(pkg, test string) string {
+	// Special case for CompilationError - get build failure message
+	if test == "CompilationError" {
+		// Find the build failure for this package
+		for _, msg := range p.buildFailures {
+			// The build failure message contains the error details
+			if msg != "" {
+				return strings.TrimSpace(msg)
+			}
+		}
+	}
+
+	if p.testOutputs[pkg] == nil {
+		return ""
+	}
+	output, exists := p.testOutputs[pkg][test]
+	if !exists {
+		return ""
+	}
+	// Trim trailing whitespace/newlines
+	return strings.TrimRight(output, "\n")
+}
+
+// GetBuildFailure returns captured build failure output for a package
+func (p *Parser) GetBuildFailure(importPath string) string {
+	return p.buildFailures[importPath]
+}