claudetool/onstart/analyze_test.go - sketch - Gitiles

 package onstart

 import (
 	"context"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"slices"
 	"testing"
 )

 func TestAnalyzeCodebase(t *testing.T) {
 	t.Run("Basic Analysis", func(t *testing.T) {
 		// Test basic functionality with regular ASCII filenames
 		codebase, err := AnalyzeCodebase(context.Background(), ".")
 		if err != nil {
 			t.Fatalf("AnalyzeCodebase failed: %v", err)
 		}

 		if codebase == nil {
 			t.Fatal("Expected non-nil codebase")
 		}

 		if codebase.TotalFiles == 0 {
 			t.Error("Expected some files to be analyzed")
 		}

 		if len(codebase.ExtensionCounts) == 0 {
 			t.Error("Expected extension counts to be populated")
 		}
 	})

 	t.Run("Non-ASCII Filenames", func(t *testing.T) {
 		// Create a temporary directory with unicode filenames for testing
 		tempDir := t.TempDir()

 		// Initialize git repository
 		cmd := exec.Command("git", "init")
 		cmd.Dir = tempDir
 		if err := cmd.Run(); err != nil {
 			t.Fatalf("Failed to init git repo: %v", err)
 		}

 		cmd = exec.Command("git", "config", "user.name", "Test User")
 		cmd.Dir = tempDir
 		if err := cmd.Run(); err != nil {
 			t.Fatalf("Failed to set git user.name: %v", err)
 		}

 		cmd = exec.Command("git", "config", "user.email", "test@example.com")
 		cmd.Dir = tempDir
 		if err := cmd.Run(); err != nil {
 			t.Fatalf("Failed to set git user.email: %v", err)
 		}

 		// Configure git to handle unicode filenames properly
 		cmd = exec.Command("git", "config", "core.quotepath", "false")
 		cmd.Dir = tempDir
 		if err := cmd.Run(); err != nil {
 			t.Fatalf("Failed to set git core.quotepath: %v", err)
 		}

 		cmd = exec.Command("git", "config", "core.precomposeunicode", "true")
 		cmd.Dir = tempDir
 		if err := cmd.Run(); err != nil {
 			t.Fatalf("Failed to set git core.precomposeunicode: %v", err)
 		}

 		// Create test files with unicode characters dynamically
 		testFiles := map[string]string{
 			"测试文件.go":           "// Package test with Chinese characters in filename\npackage test\n\nfunc TestFunction() {\n\t// This is a test file\n}",
 			"café.js":           "// JavaScript file with French characters\nconsole.log('Hello from café!');",
 			"русский.py":        "# Python file with Russian characters\nprint('Привет мир!')",
 			"🚀rocket.md":        "# README with Emoji\n\nThis file has an emoji in the filename.",
 			"readme-español.md": "# Spanish README\n\nEste es un archivo de documentación.",
 			"Übung.html":        "<!DOCTYPE html>\n<html><head><title>German Exercise</title></head><body><h1>Übung</h1></body></html>",
 			"Makefile-日本語":      "# Japanese Makefile\nall:\n\techo 'Japanese makefile'",
 		}

 		// Create subdirectory
 		subdir := filepath.Join(tempDir, "subdir")
 		err := os.MkdirAll(subdir, 0o755)
 		if err != nil {
 			t.Fatalf("Failed to create subdir: %v", err)
 		}

 		// Add file in subdirectory
 		testFiles["subdir/claude.한국어.md"] = "# Korean Claude file\n\nThis is a guidance file with Korean characters."

 		// Write all test files
 		for filename, content := range testFiles {
 			fullPath := filepath.Join(tempDir, filename)
 			dir := filepath.Dir(fullPath)
 			if dir != tempDir {
 				err := os.MkdirAll(dir, 0o755)
 				if err != nil {
 					t.Fatalf("Failed to create directory %s: %v", dir, err)
 				}
 			}
 			err := os.WriteFile(fullPath, []byte(content), 0o644)
 			if err != nil {
 				t.Fatalf("Failed to write file %s: %v", filename, err)
 			}
 		}

 		// Add all files to git at once
 		cmd = exec.Command("git", "add", ".")
 		cmd.Dir = tempDir
 		if err := cmd.Run(); err != nil {
 			t.Fatalf("Failed to add files to git: %v", err)
 		}

 		// Test with non-ASCII characters in filenames
 		codebase, err := AnalyzeCodebase(context.Background(), tempDir)
 		if err != nil {
 			t.Fatalf("AnalyzeCodebase failed with non-ASCII filenames: %v", err)
 		}

 		if codebase == nil {
 			t.Fatal("Expected non-nil codebase")
 		}

 		// We expect 8 files in our temp directory
 		expectedFiles := 8
 		if codebase.TotalFiles != expectedFiles {
 			t.Errorf("Expected %d files, got %d", expectedFiles, codebase.TotalFiles)
 		}

 		// Verify extension counts include our non-ASCII files
 		expectedExtensions := map[string]int{
 			".go":            1, // 测试文件.go
 			".js":            1, // café.js
 			".py":            1, // русский.py
 			".md":            3, // 🚀rocket.md, readme-español.md, claude.한국어.md
 			".html":          1, // Übung.html
 			"<no-extension>": 1, // Makefile-日本語
 		}

 		for ext, expectedCount := range expectedExtensions {
 			actualCount, exists := codebase.ExtensionCounts[ext]
 			if !exists {
 				t.Errorf("Expected extension %s to be found", ext)
 				continue
 			}
 			if actualCount != expectedCount {
 				t.Errorf("Expected %d files with extension %s, got %d", expectedCount, ext, actualCount)
 			}
 		}

 		// Verify file categorization works with non-ASCII filenames
 		// Check build files
 		if !slices.Contains(codebase.BuildFiles, "Makefile-日本語") {
 			t.Error("Expected Makefile-日本語 to be categorized as a build file")
 		}

 		// Check documentation files
 		if !slices.Contains(codebase.DocumentationFiles, "readme-español.md") {
 			t.Error("Expected readme-español.md to be categorized as a documentation file")
 		}

 		// Check guidance files
 		if !slices.Contains(codebase.GuidanceFiles, "subdir/claude.한국어.md") {
 			t.Error("Expected subdir/claude.한국어.md to be categorized as a guidance file")
 		}
 	})
 }

 func TestCategorizeFile(t *testing.T) {
 	t.Run("Non-ASCII Filenames", func(t *testing.T) {
 		tests := []struct {
 			name     string
 			path     string
 			expected string
 		}{
 			{"Chinese Go file", "测试文件.go", ""},
 			{"French JS file", "café.js", ""},
 			{"Russian Python file", "русский.py", ""},
 			{"Emoji markdown file", "🚀rocket.md", ""},
 			{"German HTML file", "Übung.html", ""},
 			{"Japanese Makefile", "Makefile-日本語", "build"},
 			{"Spanish README", "readme-español.md", "documentation"},
 			{"Korean Claude file", "subdir/claude.한국어.md", "guidance"},
 			// Test edge cases with Unicode normalization and combining characters
 			{"Mixed Unicode file", "test中文🚀.txt", ""},
 			{"Combining characters", "filé̂.go", ""}, // file with combining acute and circumflex accents
 			{"Right-to-left script", "مرحبا.py", ""},  // Arabic "hello"
 		}

 		for _, tt := range tests {
 			t.Run(tt.name, func(t *testing.T) {
 				result := categorizeFile(tt.path)
 				if result != tt.expected {
 					t.Errorf("categorizeFile(%q) = %q, want %q", tt.path, result, tt.expected)
 				}
 			})
 		}
 	})
 }

 func TestTopExtensions(t *testing.T) {
 	t.Run("With Non-ASCII Files", func(t *testing.T) {
 		// Create a test codebase with known extension counts
 		codebase := &Codebase{
 			ExtensionCounts: map[string]int{
 				".md":   5, // Most common
 				".go":   3,
 				".js":   2,
 				".py":   1,
 				".html": 1, // Least common
 			},
 			TotalFiles: 12,
 		}

 		topExt := codebase.TopExtensions()
 		if len(topExt) != 5 {
 			t.Errorf("Expected 5 top extensions, got %d", len(topExt))
 		}

 		// Check that extensions are sorted by count (descending)
 		expected := []string{
 			".md: 5 (42%)",
 			".go: 3 (25%)",
 			".js: 2 (17%)",
 			".html: 1 (8%)",
 			".py: 1 (8%)",
 		}

 		for i, expectedExt := range expected {
 			if i >= len(topExt) {
 				t.Errorf("Missing expected extension at index %d: %s", i, expectedExt)
 				continue
 			}
 			if topExt[i] != expectedExt {
 				t.Errorf("Expected extension %q at index %d, got %q", expectedExt, i, topExt[i])
 			}
 		}
 	})
 }
	package onstart

	import (
	"context"
	"os"
	"os/exec"
	"path/filepath"
	"slices"
	"testing"
	)

	func TestAnalyzeCodebase(t *testing.T) {
	t.Run("Basic Analysis", func(t *testing.T) {
	// Test basic functionality with regular ASCII filenames
	codebase, err := AnalyzeCodebase(context.Background(), ".")
	if err != nil {
	t.Fatalf("AnalyzeCodebase failed: %v", err)
	}

	if codebase == nil {
	t.Fatal("Expected non-nil codebase")
	}

	if codebase.TotalFiles == 0 {
	t.Error("Expected some files to be analyzed")
	}

	if len(codebase.ExtensionCounts) == 0 {
	t.Error("Expected extension counts to be populated")
	}
	})

	t.Run("Non-ASCII Filenames", func(t *testing.T) {
	// Create a temporary directory with unicode filenames for testing
	tempDir := t.TempDir()

	// Initialize git repository
	cmd := exec.Command("git", "init")
	cmd.Dir = tempDir
	if err := cmd.Run(); err != nil {
	t.Fatalf("Failed to init git repo: %v", err)
	}

	cmd = exec.Command("git", "config", "user.name", "Test User")
	cmd.Dir = tempDir
	if err := cmd.Run(); err != nil {
	t.Fatalf("Failed to set git user.name: %v", err)
	}

	cmd = exec.Command("git", "config", "user.email", "test@example.com")
	cmd.Dir = tempDir
	if err := cmd.Run(); err != nil {
	t.Fatalf("Failed to set git user.email: %v", err)
	}

	// Configure git to handle unicode filenames properly
	cmd = exec.Command("git", "config", "core.quotepath", "false")
	cmd.Dir = tempDir
	if err := cmd.Run(); err != nil {
	t.Fatalf("Failed to set git core.quotepath: %v", err)
	}

	cmd = exec.Command("git", "config", "core.precomposeunicode", "true")
	cmd.Dir = tempDir
	if err := cmd.Run(); err != nil {
	t.Fatalf("Failed to set git core.precomposeunicode: %v", err)
	}

	// Create test files with unicode characters dynamically
	testFiles := map[string]string{
	"测试文件.go": "// Package test with Chinese characters in filename\npackage test\n\nfunc TestFunction() {\n\t// This is a test file\n}",
	"café.js": "// JavaScript file with French characters\nconsole.log('Hello from café!');",
	"русский.py": "# Python file with Russian characters\nprint('Привет мир!')",
	"🚀rocket.md": "# README with Emoji\n\nThis file has an emoji in the filename.",
	"readme-español.md": "# Spanish README\n\nEste es un archivo de documentación.",
	"Übung.html": "<!DOCTYPE html>\n<html><head><title>German Exercise</title></head><body><h1>Übung</h1></body></html>",
	"Makefile-日本語": "# Japanese Makefile\nall:\n\techo 'Japanese makefile'",
	}

	// Create subdirectory
	subdir := filepath.Join(tempDir, "subdir")
	err := os.MkdirAll(subdir, 0o755)
	if err != nil {
	t.Fatalf("Failed to create subdir: %v", err)
	}

	// Add file in subdirectory
	testFiles["subdir/claude.한국어.md"] = "# Korean Claude file\n\nThis is a guidance file with Korean characters."

	// Write all test files
	for filename, content := range testFiles {
	fullPath := filepath.Join(tempDir, filename)
	dir := filepath.Dir(fullPath)
	if dir != tempDir {
	err := os.MkdirAll(dir, 0o755)
	if err != nil {
	t.Fatalf("Failed to create directory %s: %v", dir, err)
	}
	}
	err := os.WriteFile(fullPath, []byte(content), 0o644)
	if err != nil {
	t.Fatalf("Failed to write file %s: %v", filename, err)
	}
	}

	// Add all files to git at once
	cmd = exec.Command("git", "add", ".")
	cmd.Dir = tempDir
	if err := cmd.Run(); err != nil {
	t.Fatalf("Failed to add files to git: %v", err)
	}

	// Test with non-ASCII characters in filenames
	codebase, err := AnalyzeCodebase(context.Background(), tempDir)
	if err != nil {
	t.Fatalf("AnalyzeCodebase failed with non-ASCII filenames: %v", err)
	}

	if codebase == nil {
	t.Fatal("Expected non-nil codebase")
	}

	// We expect 8 files in our temp directory
	expectedFiles := 8
	if codebase.TotalFiles != expectedFiles {
	t.Errorf("Expected %d files, got %d", expectedFiles, codebase.TotalFiles)
	}

	// Verify extension counts include our non-ASCII files
	expectedExtensions := map[string]int{
	".go": 1, // 测试文件.go
	".js": 1, // café.js
	".py": 1, // русский.py
	".md": 3, // 🚀rocket.md, readme-español.md, claude.한국어.md
	".html": 1, // Übung.html
	"<no-extension>": 1, // Makefile-日本語
	}

	for ext, expectedCount := range expectedExtensions {
	actualCount, exists := codebase.ExtensionCounts[ext]
	if !exists {
	t.Errorf("Expected extension %s to be found", ext)
	continue
	}
	if actualCount != expectedCount {
	t.Errorf("Expected %d files with extension %s, got %d", expectedCount, ext, actualCount)
	}
	}

	// Verify file categorization works with non-ASCII filenames
	// Check build files
	if !slices.Contains(codebase.BuildFiles, "Makefile-日本語") {
	t.Error("Expected Makefile-日本語 to be categorized as a build file")
	}

	// Check documentation files
	if !slices.Contains(codebase.DocumentationFiles, "readme-español.md") {
	t.Error("Expected readme-español.md to be categorized as a documentation file")
	}

	// Check guidance files
	if !slices.Contains(codebase.GuidanceFiles, "subdir/claude.한국어.md") {
	t.Error("Expected subdir/claude.한국어.md to be categorized as a guidance file")
	}
	})
	}

	func TestCategorizeFile(t *testing.T) {
	t.Run("Non-ASCII Filenames", func(t *testing.T) {
	tests := []struct {
	name string
	path string
	expected string
	}{
	{"Chinese Go file", "测试文件.go", ""},
	{"French JS file", "café.js", ""},
	{"Russian Python file", "русский.py", ""},
	{"Emoji markdown file", "🚀rocket.md", ""},
	{"German HTML file", "Übung.html", ""},
	{"Japanese Makefile", "Makefile-日本語", "build"},
	{"Spanish README", "readme-español.md", "documentation"},
	{"Korean Claude file", "subdir/claude.한국어.md", "guidance"},
	// Test edge cases with Unicode normalization and combining characters
	{"Mixed Unicode file", "test中文🚀.txt", ""},
	{"Combining characters", "filé̂.go", ""}, // file with combining acute and circumflex accents
	{"Right-to-left script", "مرحبا.py", ""}, // Arabic "hello"
	}

	for _, tt := range tests {
	t.Run(tt.name, func(t *testing.T) {
	result := categorizeFile(tt.path)
	if result != tt.expected {
	t.Errorf("categorizeFile(%q) = %q, want %q", tt.path, result, tt.expected)
	}
	})
	}
	})
	}

	func TestTopExtensions(t *testing.T) {
	t.Run("With Non-ASCII Files", func(t *testing.T) {
	// Create a test codebase with known extension counts
	codebase := &Codebase{
	ExtensionCounts: map[string]int{
	".md": 5, // Most common
	".go": 3,
	".js": 2,
	".py": 1,
	".html": 1, // Least common
	},
	TotalFiles: 12,
	}

	topExt := codebase.TopExtensions()
	if len(topExt) != 5 {
	t.Errorf("Expected 5 top extensions, got %d", len(topExt))
	}

	// Check that extensions are sorted by count (descending)
	expected := []string{
	".md: 5 (42%)",
	".go: 3 (25%)",
	".js: 2 (17%)",
	".html: 1 (8%)",
	".py: 1 (8%)",
	}

	for i, expectedExt := range expected {
	if i >= len(topExt) {
	t.Errorf("Missing expected extension at index %d: %s", i, expectedExt)
	continue
	}
	if topExt[i] != expectedExt {
	t.Errorf("Expected extension %q at index %d, got %q", expectedExt, i, topExt[i])
	}
	}
	})
	}