xtrm-tools 2.0.0

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

@@ -0,0 +1,126 @@
+package formatter
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/nizos/tdd-guard/reporters/go/internal/parser"
+)
+
+// Formatter converts go test JSON events to standard go test output format.
+// It reduces verbose JSON output to concise, human-readable test results.
+type Formatter struct {
+	handlers map[string]eventHandler
+}
+
+type eventHandler func(event parser.TestEvent) string
+
+func NewFormatter() *Formatter {
+	f := &Formatter{}
+	f.initHandlers()
+	return f
+}
+
+func (f *Formatter) initHandlers() {
+	returnEmpty := func(event parser.TestEvent) string { return "" }
+
+	f.handlers = map[string]eventHandler{
+		"start":        returnEmpty,
+		"run":          returnEmpty,
+		"build-output": f.handleBuildOutput,
+		"build-fail":   f.handleBuildFail,
+		"output":       f.handleOutput,
+		"pass":         f.handlePass,
+		"fail":         f.handleFail,
+	}
+}
+
+func (f *Formatter) Format(event parser.TestEvent) string {
+	handler, exists := f.handlers[event.Action]
+	if !exists {
+		return f.handleUnknown(event)
+	}
+	return handler(event)
+}
+
+func (f *Formatter) handleBuildOutput(event parser.TestEvent) string {
+	return trimNewline(event.Output)
+}
+
+func (f *Formatter) handleBuildFail(event parser.TestEvent) string {
+	if event.Package != "" {
+		return fmt.Sprintf("BUILD FAILED\t%s", event.Package)
+	}
+	return "BUILD FAILED"
+}
+
+// handleOutput filters redundant output lines and preserves error messages.
+// Removes duplicate package summaries (we generate our own from pass/fail events)
+// and test execution markers while keeping actual test failures and error details.
+func (f *Formatter) handleOutput(event parser.TestEvent) string {
+	output := event.Output
+
+	switch {
+	case output == "PASS\n":
+		return "" // Filtered - redundant with package pass event
+	case output == "FAIL\n":
+		return "FAIL"
+	case strings.HasPrefix(output, "exit status"):
+		return trimNewline(output)
+	case strings.HasPrefix(output, "ok  \t"):
+		return "" // Filtered - we generate from pass event
+	case strings.HasPrefix(output, "FAIL\t"):
+		// Keep all FAIL output to preserve error information
+		return trimNewline(output)
+	}
+
+	if event.Test != "" {
+		switch {
+		case strings.HasPrefix(output, "=== RUN"), strings.HasPrefix(output, "--- PASS:"):
+			return "" // Filter verbose test markers
+		case strings.HasPrefix(output, "--- FAIL:"), strings.Contains(output, ":"):
+			return trimNewline(output) // Keep failure details and error messages
+		default:
+			return trimNewline(output)
+		}
+	}
+
+	if output != "" {
+		return trimNewline(output)
+	}
+
+	return ""
+}
+
+// handlePass generates the "ok" summary line for successful package tests.
+// Individual test pass events are filtered to reduce output noise.
+func (f *Formatter) handlePass(event parser.TestEvent) string {
+	if event.Package != "" && event.Test == "" {
+		return fmt.Sprintf("ok  \t%s\t%.3fs", event.Package, event.Elapsed)
+	}
+	return "" // Filter individual test passes
+}
+
+// handleFail generates the "FAIL" summary line for failed package tests.
+// Shows build failures with package information for better error visibility.
+func (f *Formatter) handleFail(event parser.TestEvent) string {
+	if event.Package != "" && event.Test == "" {
+		if event.FailedBuild != "" {
+			return fmt.Sprintf("FAIL\t%s [build failed]", event.Package)
+		}
+		return fmt.Sprintf("FAIL\t%s\t%.3fs", event.Package, event.Elapsed)
+	}
+	// Show individual test failure summaries for better error tracking
+	if event.Test != "" {
+		return fmt.Sprintf("FAIL\t%s/%s", event.Package, event.Test)
+	}
+	return ""
+}
+
+func (f *Formatter) handleUnknown(event parser.TestEvent) string {
+	return fmt.Sprintf("%s: %s", event.Action, trimNewline(event.Output))
+}
+
+func trimNewline(s string) string {
+	return strings.TrimSuffix(s, "\n")
+}

