xtrm-tools 2.2.0 → 2.4.0

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

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

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

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

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

@@ -1,94 +0,0 @@
-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")
-}