+1 -1

README.md

··· 35 35 response := handleRequest(request) 36 36 37 37 // Snapshot both request and response together 38 38 - shutter.SnapMany(t, "request and response", []any{request, response}) 38 38 + shutter.SnapMany(t, "title", []any{request, response}) 39 39 } 40 40 ``` 41 41

+17 -8

internal/files/files.go

··· 92 92 } 93 93 } 94 94 95 95 + // getSnapshotPath returns the full path for a snapshot file 96 96 + func getSnapshotPath(snapTitle string, state string) (string, error) { 97 97 + snapshotDir, err := getSnapshotDir() 98 98 + if err != nil { 99 99 + return "", err 100 100 + } 101 101 + 102 102 + fileName := getSnapshotFileName(snapTitle, state) 103 103 + return filepath.Join(snapshotDir, fileName), nil 104 104 + } 105 105 + 95 106 func SaveSnapshot(snap *Snapshot, state string) error { 96 107 snapshotDir, err := getSnapshotDir() 97 108 if err != nil { ··· 152 163 } 153 164 154 165 func AcceptSnapshot(snapTitle string) error { 155 155 - snapshotDir, err := getSnapshotDir() 166 166 + newPath, err := getSnapshotPath(snapTitle, "new") 156 167 if err != nil { 157 168 return err 158 169 } 159 170 160 160 - fileName := SnapshotFileName(snapTitle) 161 161 - newPath := filepath.Join(snapshotDir, fileName+".snap.new") 162 162 - acceptedPath := filepath.Join(snapshotDir, fileName+".snap") 171 171 + acceptedPath, err := getSnapshotPath(snapTitle, "accepted") 172 172 + if err != nil { 173 173 + return err 174 174 + } 163 175 164 176 data, err := os.ReadFile(newPath) 165 177 if err != nil { ··· 174 186 } 175 187 176 188 func RejectSnapshot(snapTitle string) error { 177 177 - snapshotDir, err := getSnapshotDir() 189 189 + filePath, err := getSnapshotPath(snapTitle, "new") 178 190 if err != nil { 179 191 return err 180 192 } 181 181 - 182 182 - fileName := SnapshotFileName(snapTitle) + ".snap.new" 183 183 - filePath := filepath.Join(snapshotDir, fileName) 184 193 185 194 return os.Remove(filePath) 186 195 }

+23

internal/pretty/__snapshots__/diff_box_complex_mixed.snap

··· 1 1 + --- 2 2 + title: diff_box_complex_mixed 3 3 + test_name: TestDiffSnapshotBox_VisualRegression_ComplexMixed 4 4 + file_name: boxes_test.go 5 5 + version: 0.1.0 6 6 + --- 7 7 + ─── Snapshot Diff ───────────────────────────────────────────────────────────────────────────────────────────────────────── 8 8 + 9 9 +  title: Visual Complex 10 10 +  test: TestVisualComplex 11 11 +  file: testvisualcomplex.snap 12 12 + 13 13 + ──────┬───────────────────────────────────────────────────────────────────────────────────────────────────────────────────── 14 14 + 1 │ unchanged1 15 15 + 2 - delete1 16 16 + 3 - delete2 17 17 + 2 │ unchanged2 18 18 + 5 - modify_old 19 19 + 3 + modify_new 20 20 + 4 + add1 21 21 + 5 │ unchanged3 22 22 + 6 + add2 23 23 + ──────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

+121

internal/pretty/__snapshots__/diff_box_large_line_numbers.snap

··· 1 1 + --- 2 2 + title: diff_box_large_line_numbers 3 3 + test_name: TestDiffSnapshotBox_VisualRegression_LargeLineNumbers 4 4 + file_name: boxes_test.go 5 5 + version: 0.1.0 6 6 + --- 7 7 + ─── Snapshot Diff ───────────────────────────────────────────────────────────────────────────────────────────────────────── 8 8 + 9 9 +  title: Large Line Numbers 10 10 +  test: TestVisualLarge 11 11 +  file: testvisuallarge.snap 12 12 + 13 13 + ──────────┬───────────────────────────────────────────────────────────────────────────────────────────────────────────────── 14 14 +  1 │ line 1 15 15 +  2 │ line 2 16 16 +  3 │ line 3 17 17 +  4 │ line 4 18 18 +  5 │ line 5 19 19 +  6 │ line 6 20 20 +  7 │ line 7 21 21 +  8 │ line 8 22 22 +  9 │ line 9 23 23 +  10 │ line 10 24 24 +  11 │ line 11 25 25 +  12 │ line 12 26 26 +  13 │ line 13 27 27 +  14 │ line 14 28 28 +  15 │ line 15 29 29 +  16 │ line 16 30 30 +  17 │ line 17 31 31 +  18 │ line 18 32 32 +  19 │ line 19 33 33 +  20 │ line 20 34 34 +  21 │ line 21 35 35 +  22 │ line 22 36 36 +  23 │ line 23 37 37 +  24 │ line 24 38 38 +  25 │ line 25 39 39 +  26 │ line 26 40 40 +  27 │ line 27 41 41 +  28 │ line 28 42 42 +  29 │ line 29 43 43 +  30 │ line 30 44 44 +  31 │ line 31 45 45 +  32 │ line 32 46 46 +  33 │ line 33 47 47 +  34 │ line 34 48 48 +  35 │ line 35 49 49 +  36 │ line 36 50 50 +  37 │ line 37 51 51 +  38 │ line 38 52 52 +  39 │ line 39 53 53 +  40 │ line 40 54 54 +  41 │ line 41 55 55 +  42 │ line 42 56 56 +  43 │ line 43 57 57 +  44 │ line 44 58 58 +  45 │ line 45 59 59 +  46 │ line 46 60 60 +  47 │ line 47 61 61 +  48 │ line 48 62 62 +  49 │ line 49 63 63 +  50 - old line 50 64 64 +  50 + new line 50 65 65 +  51 │ line 51 66 66 +  52 │ line 52 67 67 +  53 │ line 53 68 68 +  54 │ line 54 69 69 +  55 │ line 55 70 70 +  56 │ line 56 71 71 +  57 │ line 57 72 72 +  58 │ line 58 73 73 +  59 │ line 59 74 74 +  60 │ line 60 75 75 +  61 │ line 61 76 76 +  62 │ line 62 77 77 +  63 │ line 63 78 78 +  64 │ line 64 79 79 +  65 │ line 65 80 80 +  66 │ line 66 81 81 +  67 │ line 67 82 82 +  68 │ line 68 83 83 +  69 │ line 69 84 84 +  70 │ line 70 85 85 +  71 │ line 71 86 86 +  72 │ line 72 87 87 +  73 │ line 73 88 88 +  74 │ line 74 89 89 +  75 │ line 75 90 90 +  76 │ line 76 91 91 +  77 │ line 77 92 92 +  78 │ line 78 93 93 +  79 │ line 79 94 94 +  80 │ line 80 95 95 +  81 │ line 81 96 96 +  82 │ line 82 97 97 +  83 │ line 83 98 98 +  84 │ line 84 99 99 +  85 │ line 85 100 100 +  86 │ line 86 101 101 +  87 │ line 87 102 102 +  88 │ line 88 103 103 +  89 │ line 89 104 104 +  90 │ line 90 105 105 +  91 │ line 91 106 106 +  92 │ line 92 107 107 +  93 │ line 93 108 108 +  94 │ line 94 109 109 +  95 │ line 95 110 110 +  96 │ line 96 111 111 +  97 │ line 97 112 112 +  98 │ line 98 113 113 +  99 │ line 99 114 114 + 100 - old line 100 115 115 + 100 + new line 100 116 116 + 101 │ line 101 117 117 + 102 │ line 102 118 118 + 103 │ line 103 119 119 + 104 │ line 104 120 120 + 105 │ line 105 121 121 + ──────────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────