package/project-skills/tdd-guard/reporters/go/internal/formatter/formatter_test.go

@@ -0,0 +1,264 @@
+package formatter
+
+import (
+	"testing"
+
+	"github.com/nizos/tdd-guard/reporters/go/internal/parser"
+)
+
+func TestFormatter(t *testing.T) {
+	t.Run("NewFormatter", func(t *testing.T) {
+		formatter := NewFormatter()
+		if formatter == nil {
+			t.Fatal("Expected NewFormatter to return a formatter instance")
+		}
+	})
+
+	t.Run("FormatMethodExists", func(t *testing.T) {
+		formatter := NewFormatter()
+		event := parser.TestEvent{}
+		_ = formatter.Format(event)
+	})
+
+	t.Run("TestFilterStartEvents", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{Action: "start"})
+		if result != "" {
+			t.Fatal("Expected start events to be filtered out")
+		}
+	})
+
+	t.Run("TestFilterRunEvents", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{Action: "run"})
+		if result != "" {
+			t.Fatal("Expected run events to be filtered out")
+		}
+	})
+
+	t.Run("TestFilterPASSOutput", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action: "output",
+			Output: "PASS\n",
+		})
+		if result != "" {
+			t.Fatalf("Expected PASS output to be filtered, got '%s'", result)
+		}
+	})
+
+	t.Run("TestPassThroughFAILOutput", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action: "output",
+			Output: "FAIL\n",
+		})
+		if result != "FAIL" {
+			t.Fatalf("Expected 'FAIL' but got '%s'", result)
+		}
+	})
+
+	t.Run("TestPassThroughTestFailureOutput", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action: "output",
+			Test:   "TestCalculator/TestShouldAddNumbersCorrectly",
+			Output: "    single_failing_test.go:10: Expected 6 but got 5\n",
+		})
+		expected := "    single_failing_test.go:10: Expected 6 but got 5"
+		if result != expected {
+			t.Fatalf("Expected '%s' but got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestFormatPackagePassSummary", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "pass",
+			Package: "command-line-arguments",
+			Elapsed: 0.002,
+		})
+		expected := "ok  \tcommand-line-arguments\t0.002s"
+		if result != expected {
+			t.Fatalf("Expected '%s' but got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestFormatPackageFailSummary", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "fail",
+			Package: "command-line-arguments",
+			Elapsed: 0.002,
+		})
+		expected := "FAIL\tcommand-line-arguments\t0.002s"
+		if result != expected {
+			t.Fatalf("Expected '%s' but got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestShowPackageFailWithBuildFailure", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:      "fail",
+			Package:     "command-line-arguments",
+			Elapsed:     0,
+			FailedBuild: "github.com/non-existent/module",
+		})
+		expected := "FAIL\tcommand-line-arguments [build failed]"
+		if result != expected {
+			t.Fatalf("Expected '%s', got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestFilterTestLevelPassEvents", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "pass",
+			Package: "command-line-arguments",
+			Test:    "TestCalculator",
+			Elapsed: 0.001,
+		})
+		if result != "" {
+			t.Fatalf("Expected test-level pass events to be filtered out, got '%s'", result)
+		}
+	})
+
+	t.Run("TestShowTestLevelFailEvents", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "fail",
+			Package: "command-line-arguments",
+			Test:    "TestCalculator",
+			Elapsed: 0.001,
+		})
+		expected := "FAIL\tcommand-line-arguments/TestCalculator"
+		if result != expected {
+			t.Fatalf("Expected '%s', got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestFilterRunOutputEvents", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "output",
+			Package: "singlePassingTestModule",
+			Test:    "TestCalculator",
+			Output:  "=== RUN   TestCalculator\n",
+		})
+		if result != "" {
+			t.Fatalf("Expected RUN output events to be filtered out, got '%s'", result)
+		}
+	})
+
+	t.Run("TestFilterPassOutputEvents", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "output",
+			Package: "singlePassingTestModule",
+			Test:    "TestCalculator",
+			Output:  "--- PASS: TestCalculator (0.00s)\n",
+		})
+		if result != "" {
+			t.Fatalf("Expected PASS output events to be filtered out, got '%s'", result)
+		}
+	})
+
+	t.Run("TestShowFailOutputEvents", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "output",
+			Package: "singlePassingTestModule",
+			Test:    "TestCalculator",
+			Output:  "--- FAIL: TestCalculator (0.00s)\n",
+		})
+		expected := "--- FAIL: TestCalculator (0.00s)"
+		if result != expected {
+			t.Fatalf("Expected '%s', got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestFilterPackageOkOutput", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "output",
+			Package: "singlePassingTestModule",
+			Output:  "ok  \tsinglePassingTestModule\t0.002s\n",
+		})
+		if result != "" {
+			t.Fatalf("Expected package ok output to be filtered out, got '%s'", result)
+		}
+	})
+
+	t.Run("TestShowPackageFailOutput", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "output",
+			Package: "example.com/pkg",
+			Output:  "FAIL\texample.com/pkg\t0.002s\n",
+		})
+		expected := "FAIL\texample.com/pkg\t0.002s"
+		if result != expected {
+			t.Fatalf("Expected '%s', got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestPassThroughSetupFailedOutput", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "output",
+			Package: "command-line-arguments",
+			Output:  "FAIL\tcommand-line-arguments [setup failed]\n",
+		})
+		expected := "FAIL\tcommand-line-arguments [setup failed]"
+		if result != expected {
+			t.Fatalf("Expected '%s', got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestPassThroughBuildOutput", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action: "build-output",
+			Output: "# command-line-arguments\n",
+		})
+		expected := "# command-line-arguments"
+		if result != expected {
+			t.Fatalf("Expected '%s', got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestShowBuildFailEvents", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{Action: "build-fail"})
+		expected := "BUILD FAILED"
+		if result != expected {
+			t.Fatalf("Expected '%s', got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestPassThroughExitStatusOutput", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "output",
+			Package: "combined",
+			Output:  "exit status 1\n",
+		})
+		expected := "exit status 1"
+		if result != expected {
+			t.Fatalf("Expected '%s', got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestPassThroughUnknownOutputEvents", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action:  "output",
+			Package: "example",
+			Output:  "some unknown output\n",
+		})
+		expected := "some unknown output"
+		if result != expected {
+			t.Fatalf("Expected '%s', got '%s'", expected, result)
+		}
+	})
+
+	t.Run("TestPassThroughUnknownActions", func(t *testing.T) {
+		result := formatEvent(t, parser.TestEvent{
+			Action: "unknown-action",
+			Output: "data from unknown action\n",
+		})
+		expected := "unknown-action: data from unknown action"
+		if result != expected {
+			t.Fatalf("Expected '%s', got '%s'", expected, result)
+		}
+	})
+}
+
+// Helper functions
+
+func formatEvent(t *testing.T, event parser.TestEvent) string {
+	t.Helper()
+	formatter := NewFormatter()
+	return formatter.Format(event)
+}

