xtrm-tools 2.2.0 → 2.4.0

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

@@ -1,198 +0,0 @@
-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

@@ -1,245 +0,0 @@
-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]
-}