+18

internal/pretty/__snapshots__/diff_box_simple_modification.snap

··· 1 1 + --- 2 2 + title: diff_box_simple_modification 3 3 + test_name: TestDiffSnapshotBox_VisualRegression_SimpleModification 4 4 + file_name: boxes_test.go 5 5 + version: 0.1.0 6 6 + --- 7 7 + ─── Snapshot Diff ───────────────────────────────────────────────────────────────────────────────────── 8 8 + 9 9 +  title: Visual Test 10 10 +  test: TestVisualSimple 11 11 +  file: testvisualsimple.snap 12 12 + 13 13 + ──────┬───────────────────────────────────────────────────────────────────────────────────────────────── 14 14 + 1 │ line1 15 15 + 2 - line2 16 16 + 2 + modified 17 17 + 3 │ line3 18 18 + ──────┴─────────────────────────────────────────────────────────────────────────────────────────────────

+19

internal/pretty/__snapshots__/new_snapshot_box.snap

··· 1 1 + --- 2 2 + title: new_snapshot_box 3 3 + test_name: TestNewSnapshotBox_VisualRegression 4 4 + file_name: boxes_test.go 5 5 + version: 0.1.0 6 6 + --- 7 7 + ─── New Snapshot ───────────────────────────────────────────────────────────────────────────────────── 8 8 + 9 9 +  title: New Snapshot Visual 10 10 +  test: TestNewVisual 11 11 +  file: test_new_visual.snap 12 12 + 13 13 + ────┬───────────────────────────────────────────────────────────────────────────────────────────────── 14 14 + 1 + line1 15 15 + 2 + line2 16 16 + 3 + line3 17 17 + 4 + line4 18 18 + 5 + line5 19 19 + ────┴─────────────────────────────────────────────────────────────────────────────────────────────────

+22 -14

internal/pretty/boxes.go

··· 2 2 3 3 import ( 4 4 "fmt" 5 5 - "strconv" 6 5 "strings" 7 6 8 7 "github.com/ptdewey/shutter/internal/diff" ··· 13 12 return newSnapshotBoxInternal(snap) 14 13 } 15 14 15 15 + // calculateLineNumWidth returns the width needed to display line numbers 16 16 + func calculateLineNumWidth(maxLineNum int) int { 17 17 + return len(fmt.Sprintf("%d", maxLineNum)) 18 18 + } 19 19 + 20 20 + // formatColoredLine applies color to a line based on diff kind 21 21 + func formatColoredLine(line string, kind diff.DiffKind) string { 22 22 + switch kind { 23 23 + case diff.DiffOld: 24 24 + return Red(line) 25 25 + case diff.DiffNew: 26 26 + return Green(line) 27 27 + case diff.DiffShared: 28 28 + return line 29 29 + default: 30 30 + return line 31 31 + } 32 32 + } 33 33 + 16 34 func DiffSnapshotBox(old, newSnapshot *files.Snapshot, diffLines []diff.DiffLine) string { 17 35 width := TerminalWidth() 18 36 snapshotFileName := files.SnapshotFileName(newSnapshot.Test) + ".snap" ··· 49 67 if maxNewNum > maxLineNum { 50 68 maxLineNum = maxNewNum 51 69 } 52 52 - lineNumWidth := len(fmt.Sprintf("%d", maxLineNum)) 70 70 + lineNumWidth := calculateLineNumWidth(maxLineNum) 53 71 54 72 // Top bar with corner (account for both line number columns) 55 73 topBar := strings.Repeat("─", (lineNumWidth*2)+4) + "┬" + ··· 86 104 maxContentWidth := width - (lineNumWidth * 2) - 8 87 105 if len(dl.Line) > maxContentWidth { 88 106 truncated := dl.Line[:maxContentWidth-3] + "..." 89 89 - switch dl.Kind { 90 90 - case diff.DiffOld: 91 91 - formatted = Red(truncated) 92 92 - case diff.DiffNew: 93 93 - formatted = Green(truncated) 94 94 - case diff.DiffShared: 95 95 - formatted = truncated 96 96 - } 107 107 + formatted = formatColoredLine(truncated, dl.Kind) 97 108 } 98 109 99 110 display := fmt.Sprintf("%s %s %s %s", leftNum, rightNum, prefix, formatted) ··· 116 127 117 128 if snap.Title != "" { 118 129 sb.WriteString(Blue(" title: ") + snap.Title + "\n") 119 119 - // sb.WriteString(fmt.Sprintf(" title: %s\n", Blue(snap.Title))) 120 130 } 121 131 if snap.Test != "" { 122 122 - // sb.WriteString(fmt.Sprintf(" test: %s\n", Blue(snap.Test))) 123 132 sb.WriteString(Blue(" test: ") + snap.Test + "\n") 124 133 } 125 134 if snap.FileName != "" { 126 126 - // sb.WriteString(fmt.Sprintf(" file: %s\n", Gray(snap.FileName))) 127 135 sb.WriteString(Blue(" file: ") + snap.FileName + "\n") 128 136 } 129 137 sb.WriteString("\n") 130 138 131 139 lines := strings.Split(snap.Content, "\n") 132 140 numLines := len(lines) 133 133 - lineNumWidth := len(strconv.Itoa(numLines)) 141 141 + lineNumWidth := calculateLineNumWidth(numLines) 134 142 135 143 topBar := strings.Repeat("─", lineNumWidth+3) + "┬" + 136 144 strings.Repeat("─", width-lineNumWidth-2) + "\n"

+1008

internal/pretty/boxes_test.go