package/project-skills/tdd-guard/reporters/go/internal/io/tee_reader.go

@@ -0,0 +1,26 @@
+package io
+
+import "io"
+
+// TeeReader reads from r and writes to w
+type TeeReader struct {
+	reader io.Reader
+	writer io.Writer
+}
+
+// NewTeeReader returns a Reader that writes to w what it reads from r
+func NewTeeReader(r io.Reader, w io.Writer) io.Reader {
+	return &TeeReader{
+		reader: r,
+		writer: w,
+	}
+}
+
+// Read implements io.Reader
+func (t *TeeReader) Read(p []byte) (n int, err error) {
+	n, err = t.reader.Read(p)
+	if n > 0 {
+		t.writer.Write(p[:n])
+	}
+	return n, err
+}

package/project-skills/tdd-guard/reporters/go/internal/io/tee_reader_test.go

@@ -0,0 +1,37 @@
+package io
+
+import (
+	"bytes"
+	"io"
+	"strings"
+	"testing"
+)
+
+func TestTeeReader(t *testing.T) {
+	input := "test data"
+
+	t.Run("reads input", func(t *testing.T) {
+		result, _ := readThroughTeeReader(input)
+
+		if string(result) != input {
+			t.Errorf("Expected to read '%s', got '%s'", input, string(result))
+		}
+	})
+
+	t.Run("writes to output", func(t *testing.T) {
+		_, output := readThroughTeeReader(input)
+
+		if output.String() != input {
+			t.Errorf("Expected output to contain '%s', got '%s'", input, output.String())
+		}
+	})
+}
+
+// Test helpers
+func readThroughTeeReader(input string) ([]byte, *bytes.Buffer) {
+	reader := strings.NewReader(input)
+	output := &bytes.Buffer{}
+	teeReader := NewTeeReader(reader, output)
+	result, _ := io.ReadAll(teeReader)
+	return result, output
+}

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

