Initial commit

testutil/testutil.go

@@ -0,0 +1,339 @@
+// Package testutil provides testing utilities and mocks for gh-action-readme.
+package testutil
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/go-github/v57/github"
+)
+
+// MockHTTPClient is a mock HTTP client for testing.
+type MockHTTPClient struct {
+	Responses map[string]*http.Response
+	Requests  []*http.Request
+}
+
+// Do implements the http.Client interface.
+func (m *MockHTTPClient) Do(req *http.Request) (*http.Response, error) {
+	m.Requests = append(m.Requests, req)
+
+	key := req.Method + " " + req.URL.String()
+	if resp, ok := m.Responses[key]; ok {
+		return resp, nil
+	}
+
+	// Default 404 response
+	return &http.Response{
+		StatusCode: 404,
+		Body:       io.NopCloser(strings.NewReader(`{"error": "not found"}`)),
+	}, nil
+}
+
+// MockGitHubClient creates a GitHub client with mocked responses.
+func MockGitHubClient(responses map[string]string) *github.Client {
+	mockClient := &MockHTTPClient{
+		Responses: make(map[string]*http.Response),
+	}
+
+	for key, body := range responses {
+		mockClient.Responses[key] = &http.Response{
+			StatusCode: 200,
+			Body:       io.NopCloser(strings.NewReader(body)),
+			Header:     make(http.Header),
+		}
+	}
+
+	client := github.NewClient(&http.Client{Transport: &mockTransport{client: mockClient}})
+	return client
+}
+
+type mockTransport struct {
+	client *MockHTTPClient
+}
+
+func (t *mockTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	return t.client.Do(req)
+}
+
+// TempDir creates a temporary directory for testing and returns cleanup function.
+func TempDir(t *testing.T) (string, func()) {
+	t.Helper()
+
+	dir, err := os.MkdirTemp("", "gh-action-readme-test-*")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+
+	return dir, func() {
+		_ = os.RemoveAll(dir)
+	}
+}
+
+// WriteTestFile writes a test file to the given path.
+func WriteTestFile(t *testing.T, path, content string) {
+	t.Helper()
+
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		t.Fatalf("failed to create dir %s: %v", dir, err)
+	}
+
+	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+		t.Fatalf("failed to write test file %s: %v", path, err)
+	}
+}
+
+// MockColoredOutput captures output for testing.
+type MockColoredOutput struct {
+	Messages []string
+	Errors   []string
+	Quiet    bool
+}
+
+// NewMockColoredOutput creates a new mock colored output.
+func NewMockColoredOutput(quiet bool) *MockColoredOutput {
+	return &MockColoredOutput{Quiet: quiet}
+}
+
+// Info captures info messages.
+func (m *MockColoredOutput) Info(format string, args ...any) {
+	if !m.Quiet {
+		m.Messages = append(m.Messages, fmt.Sprintf("INFO: "+format, args...))
+	}
+}
+
+// Success captures success messages.
+func (m *MockColoredOutput) Success(format string, args ...any) {
+	if !m.Quiet {
+		m.Messages = append(m.Messages, fmt.Sprintf("SUCCESS: "+format, args...))
+	}
+}
+
+// Warning captures warning messages.
+func (m *MockColoredOutput) Warning(format string, args ...any) {
+	if !m.Quiet {
+		m.Messages = append(m.Messages, fmt.Sprintf("WARNING: "+format, args...))
+	}
+}
+
+// Error captures error messages.
+func (m *MockColoredOutput) Error(format string, args ...any) {
+	m.Errors = append(m.Errors, fmt.Sprintf("ERROR: "+format, args...))
+}
+
+// Bold captures bold messages.
+func (m *MockColoredOutput) Bold(format string, args ...any) {
+	if !m.Quiet {
+		m.Messages = append(m.Messages, fmt.Sprintf("BOLD: "+format, args...))
+	}
+}
+
+// Printf captures printf messages.
+func (m *MockColoredOutput) Printf(format string, args ...any) {
+	if !m.Quiet {
+		m.Messages = append(m.Messages, fmt.Sprintf(format, args...))
+	}
+}
+
+// Reset clears all captured messages.
+func (m *MockColoredOutput) Reset() {
+	m.Messages = nil
+	m.Errors = nil
+}
+
+// HasMessage checks if a message contains the given substring.
+func (m *MockColoredOutput) HasMessage(substring string) bool {
+	for _, msg := range m.Messages {
+		if strings.Contains(msg, substring) {
+			return true
+		}
+	}
+	return false
+}
+
+// HasError checks if an error contains the given substring.
+func (m *MockColoredOutput) HasError(substring string) bool {
+	for _, err := range m.Errors {
+		if strings.Contains(err, substring) {
+			return true
+		}
+	}
+	return false
+}
+
+// CreateTestAction creates a test action.yml file content.
+func CreateTestAction(name, description string, inputs map[string]string) string {
+	var inputsYAML bytes.Buffer
+	for key, desc := range inputs {
+		inputsYAML.WriteString(fmt.Sprintf("  %s:\n    description: %s\n    required: true\n", key, desc))
+	}
+
+	return fmt.Sprintf(`name: %s
+description: %s
+inputs:
+%soutputs:
+  result:
+    description: 'The result'
+runs:
+  using: 'node20'
+  main: 'index.js'
+branding:
+  icon: 'zap'
+  color: 'yellow'
+`, name, description, inputsYAML.String())
+}
+
+// CreateCompositeAction creates a test composite action with dependencies.
+func CreateCompositeAction(name, description string, steps []string) string {
+	var stepsYAML bytes.Buffer
+	for i, step := range steps {
+		stepsYAML.WriteString(fmt.Sprintf("  - name: Step %d\n    uses: %s\n", i+1, step))
+	}
+
+	return fmt.Sprintf(`name: %s
+description: %s
+runs:
+  using: 'composite'
+  steps:
+%s`, name, description, stepsYAML.String())
+}
+
+// TestAppConfig represents a test configuration structure.
+type TestAppConfig struct {
+	Theme        string
+	OutputFormat string
+	OutputDir    string
+	Template     string
+	Schema       string
+	Verbose      bool
+	Quiet        bool
+	GitHubToken  string
+}
+
+// MockAppConfig creates a test configuration.
+func MockAppConfig(overrides *TestAppConfig) *TestAppConfig {
+	config := &TestAppConfig{
+		Theme:        "default",
+		OutputFormat: "md",
+		OutputDir:    ".",
+		Template:     "",
+		Schema:       "schemas/action.schema.json",
+		Verbose:      false,
+		Quiet:        false,
+		GitHubToken:  "",
+	}
+
+	if overrides != nil {
+		if overrides.Theme != "" {
+			config.Theme = overrides.Theme
+		}
+		if overrides.OutputFormat != "" {
+			config.OutputFormat = overrides.OutputFormat
+		}
+		if overrides.OutputDir != "" {
+			config.OutputDir = overrides.OutputDir
+		}
+		if overrides.Template != "" {
+			config.Template = overrides.Template
+		}
+		if overrides.Schema != "" {
+			config.Schema = overrides.Schema
+		}
+		config.Verbose = overrides.Verbose
+		config.Quiet = overrides.Quiet
+		if overrides.GitHubToken != "" {
+			config.GitHubToken = overrides.GitHubToken
+		}
+	}
+
+	return config
+}
+
+// SetEnv sets an environment variable for testing and returns cleanup function.
+func SetEnv(t *testing.T, key, value string) func() {
+	t.Helper()
+
+	original := os.Getenv(key)
+	_ = os.Setenv(key, value)
+
+	return func() {
+		if original == "" {
+			_ = os.Unsetenv(key)
+		} else {
+			_ = os.Setenv(key, original)
+		}
+	}
+}
+
+// WithContext creates a context with timeout for testing.
+func WithContext(timeout time.Duration) context.Context {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	_ = cancel // Avoid lostcancel - we're intentionally creating a context without cleanup for testing
+	return ctx
+}
+
+// AssertNoError fails the test if err is not nil.
+func AssertNoError(t *testing.T, err error) {
+	t.Helper()
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+// AssertError fails the test if err is nil.
+func AssertError(t *testing.T, err error) {
+	t.Helper()
+	if err == nil {
+		t.Fatal("expected error but got nil")
+	}
+}
+
+// AssertStringContains fails the test if str doesn't contain substring.
+func AssertStringContains(t *testing.T, str, substring string) {
+	t.Helper()
+	if !strings.Contains(str, substring) {
+		t.Fatalf("expected string to contain %q, got: %s", substring, str)
+	}
+}
+
+// AssertEqual fails the test if expected != actual.
+func AssertEqual(t *testing.T, expected, actual any) {
+	t.Helper()
+
+	// Handle maps which can't be compared directly
+	if expectedMap, ok := expected.(map[string]string); ok {
+		actualMap, ok := actual.(map[string]string)
+		if !ok {
+			t.Fatalf("expected map[string]string, got %T", actual)
+		}
+
+		if len(expectedMap) != len(actualMap) {
+			t.Fatalf("expected map with %d entries, got %d", len(expectedMap), len(actualMap))
+		}
+
+		for k, v := range expectedMap {
+			if actualMap[k] != v {
+				t.Fatalf("expected map[%s] = %s, got %s", k, v, actualMap[k])
+			}
+		}
+		return
+	}
+
+	if expected != actual {
+		t.Fatalf("expected %v, got %v", expected, actual)
+	}
+}
+
+// NewStringReader creates an io.ReadCloser from a string.
+func NewStringReader(s string) io.ReadCloser {
+	return io.NopCloser(strings.NewReader(s))
+}