··· 1 1 + package pretty_test 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "math/rand" 6 6 + "os" 7 7 + "strings" 8 8 + "testing" 9 9 + 10 10 + "github.com/ptdewey/shutter" 11 11 + "github.com/ptdewey/shutter/internal/diff" 12 12 + "github.com/ptdewey/shutter/internal/files" 13 13 + "github.com/ptdewey/shutter/internal/pretty" 14 14 + ) 15 15 + 16 16 + // BoxValidation holds expected properties for validation 17 17 + type BoxValidation struct { 18 18 + // Title and filename expectations 19 19 + Title string 20 20 + TestName string 21 21 + FileName string 22 22 + HasTitle bool 23 23 + HasTestName bool 24 24 + HasFileName bool 25 25 + 26 26 + // Diff line expectations 27 27 + ExpectedAdds []string // Lines that should appear as additions (green +) 28 28 + ExpectedDeletes []string // Lines that should appear as deletions (red -) 29 29 + ExpectedContext []string // Lines that should appear as context (gray │) 30 30 + 31 31 + // Structural expectations 32 32 + HasTopBar bool 33 33 + HasBottomBar bool 34 34 + MinLines int // Minimum number of content lines expected 35 35 + } 36 36 + 37 37 + // ValidateDiffBox checks that a diff box output matches expectations 38 38 + func ValidateDiffBox(t *testing.T, output string, validation BoxValidation) { 39 39 + t.Helper() 40 40 + 41 41 + // Remove ANSI codes for easier content checking 42 42 + stripped := stripANSI(output) 43 43 + 44 44 + // Check title/test/filename presence 45 45 + if validation.HasTitle { 46 46 + if !strings.Contains(stripped, "title: "+validation.Title) { 47 47 + t.Errorf("Expected title '%s' not found in output", validation.Title) 48 48 + } 49 49 + } 50 50 + 51 51 + if validation.HasTestName { 52 52 + if !strings.Contains(stripped, "test: "+validation.TestName) { 53 53 + t.Errorf("Expected test name '%s' not found in output", validation.TestName) 54 54 + } 55 55 + } 56 56 + 57 57 + if validation.HasFileName { 58 58 + if !strings.Contains(stripped, "file: "+validation.FileName) { 59 59 + t.Errorf("Expected file name '%s' not found in output", validation.FileName) 60 60 + } 61 61 + } 62 62 + 63 63 + // Check for box structure 64 64 + if validation.HasTopBar { 65 65 + if !strings.Contains(stripped, "┬") { 66 66 + t.Error("Expected top bar with ┬ character") 67 67 + } 68 68 + } 69 69 + 70 70 + if validation.HasBottomBar { 71 71 + if !strings.Contains(stripped, "┴") { 72 72 + t.Error("Expected bottom bar with ┴ character") 73 73 + } 74 74 + } 75 75 + 76 76 + // Check expected additions (green + lines) 77 77 + for _, expectedAdd := range validation.ExpectedAdds { 78 78 + if !containsDiffLine(output, "+", expectedAdd) { 79 79 + t.Errorf("Expected addition not found: + %s", expectedAdd) 80 80 + } 81 81 + } 82 82 + 83 83 + // Check expected deletions (red - lines) 84 84 + for _, expectedDelete := range validation.ExpectedDeletes { 85 85 + if !containsDiffLine(output, "-", expectedDelete) { 86 86 + t.Errorf("Expected deletion not found: - %s", expectedDelete) 87 87 + } 88 88 + } 89 89 + 90 90 + // Check expected context (shared lines) 91 91 + for _, expectedContext := range validation.ExpectedContext { 92 92 + if !containsDiffLine(output, "│", expectedContext) { 93 93 + t.Errorf("Expected context line not found: │ %s", expectedContext) 94 94 + } 95 95 + } 96 96 + 97 97 + // Check minimum line count 98 98 + if validation.MinLines > 0 { 99 99 + lines := strings.Split(output, "\n") 100 100 + contentLines := countContentLines(lines) 101 101 + if contentLines < validation.MinLines { 102 102 + t.Errorf("Expected at least %d content lines, got %d", validation.MinLines, contentLines) 103 103 + } 104 104 + } 105 105 + } 106 106 + 107 107 + // containsDiffLine checks if a line with the given prefix and content exists 108 108 + func containsDiffLine(output, prefix, content string) bool { 109 109 + lines := strings.Split(output, "\n") 110 110 + stripped := stripANSI(output) 111 111 + strippedLines := strings.Split(stripped, "\n") 112 112 + 113 113 + for i, line := range strippedLines { 114 114 + // Check if line contains the prefix and content 115 115 + if strings.Contains(line, prefix) && strings.Contains(line, content) { 116 116 + // Verify the original line has proper coloring 117 117 + originalLine := lines[i] 118 118 + switch prefix { 119 119 + case "+": 120 120 + // Green additions should have ANSI codes 121 121 + if !strings.Contains(originalLine, "\033[") { 122 122 + continue // Skip if no color 123 123 + } 124 124 + case "-": 125 125 + // Red deletions should have ANSI codes 126 126 + if !strings.Contains(originalLine, "\033[") { 127 127 + continue 128 128 + } 129 129 + case "│": 130 130 + // Context lines may or may not have color 131 131 + } 132 132 + return true 133 133 + } 134 134 + } 135 135 + return false 136 136 + } 137 137 + 138 138 + // countContentLines counts lines that contain diff content (not headers/borders) 139 139 + func countContentLines(lines []string) int { 140 140 + count := 0 141 141 + for _, line := range lines { 142 142 + stripped := stripANSI(line) 143 143 + // Content lines have line numbers followed by +, -, or │ 144 144 + if strings.Contains(stripped, "+") || 145 145 + strings.Contains(stripped, "-") || 146 146 + strings.Contains(stripped, "│") { 147 147 + count++ 148 148 + } 149 149 + } 150 150 + return count 151 151 + } 152 152 + 153 153 + // stripANSI removes ANSI escape codes from a string 154 154 + func stripANSI(s string) string { 155 155 + var result strings.Builder 156 156 + inEscape := false 157 157 + for _, r := range s { 158 158 + if r == '\033' { 159 159 + inEscape = true 160 160 + continue 161 161 + } 162 162 + if inEscape { 163 163 + if r == 'm' { 164 164 + inEscape = false 165 165 + } 166 166 + continue 167 167 + } 168 168 + result.WriteRune(r) 169 169 + } 170 170 + return result.String() 171 171 + } 172 172 + 173 173 + // TestDiffSnapshotBox_SimpleModification tests a basic modification scenario 174 174 + func TestDiffSnapshotBox_SimpleModification(t *testing.T) { 175 175 + os.Unsetenv("NO_COLOR") 176 176 + os.Setenv("COLUMNS", "100") 177 177 + defer os.Unsetenv("COLUMNS") 178 178 + 179 179 + oldContent := "line1\nline2\nline3" 180 180 + newContent := "line1\nmodified\nline3" 181 181 + 182 182 + oldSnap := &files.Snapshot{ 183 183 + Title: "Simple Modification", 184 184 + Test: "TestSimple", 185 185 + Content: oldContent, 186 186 + } 187 187 + 188 188 + newSnap := &files.Snapshot{ 189 189 + Title: "Simple Modification", 190 190 + Test: "TestSimple", 191 191 + Content: newContent, 192 192 + } 193 193 + 194 194 + diffLines := diff.Histogram(oldContent, newContent) 195 195 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 196 196 + 197 197 + validation := BoxValidation{ 198 198 + Title: "Simple Modification", 199 199 + TestName: "TestSimple", 200 200 + FileName: "testsimple.snap", 201 201 + HasTitle: true, 202 202 + HasTestName: true, 203 203 + HasFileName: true, 204 204 + ExpectedAdds: []string{"modified"}, 205 205 + ExpectedDeletes: []string{"line2"}, 206 206 + ExpectedContext: []string{"line1", "line3"}, 207 207 + HasTopBar: true, 208 208 + HasBottomBar: true, 209 209 + MinLines: 4, // 1 shared + 1 delete + 1 add + 1 shared 210 210 + } 211 211 + 212 212 + ValidateDiffBox(t, result, validation) 213 213 + } 214 214 + 215 215 + // TestDiffSnapshotBox_PureAddition tests adding lines only 216 216 + func TestDiffSnapshotBox_PureAddition(t *testing.T) { 217 217 + os.Unsetenv("NO_COLOR") 218 218 + os.Setenv("COLUMNS", "100") 219 219 + defer os.Unsetenv("COLUMNS") 220 220 + 221 221 + oldContent := "line1\nline2" 222 222 + newContent := "line1\nline2\nline3\nline4" 223 223 + 224 224 + oldSnap := &files.Snapshot{ 225 225 + Title: "Pure Addition", 226 226 + Test: "TestAddition", 227 227 + Content: oldContent, 228 228 + } 229 229 + 230 230 + newSnap := &files.Snapshot{ 231 231 + Title: "Pure Addition", 232 232 + Test: "TestAddition", 233 233 + Content: newContent, 234 234 + } 235 235 + 236 236 + diffLines := diff.Histogram(oldContent, newContent) 237 237 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 238 238 + 239 239 + validation := BoxValidation{ 240 240 + Title: "Pure Addition", 241 241 + TestName: "TestAddition", 242 242 + FileName: "testaddition.snap", 243 243 + HasTitle: true, 244 244 + HasTestName: true, 245 245 + HasFileName: true, 246 246 + ExpectedAdds: []string{"line3", "line4"}, 247 247 + ExpectedDeletes: []string{}, 248 248 + ExpectedContext: []string{"line1", "line2"}, 249 249 + HasTopBar: true, 250 250 + HasBottomBar: true, 251 251 + MinLines: 4, // 2 shared + 2 adds 252 252 + } 253 253 + 254 254 + ValidateDiffBox(t, result, validation) 255 255 + } 256 256 + 257 257 + // TestDiffSnapshotBox_PureDeletion tests deleting lines only 258 258 + func TestDiffSnapshotBox_PureDeletion(t *testing.T) { 259 259 + os.Unsetenv("NO_COLOR") 260 260 + os.Setenv("COLUMNS", "100") 261 261 + defer os.Unsetenv("COLUMNS") 262 262 + 263 263 + oldContent := "line1\nline2\nline3\nline4" 264 264 + newContent := "line1\nline2" 265 265 + 266 266 + oldSnap := &files.Snapshot{ 267 267 + Title: "Pure Deletion", 268 268 + Test: "TestDeletion", 269 269 + Content: oldContent, 270 270 + } 271 271 + 272 272 + newSnap := &files.Snapshot{ 273 273 + Title: "Pure Deletion", 274 274 + Test: "TestDeletion", 275 275 + Content: newContent, 276 276 + } 277 277 + 278 278 + diffLines := diff.Histogram(oldContent, newContent) 279 279 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 280 280 + 281 281 + validation := BoxValidation{ 282 282 + Title: "Pure Deletion", 283 283 + TestName: "TestDeletion", 284 284 + FileName: "testdeletion.snap", 285 285 + HasTitle: true, 286 286 + HasTestName: true, 287 287 + HasFileName: true, 288 288 + ExpectedAdds: []string{}, 289 289 + ExpectedDeletes: []string{"line3", "line4"}, 290 290 + ExpectedContext: []string{"line1", "line2"}, 291 291 + HasTopBar: true, 292 292 + HasBottomBar: true, 293 293 + MinLines: 4, // 2 shared + 2 deletes 294 294 + } 295 295 + 296 296 + ValidateDiffBox(t, result, validation) 297 297 + } 298 298 + 299 299 + // TestDiffSnapshotBox_ComplexMixed tests multiple types of changes 300 300 + func TestDiffSnapshotBox_ComplexMixed(t *testing.T) { 301 301 + os.Unsetenv("NO_COLOR") 302 302 + os.Setenv("COLUMNS", "120") 303 303 + defer os.Unsetenv("COLUMNS") 304 304 + 305 305 + oldContent := `unchanged1 306 306 + delete1 307 307 + delete2 308 308 + unchanged2 309 309 + modify_old 310 310 + unchanged3` 311 311 + 312 312 + newContent := `unchanged1 313 313 + unchanged2 314 314 + modify_new 315 315 + add1 316 316 + unchanged3 317 317 + add2` 318 318 + 319 319 + oldSnap := &files.Snapshot{ 320 320 + Title: "Complex Mixed", 321 321 + Test: "TestComplexMixed", 322 322 + Content: oldContent, 323 323 + } 324 324 + 325 325 + newSnap := &files.Snapshot{ 326 326 + Title: "Complex Mixed", 327 327 + Test: "TestComplexMixed", 328 328 + Content: newContent, 329 329 + } 330 330 + 331 331 + diffLines := diff.Histogram(oldContent, newContent) 332 332 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 333 333 + 334 334 + validation := BoxValidation{ 335 335 + Title: "Complex Mixed", 336 336 + TestName: "TestComplexMixed", 337 337 + FileName: "testcomplexmixed.snap", 338 338 + HasTitle: true, 339 339 + HasTestName: true, 340 340 + HasFileName: true, 341 341 + ExpectedAdds: []string{"modify_new", "add1", "add2"}, 342 342 + ExpectedDeletes: []string{"delete1", "delete2", "modify_old"}, 343 343 + ExpectedContext: []string{"unchanged1", "unchanged2", "unchanged3"}, 344 344 + HasTopBar: true, 345 345 + HasBottomBar: true, 346 346 + MinLines: 9, // 3 shared + 3 deletes + 3 adds 347 347 + } 348 348 + 349 349 + ValidateDiffBox(t, result, validation) 350 350 + } 351 351 + 352 352 + // TestDiffSnapshotBox_EmptyOld tests diff from empty to content 353 353 + func TestDiffSnapshotBox_EmptyOld(t *testing.T) { 354 354 + os.Unsetenv("NO_COLOR") 355 355 + os.Setenv("COLUMNS", "100") 356 356 + defer os.Unsetenv("COLUMNS") 357 357 + 358 358 + oldContent := "" 359 359 + newContent := "line1\nline2\nline3" 360 360 + 361 361 + oldSnap := &files.Snapshot{ 362 362 + Title: "Empty to Content", 363 363 + Test: "TestEmptyOld", 364 364 + Content: oldContent, 365 365 + } 366 366 + 367 367 + newSnap := &files.Snapshot{ 368 368 + Title: "Empty to Content", 369 369 + Test: "TestEmptyOld", 370 370 + Content: newContent, 371 371 + } 372 372 + 373 373 + diffLines := diff.Histogram(oldContent, newContent) 374 374 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 375 375 + 376 376 + validation := BoxValidation{ 377 377 + Title: "Empty to Content", 378 378 + TestName: "TestEmptyOld", 379 379 + FileName: "testemptyold.snap", 380 380 + HasTitle: true, 381 381 + HasTestName: true, 382 382 + HasFileName: true, 383 383 + ExpectedAdds: []string{"line1", "line2", "line3"}, 384 384 + ExpectedDeletes: []string{}, 385 385 + ExpectedContext: []string{}, 386 386 + HasTopBar: true, 387 387 + HasBottomBar: true, 388 388 + MinLines: 3, // 3 adds 389 389 + } 390 390 + 391 391 + ValidateDiffBox(t, result, validation) 392 392 + } 393 393 + 394 394 + // TestDiffSnapshotBox_EmptyNew tests diff from content to empty 395 395 + func TestDiffSnapshotBox_EmptyNew(t *testing.T) { 396 396 + os.Unsetenv("NO_COLOR") 397 397 + os.Setenv("COLUMNS", "100") 398 398 + defer os.Unsetenv("COLUMNS") 399 399 + 400 400 + oldContent := "line1\nline2\nline3" 401 401 + newContent := "" 402 402 + 403 403 + oldSnap := &files.Snapshot{ 404 404 + Title: "Content to Empty", 405 405 + Test: "TestEmptyNew", 406 406 + Content: oldContent, 407 407 + } 408 408 + 409 409 + newSnap := &files.Snapshot{ 410 410 + Title: "Content to Empty", 411 411 + Test: "TestEmptyNew", 412 412 + Content: newContent, 413 413 + } 414 414 + 415 415 + diffLines := diff.Histogram(oldContent, newContent) 416 416 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 417 417 + 418 418 + validation := BoxValidation{ 419 419 + Title: "Content to Empty", 420 420 + TestName: "TestEmptyNew", 421 421 + FileName: "testemptynew.snap", 422 422 + HasTitle: true, 423 423 + HasTestName: true, 424 424 + HasFileName: true, 425 425 + ExpectedAdds: []string{}, 426 426 + ExpectedDeletes: []string{"line1", "line2", "line3"}, 427 427 + ExpectedContext: []string{}, 428 428 + HasTopBar: true, 429 429 + HasBottomBar: true, 430 430 + MinLines: 3, // 3 deletes 431 431 + } 432 432 + 433 433 + ValidateDiffBox(t, result, validation) 434 434 + } 435 435 + 436 436 + // TestDiffSnapshotBox_NoTitle tests snapshot without title 437 437 + func TestDiffSnapshotBox_NoTitle(t *testing.T) { 438 438 + os.Unsetenv("NO_COLOR") 439 439 + os.Setenv("COLUMNS", "100") 440 440 + defer os.Unsetenv("COLUMNS") 441 441 + 442 442 + oldContent := "old" 443 443 + newContent := "new" 444 444 + 445 445 + oldSnap := &files.Snapshot{ 446 446 + Title: "", 447 447 + Test: "TestNoTitle", 448 448 + Content: oldContent, 449 449 + } 450 450 + 451 451 + newSnap := &files.Snapshot{ 452 452 + Title: "", 453 453 + Test: "TestNoTitle", 454 454 + Content: newContent, 455 455 + } 456 456 + 457 457 + diffLines := diff.Histogram(oldContent, newContent) 458 458 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 459 459 + 460 460 + stripped := stripANSI(result) 461 461 + 462 462 + // Should NOT contain "title:" line 463 463 + if strings.Contains(stripped, "title:") { 464 464 + t.Error("Expected no title line when title is empty") 465 465 + } 466 466 + 467 467 + // Should still contain test and file 468 468 + if !strings.Contains(stripped, "test: TestNoTitle") { 469 469 + t.Error("Expected test name to be present") 470 470 + } 471 471 + if !strings.Contains(stripped, "file: testnotitle.snap") { 472 472 + t.Error("Expected file name to be present") 473 473 + } 474 474 + } 475 475 + 476 476 + // TestDiffSnapshotBox_LargeLineNumbers tests proper padding for multi-digit line numbers 477 477 + func TestDiffSnapshotBox_LargeLineNumbers(t *testing.T) { 478 478 + os.Unsetenv("NO_COLOR") 479 479 + os.Setenv("COLUMNS", "120") 480 480 + defer os.Unsetenv("COLUMNS") 481 481 + 482 482 + // Create content with 100+ lines to test 3-digit line numbers 483 483 + oldLines := make([]string, 105) 484 484 + newLines := make([]string, 105) 485 485 + for i := 0; i < 105; i++ { 486 486 + oldLines[i] = fmt.Sprintf("line %d", i+1) 487 487 + newLines[i] = fmt.Sprintf("line %d", i+1) 488 488 + } 489 489 + // Modify lines 50, 75, and 100 490 490 + oldLines[49] = "old line 50" 491 491 + newLines[49] = "new line 50" 492 492 + oldLines[74] = "old line 75" 493 493 + newLines[74] = "new line 75" 494 494 + oldLines[99] = "old line 100" 495 495 + newLines[99] = "new line 100" 496 496 + 497 497 + oldContent := strings.Join(oldLines, "\n") 498 498 + newContent := strings.Join(newLines, "\n") 499 499 + 500 500 + oldSnap := &files.Snapshot{ 501 501 + Title: "Large Line Numbers", 502 502 + Test: "TestLargeLineNumbers", 503 503 + Content: oldContent, 504 504 + } 505 505 + 506 506 + newSnap := &files.Snapshot{ 507 507 + Title: "Large Line Numbers", 508 508 + Test: "TestLargeLineNumbers", 509 509 + Content: newContent, 510 510 + } 511 511 + 512 512 + diffLines := diff.Histogram(oldContent, newContent) 513 513 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 514 514 + 515 515 + stripped := stripANSI(result) 516 516 + 517 517 + // Check that 3-digit line numbers appear 518 518 + if !strings.Contains(stripped, "100") { 519 519 + t.Error("Expected 3-digit line number 100 to appear") 520 520 + } 521 521 + 522 522 + // Validate line number alignment by checking that numbers are right-aligned 523 523 + // Line 1 should have padding for 3 digits 524 524 + lines := strings.Split(stripped, "\n") 525 525 + foundSingleDigit := false 526 526 + foundTripleDigit := false 527 527 + 528 528 + for _, line := range lines { 529 529 + // Look for lines with content markers 530 530 + if strings.Contains(line, "│") || strings.Contains(line, "+") || strings.Contains(line, "-") { 531 531 + // Single digit should have padding (e.g., " 1" or " 2") 532 532 + if strings.Contains(line, " 1 ") || strings.Contains(line, " 2 ") { 533 533 + foundSingleDigit = true 534 534 + } 535 535 + // Triple digit should align (e.g., "100" or "105") 536 536 + if strings.Contains(line, "100 ") || strings.Contains(line, "105 ") { 537 537 + foundTripleDigit = true 538 538 + } 539 539 + } 540 540 + } 541 541 + 542 542 + if !foundSingleDigit { 543 543 + t.Error("Expected to find padded single-digit line numbers") 544 544 + } 545 545 + if !foundTripleDigit { 546 546 + t.Error("Expected to find triple-digit line numbers") 547 547 + } 548 548 + } 549 549 + 550 550 + // TestDiffSnapshotBox_UnicodeContent tests diff with unicode characters 551 551 + func TestDiffSnapshotBox_UnicodeContent(t *testing.T) { 552 552 + os.Unsetenv("NO_COLOR") 553 553 + os.Setenv("COLUMNS", "100") 554 554 + defer os.Unsetenv("COLUMNS") 555 555 + 556 556 + oldContent := "Hello 世界\nこんにちは\n🎉 emoji" 557 557 + newContent := "Hello 世界\nさようなら\n🎊 party" 558 558 + 559 559 + oldSnap := &files.Snapshot{ 560 560 + Title: "Unicode Test", 561 561 + Test: "TestUnicode", 562 562 + Content: oldContent, 563 563 + } 564 564 + 565 565 + newSnap := &files.Snapshot{ 566 566 + Title: "Unicode Test", 567 567 + Test: "TestUnicode", 568 568 + Content: newContent, 569 569 + } 570 570 + 571 571 + diffLines := diff.Histogram(oldContent, newContent) 572 572 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 573 573 + 574 574 + validation := BoxValidation{ 575 575 + Title: "Unicode Test", 576 576 + TestName: "TestUnicode", 577 577 + FileName: "testunicode.snap", 578 578 + HasTitle: true, 579 579 + HasTestName: true, 580 580 + HasFileName: true, 581 581 + ExpectedAdds: []string{"さようなら", "🎊 party"}, 582 582 + ExpectedDeletes: []string{"こんにちは", "🎉 emoji"}, 583 583 + ExpectedContext: []string{"Hello 世界"}, 584 584 + HasTopBar: true, 585 585 + HasBottomBar: true, 586 586 + MinLines: 5, // 1 shared + 2 deletes + 2 adds 587 587 + } 588 588 + 589 589 + ValidateDiffBox(t, result, validation) 590 590 + } 591 591 + 592 592 + // TestNewSnapshotBox_Basic tests the new snapshot box rendering 593 593 + func TestNewSnapshotBox_Basic(t *testing.T) { 594 594 + os.Unsetenv("NO_COLOR") 595 595 + os.Setenv("COLUMNS", "100") 596 596 + defer os.Unsetenv("COLUMNS") 597 597 + 598 598 + content := "line1\nline2\nline3" 599 599 + 600 600 + snap := &files.Snapshot{ 601 601 + Title: "New Snapshot", 602 602 + Test: "TestNewSnapshot", 603 603 + FileName: "test_new.snap", 604 604 + Content: content, 605 605 + } 606 606 + 607 607 + result := pretty.NewSnapshotBox(snap) 608 608 + 609 609 + stripped := stripANSI(result) 610 610 + 611 611 + // Check header 612 612 + if !strings.Contains(stripped, "New Snapshot") { 613 613 + t.Error("Expected 'New Snapshot' header") 614 614 + } 615 615 + 616 616 + // Check metadata 617 617 + if !strings.Contains(stripped, "title: New Snapshot") { 618 618 + t.Error("Expected title in output") 619 619 + } 620 620 + if !strings.Contains(stripped, "test: TestNewSnapshot") { 621 621 + t.Error("Expected test name in output") 622 622 + } 623 623 + if !strings.Contains(stripped, "file: test_new.snap") { 624 624 + t.Error("Expected file name in output") 625 625 + } 626 626 + 627 627 + // Check content lines (all should be green additions) 628 628 + if !containsDiffLine(result, "+", "line1") { 629 629 + t.Error("Expected line1 as addition") 630 630 + } 631 631 + if !containsDiffLine(result, "+", "line2") { 632 632 + t.Error("Expected line2 as addition") 633 633 + } 634 634 + if !containsDiffLine(result, "+", "line3") { 635 635 + t.Error("Expected line3 as addition") 636 636 + } 637 637 + 638 638 + // Check box structure 639 639 + if !strings.Contains(stripped, "┬") { 640 640 + t.Error("Expected top bar with ┬") 641 641 + } 642 642 + if !strings.Contains(stripped, "┴") { 643 643 + t.Error("Expected bottom bar with ┴") 644 644 + } 645 645 + } 646 646 + 647 647 + // TestNewSnapshotBox_EmptyContent tests new snapshot with empty content 648 648 + func TestNewSnapshotBox_EmptyContent(t *testing.T) { 649 649 + os.Unsetenv("NO_COLOR") 650 650 + os.Setenv("COLUMNS", "100") 651 651 + defer os.Unsetenv("COLUMNS") 652 652 + 653 653 + snap := &files.Snapshot{ 654 654 + Title: "Empty Snapshot", 655 655 + Test: "TestEmpty", 656 656 + FileName: "test_empty.snap", 657 657 + Content: "", 658 658 + } 659 659 + 660 660 + result := pretty.NewSnapshotBox(snap) 661 661 + 662 662 + // Should still render box with metadata, just no content lines 663 663 + stripped := stripANSI(result) 664 664 + 665 665 + if !strings.Contains(stripped, "title: Empty Snapshot") { 666 666 + t.Error("Expected title in output") 667 667 + } 668 668 + 669 669 + // Should have box structure even with empty content 670 670 + if !strings.Contains(stripped, "┬") { 671 671 + t.Error("Expected top bar with ┬") 672 672 + } 673 673 + if !strings.Contains(stripped, "┴") { 674 674 + t.Error("Expected bottom bar with ┴") 675 675 + } 676 676 + } 677 677 + 678 678 + // Snapshot testing for visual regression 679 679 + 680 680 + func TestDiffSnapshotBox_VisualRegression_SimpleModification(t *testing.T) { 681 681 + os.Unsetenv("NO_COLOR") 682 682 + os.Setenv("COLUMNS", "100") 683 683 + defer os.Unsetenv("COLUMNS") 684 684 + 685 685 + oldContent := "line1\nline2\nline3" 686 686 + newContent := "line1\nmodified\nline3" 687 687 + 688 688 + oldSnap := &files.Snapshot{ 689 689 + Title: "Visual Test", 690 690 + Test: "TestVisualSimple", 691 691 + Content: oldContent, 692 692 + } 693 693 + 694 694 + newSnap := &files.Snapshot{ 695 695 + Title: "Visual Test", 696 696 + Test: "TestVisualSimple", 697 697 + Content: newContent, 698 698 + } 699 699 + 700 700 + diffLines := diff.Histogram(oldContent, newContent) 701 701 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 702 702 + 703 703 + shutter.SnapString(t, "diff_box_simple_modification", result) 704 704 + } 705 705 + 706 706 + func TestDiffSnapshotBox_VisualRegression_ComplexMixed(t *testing.T) { 707 707 + os.Unsetenv("NO_COLOR") 708 708 + os.Setenv("COLUMNS", "120") 709 709 + defer os.Unsetenv("COLUMNS") 710 710 + 711 711 + oldContent := `unchanged1 712 712 + delete1 713 713 + delete2 714 714 + unchanged2 715 715 + modify_old 716 716 + unchanged3` 717 717 + 718 718 + newContent := `unchanged1 719 719 + unchanged2 720 720 + modify_new 721 721 + add1 722 722 + unchanged3 723 723 + add2` 724 724 + 725 725 + oldSnap := &files.Snapshot{ 726 726 + Title: "Visual Complex", 727 727 + Test: "TestVisualComplex", 728 728 + Content: oldContent, 729 729 + } 730 730 + 731 731 + newSnap := &files.Snapshot{ 732 732 + Title: "Visual Complex", 733 733 + Test: "TestVisualComplex", 734 734 + Content: newContent, 735 735 + } 736 736 + 737 737 + diffLines := diff.Histogram(oldContent, newContent) 738 738 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 739 739 + 740 740 + shutter.SnapString(t, "diff_box_complex_mixed", result) 741 741 + } 742 742 + 743 743 + func TestDiffSnapshotBox_VisualRegression_LargeLineNumbers(t *testing.T) { 744 744 + os.Unsetenv("NO_COLOR") 745 745 + os.Setenv("COLUMNS", "120") 746 746 + defer os.Unsetenv("COLUMNS") 747 747 + 748 748 + // Create content with 100+ lines 749 749 + oldLines := make([]string, 105) 750 750 + newLines := make([]string, 105) 751 751 + for i := 0; i < 105; i++ { 752 752 + oldLines[i] = fmt.Sprintf("line %d", i+1) 753 753 + newLines[i] = fmt.Sprintf("line %d", i+1) 754 754 + } 755 755 + oldLines[49] = "old line 50" 756 756 + newLines[49] = "new line 50" 757 757 + oldLines[99] = "old line 100" 758 758 + newLines[99] = "new line 100" 759 759 + 760 760 + oldContent := strings.Join(oldLines, "\n") 761 761 + newContent := strings.Join(newLines, "\n") 762 762 + 763 763 + oldSnap := &files.Snapshot{ 764 764 + Title: "Large Line Numbers", 765 765 + Test: "TestVisualLarge", 766 766 + Content: oldContent, 767 767 + } 768 768 + 769 769 + newSnap := &files.Snapshot{ 770 770 + Title: "Large Line Numbers", 771 771 + Test: "TestVisualLarge", 772 772 + Content: newContent, 773 773 + } 774 774 + 775 775 + diffLines := diff.Histogram(oldContent, newContent) 776 776 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 777 777 + 778 778 + shutter.SnapString(t, "diff_box_large_line_numbers", result) 779 779 + } 780 780 + 781 781 + func TestNewSnapshotBox_VisualRegression(t *testing.T) { 782 782 + os.Unsetenv("NO_COLOR") 783 783 + os.Setenv("COLUMNS", "100") 784 784 + defer os.Unsetenv("COLUMNS") 785 785 + 786 786 + content := "line1\nline2\nline3\nline4\nline5" 787 787 + 788 788 + snap := &files.Snapshot{ 789 789 + Title: "New Snapshot Visual", 790 790 + Test: "TestNewVisual", 791 791 + FileName: "test_new_visual.snap", 792 792 + Content: content, 793 793 + } 794 794 + 795 795 + result := pretty.NewSnapshotBox(snap) 796 796 + 797 797 + shutter.SnapString(t, "new_snapshot_box", result) 798 798 + } 799 799 + 800 800 + // Randomized testing 801 801 + 802 802 + func TestDiffSnapshotBox_Random_Additions(t *testing.T) { 803 803 + os.Unsetenv("NO_COLOR") 804 804 + os.Setenv("COLUMNS", "120") 805 805 + defer os.Unsetenv("COLUMNS") 806 806 + 807 807 + rng := rand.New(rand.NewSource(12345)) // Fixed seed for reproducibility 808 808 + 809 809 + for i := 0; i < 10; i++ { 810 810 + t.Run(fmt.Sprintf("random_addition_%d", i), func(t *testing.T) { 811 811 + // Generate random number of old lines (5-20) 812 812 + numOldLines := rng.Intn(16) + 5 813 813 + oldLines := make([]string, numOldLines) 814 814 + for j := 0; j < numOldLines; j++ { 815 815 + oldLines[j] = fmt.Sprintf("old_line_%d", j+1) 816 816 + } 817 817 + 818 818 + // Add random number of new lines (1-10) 819 819 + numNewLines := rng.Intn(10) + 1 820 820 + newLines := make([]string, numOldLines+numNewLines) 821 821 + copy(newLines, oldLines) 822 822 + for j := 0; j < numNewLines; j++ { 823 823 + newLines[numOldLines+j] = fmt.Sprintf("new_line_%d", j+1) 824 824 + } 825 825 + 826 826 + oldContent := strings.Join(oldLines, "\n") 827 827 + newContent := strings.Join(newLines, "\n") 828 828 + 829 829 + oldSnap := &files.Snapshot{ 830 830 + Title: fmt.Sprintf("Random Addition %d", i), 831 831 + Test: fmt.Sprintf("TestRandomAdd_%d", i), 832 832 + Content: oldContent, 833 833 + } 834 834 + 835 835 + newSnap := &files.Snapshot{ 836 836 + Title: fmt.Sprintf("Random Addition %d", i), 837 837 + Test: fmt.Sprintf("TestRandomAdd_%d", i), 838 838 + Content: newContent, 839 839 + } 840 840 + 841 841 + diffLines := diff.Histogram(oldContent, newContent) 842 842 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 843 843 + 844 844 + // Validate structure 845 845 + stripped := stripANSI(result) 846 846 + 847 847 + // Should have box structure 848 848 + if !strings.Contains(stripped, "┬") { 849 849 + t.Error("Missing top bar") 850 850 + } 851 851 + if !strings.Contains(stripped, "┴") { 852 852 + t.Error("Missing bottom bar") 853 853 + } 854 854 + 855 855 + // Should contain title and test name 856 856 + if !strings.Contains(stripped, fmt.Sprintf("Random Addition %d", i)) { 857 857 + t.Error("Missing title") 858 858 + } 859 859 + 860 860 + // Count additions 861 861 + addCount := strings.Count(result, "+") 862 862 + if addCount < numNewLines { 863 863 + t.Errorf("Expected at least %d additions, got %d", numNewLines, addCount) 864 864 + } 865 865 + }) 866 866 + } 867 867 + } 868 868 + 869 869 + func TestDiffSnapshotBox_Random_Deletions(t *testing.T) { 870 870 + os.Unsetenv("NO_COLOR") 871 871 + os.Setenv("COLUMNS", "120") 872 872 + defer os.Unsetenv("COLUMNS") 873 873 + 874 874 + rng := rand.New(rand.NewSource(54321)) 875 875 + 876 876 + for i := 0; i < 10; i++ { 877 877 + t.Run(fmt.Sprintf("random_deletion_%d", i), func(t *testing.T) { 878 878 + // Generate random number of old lines (10-30) 879 879 + numOldLines := rng.Intn(21) + 10 880 880 + oldLines := make([]string, numOldLines) 881 881 + for j := 0; j < numOldLines; j++ { 882 882 + oldLines[j] = fmt.Sprintf("line_%d", j+1) 883 883 + } 884 884 + 885 885 + // Delete random number of lines (1-5) 886 886 + numToDelete := rng.Intn(5) + 1 887 887 + if numToDelete > numOldLines { 888 888 + numToDelete = numOldLines / 2 889 889 + } 890 890 + newLines := make([]string, numOldLines-numToDelete) 891 891 + copy(newLines, oldLines[:len(newLines)]) 892 892 + 893 893 + oldContent := strings.Join(oldLines, "\n") 894 894 + newContent := strings.Join(newLines, "\n") 895 895 + 896 896 + oldSnap := &files.Snapshot{ 897 897 + Title: fmt.Sprintf("Random Deletion %d", i), 898 898 + Test: fmt.Sprintf("TestRandomDel_%d", i), 899 899 + Content: oldContent, 900 900 + } 901 901 + 902 902 + newSnap := &files.Snapshot{ 903 903 + Title: fmt.Sprintf("Random Deletion %d", i), 904 904 + Test: fmt.Sprintf("TestRandomDel_%d", i), 905 905 + Content: newContent, 906 906 + } 907 907 + 908 908 + diffLines := diff.Histogram(oldContent, newContent) 909 909 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 910 910 + 911 911 + // Validate structure 912 912 + stripped := stripANSI(result) 913 913 + 914 914 + if !strings.Contains(stripped, "┬") { 915 915 + t.Error("Missing top bar") 916 916 + } 917 917 + if !strings.Contains(stripped, "┴") { 918 918 + t.Error("Missing bottom bar") 919 919 + } 920 920 + 921 921 + // Count deletions (at least numToDelete should appear) 922 922 + delCount := strings.Count(result, "-") 923 923 + if delCount < numToDelete { 924 924 + t.Errorf("Expected at least %d deletions, got %d", numToDelete, delCount) 925 925 + } 926 926 + }) 927 927 + } 928 928 + } 929 929 + 930 930 + func TestDiffSnapshotBox_Random_Mixed(t *testing.T) { 931 931 + os.Unsetenv("NO_COLOR") 932 932 + os.Setenv("COLUMNS", "140") 933 933 + defer os.Unsetenv("COLUMNS") 934 934 + 935 935 + rng := rand.New(rand.NewSource(99999)) 936 936 + 937 937 + for i := 0; i < 10; i++ { 938 938 + t.Run(fmt.Sprintf("random_mixed_%d", i), func(t *testing.T) { 939 939 + // Generate random old content (10-30 lines) 940 940 + numOldLines := rng.Intn(21) + 10 941 941 + oldLines := make([]string, numOldLines) 942 942 + for j := 0; j < numOldLines; j++ { 943 943 + oldLines[j] = fmt.Sprintf("old_line_%d_%s", j+1, randomWord(rng)) 944 944 + } 945 945 + 946 946 + // Randomly modify, add, delete 947 947 + newLines := make([]string, 0, numOldLines*2) 948 948 + for j := 0; j < numOldLines; j++ { 949 949 + action := rng.Intn(100) 950 950 + if action < 70 { // 70% keep unchanged 951 951 + newLines = append(newLines, oldLines[j]) 952 952 + } else if action < 85 { // 15% modify 953 953 + newLines = append(newLines, fmt.Sprintf("modified_%d_%s", j+1, randomWord(rng))) 954 954 + } else if action < 95 { // 10% add 955 955 + newLines = append(newLines, oldLines[j]) 956 956 + newLines = append(newLines, fmt.Sprintf("added_%d_%s", j+1, randomWord(rng))) 957 957 + } 958 958 + // 5% delete (skip adding line) 959 959 + } 960 960 + 961 961 + oldContent := strings.Join(oldLines, "\n") 962 962 + newContent := strings.Join(newLines, "\n") 963 963 + 964 964 + oldSnap := &files.Snapshot{ 965 965 + Title: fmt.Sprintf("Random Mixed %d", i), 966 966 + Test: fmt.Sprintf("TestRandomMixed_%d", i), 967 967 + Content: oldContent, 968 968 + } 969 969 + 970 970 + newSnap := &files.Snapshot{ 971 971 + Title: fmt.Sprintf("Random Mixed %d", i), 972 972 + Test: fmt.Sprintf("TestRandomMixed_%d", i), 973 973 + Content: newContent, 974 974 + } 975 975 + 976 976 + diffLines := diff.Histogram(oldContent, newContent) 977 977 + result := pretty.DiffSnapshotBox(oldSnap, newSnap, diffLines) 978 978 + 979 979 + // Validate basic structure 980 980 + stripped := stripANSI(result) 981 981 + 982 982 + if !strings.Contains(stripped, "┬") { 983 983 + t.Error("Missing top bar") 984 984 + } 985 985 + if !strings.Contains(stripped, "┴") { 986 986 + t.Error("Missing bottom bar") 987 987 + } 988 988 + if !strings.Contains(stripped, fmt.Sprintf("Random Mixed %d", i)) { 989 989 + t.Error("Missing title") 990 990 + } 991 991 + 992 992 + // Should have some diff markers 993 993 + hasPlus := strings.Contains(result, "+") 994 994 + hasMinus := strings.Contains(result, "-") 995 995 + hasPipe := strings.Contains(result, "│") 996 996 + 997 997 + if !hasPlus && !hasMinus && !hasPipe { 998 998 + t.Error("Expected at least one type of diff marker") 999 999 + } 1000 1000 + }) 1001 1001 + } 1002 1002 + } 1003 1003 + 1004 1004 + // Helper function for random word generation 1005 1005 + func randomWord(rng *rand.Rand) string { 1006 1006 + words := []string{"apple", "banana", "cherry", "date", "elderberry", "fig", "grape", "honeydew"} 1007 1007 + return words[rng.Intn(len(words))] 1008 1008 + }