@@ -0,0 +1,94 @@
+package parser
+
+import (
+	"bufio"
+	"encoding/json"
+	"io"
+	"strings"
+)
+
+// MixedReader handles both JSON and plain text input from go test
+type MixedReader struct {
+	JSONLines        []string
+	NonJSONLines     []string
+	CompilationError *CompilationError
+}
+
+// CompilationError represents a compilation error if one occurred
+type CompilationError struct {
+	Package  string
+	Messages []string
+}
+
+// NewMixedReader creates a new MixedReader and processes the input
+func NewMixedReader(reader io.Reader) *MixedReader {
+	mr := &MixedReader{}
+	scanner := bufio.NewScanner(reader)
+	foundErrorHeader := false
+	var errorPkg string
+
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		// Try to parse as JSON
+		if isJSON(line) {
+			mr.JSONLines = append(mr.JSONLines, line)
+			continue
+		}
+
+		// Not JSON - store it
+		mr.NonJSONLines = append(mr.NonJSONLines, line)
+
+		// Check for compilation error pattern
+		if isErrorHeader(line) {
+			foundErrorHeader = true
+			errorPkg = extractPackageName(line)
+			continue
+		}
+
+		// Capture error messages (all non-FAIL lines after header)
+		if foundErrorHeader && isErrorMessage(line) {
+			if mr.CompilationError == nil {
+				mr.CompilationError = &CompilationError{
+					Package:  errorPkg,
+					Messages: []string{},
+				}
+			}
+			mr.CompilationError.Messages = append(mr.CompilationError.Messages, line)
+		}
+	}
+
+	// If we found error header but no error message, still create CompilationError
+	if foundErrorHeader && mr.CompilationError == nil {
+		mr.CompilationError = &CompilationError{
+			Package:  errorPkg,
+			Messages: []string{},
+		}
+	}
+
+	return mr
+}
+
+// isJSON checks if a line is valid JSON
+func isJSON(line string) bool {
+	var event TestEvent
+	return json.Unmarshal([]byte(line), &event) == nil
+}
+
+// isErrorHeader checks if line starts with # (compilation error header)
+func isErrorHeader(line string) bool {
+	return len(line) > 0 && line[0] == '#'
+}
+
+// extractPackageName extracts package name from error header line
+func extractPackageName(line string) string {
+	if len(line) > 2 {
+		return line[2:] // Everything after "# "
+	}
+	return ""
+}
+
+// isErrorMessage checks if line is a valid error message
+func isErrorMessage(line string) bool {
+	return line != "" && !strings.HasPrefix(line, "FAIL")
+}