+16 -26

internal/pretty/pretty.go

··· 23 23 return 80 24 24 } 25 25 26 26 - func Red(s string) string { 26 26 + func hasColor() bool { 27 27 + return os.Getenv("NO_COLOR") == "" 28 28 + } 29 29 + 30 30 + // colorize wraps text with the given color code 31 31 + func colorize(s, code string) string { 27 32 if !hasColor() { 28 33 return s 29 34 } 30 30 - return colorRed + s + colorReset 35 35 + return code + s + colorReset 36 36 + } 37 37 + 38 38 + func Red(s string) string { 39 39 + return colorize(s, colorRed) 31 40 } 32 41 33 42 func Green(s string) string { 34 34 - if !hasColor() { 35 35 - return s 36 36 - } 37 37 - return colorGreen + s + colorReset 43 43 + return colorize(s, colorGreen) 38 44 } 39 45 40 46 func Yellow(s string) string { 41 41 - if !hasColor() { 42 42 - return s 43 43 - } 44 44 - return colorYellow + s + colorReset 47 47 + return colorize(s, colorYellow) 45 48 } 46 49 47 50 func Blue(s string) string { 48 48 - if !hasColor() { 49 49 - return s 50 50 - } 51 51 - return colorBlue + s + colorReset 51 51 + return colorize(s, colorBlue) 52 52 } 53 53 54 54 func Gray(s string) string { 55 55 - if !hasColor() { 56 56 - return s 57 57 - } 58 58 - return colorGray + s + colorReset 55 55 + return colorize(s, colorGray) 59 56 } 60 57 61 58 func Bold(s string) string { 62 62 - if !hasColor() { 63 63 - return s 64 64 - } 65 65 - return colorBold + s + colorReset 66 66 - } 67 67 - 68 68 - func hasColor() bool { 69 69 - return os.Getenv("NO_COLOR") == "" 59 59 + return colorize(s, colorBold) 70 60 } 71 61 72 62 func Header(text string) string {

+30 -20

internal/review/review.go

··· 27 27 return diff.Histogram(old.Content, new.Content) 28 28 } 29 29 30 30 + // applyToSnapshots applies an operation to all snapshots and returns the count of successful operations 31 31 + func applyToSnapshots(snapshots []string, operation func(string) error) (int, error) { 32 32 + successCount := 0 33 33 + for _, snapTitle := range snapshots { 34 34 + if err := operation(snapTitle); err != nil { 35 35 + return successCount, err 36 36 + } 37 37 + successCount++ 38 38 + } 39 39 + return successCount, nil 40 40 + } 41 41 + 30 42 func Review() error { 31 43 snapshots, err := files.ListNewSnapshots() 32 44 if err != nil { ··· 87 99 case Skip: 88 100 fmt.Println(pretty.Warning("⊘ Snapshot skipped")) 89 101 case AcceptAllChoice: 90 90 - for j := i; j < len(snapshots); j++ { 91 91 - if err := files.AcceptSnapshot(snapshots[j]); err != nil { 92 92 - fmt.Println(pretty.Error("✗ Failed to accept snapshot: " + err.Error())) 93 93 - } 102 102 + remaining := snapshots[i:] 103 103 + if _, err := applyToSnapshots(remaining, files.AcceptSnapshot); err != nil { 104 104 + fmt.Println(pretty.Error("✗ Failed to accept snapshot: " + err.Error())) 105 105 + return err 94 106 } 95 95 - fmt.Printf(pretty.Success("✓ Accepted %d snapshot(s)\n"), len(snapshots)-i) 107 107 + fmt.Printf(pretty.Success("✓ Accepted %d snapshot(s)\n"), len(remaining)) 96 108 return nil 97 109 case RejectAllChoice: 98 98 - for j := i; j < len(snapshots); j++ { 99 99 - if err := files.RejectSnapshot(snapshots[j]); err != nil { 100 100 - fmt.Println(pretty.Error("✗ Failed to reject snapshot: " + err.Error())) 101 101 - } 110 110 + remaining := snapshots[i:] 111 111 + if _, err := applyToSnapshots(remaining, files.RejectSnapshot); err != nil { 112 112 + fmt.Println(pretty.Error("✗ Failed to reject snapshot: " + err.Error())) 113 113 + return err 102 114 } 103 103 - fmt.Printf(pretty.Warning("⊘ Rejected %d snapshot(s)\n"), len(snapshots)-i) 115 115 + fmt.Printf(pretty.Warning("⊘ Rejected %d snapshot(s)\n"), len(remaining)) 104 116 return nil 105 117 case SkipAllChoice: 106 118 fmt.Printf(pretty.Warning("⊘ Skipped %d snapshot(s)\n"), len(snapshots)-i) ··· 154 166 return err 155 167 } 156 168 157 157 - for _, testName := range snapshots { 158 158 - if err := files.AcceptSnapshot(testName); err != nil { 159 159 - return err 160 160 - } 169 169 + count, err := applyToSnapshots(snapshots, files.AcceptSnapshot) 170 170 + if err != nil { 171 171 + return err 161 172 } 162 173 163 163 - fmt.Printf(pretty.Success("✓ Accepted %d snapshot(s)\n"), len(snapshots)) 174 174 + fmt.Printf(pretty.Success("✓ Accepted %d snapshot(s)\n"), count) 164 175 return nil 165 176 } 166 177 ··· 170 181 return err 171 182 } 172 183 173 173 - for _, testName := range snapshots { 174 174 - if err := files.RejectSnapshot(testName); err != nil { 175 175 - return err 176 176 - } 184 184 + count, err := applyToSnapshots(snapshots, files.RejectSnapshot) 185 185 + if err != nil { 186 186 + return err 177 187 } 178 188 179 179 - fmt.Printf(pretty.Warning("⊘ Rejected %d snapshot(s)\n"), len(snapshots)) 189 189 + fmt.Printf(pretty.Warning("⊘ Rejected %d snapshot(s)\n"), count) 180 190 return nil 181 191 }