GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

cloudflare/pint

Public

mirrored from https://github.com/cloudflare/pintAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
v0.43.1

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

pint/internal/discovery

internal/discovery/git_branch_test.go

777lines · modecode

RawDownload
Latest commit unavailable.
1package discovery_test
2
3import (
4 "encoding/json"
5 "fmt"
6 "os"
7 "regexp"
8 "strings"
9 "testing"
10
11 "github.com/prometheus/prometheus/model/rulefmt"
12 "github.com/stretchr/testify/require"
13
14 "github.com/cloudflare/pint/internal/discovery"
15 "github.com/cloudflare/pint/internal/git"
16 "github.com/cloudflare/pint/internal/parser"
17)
18
19func gitCommit(t *testing.T, message string) {
20 t.Setenv("GIT_AUTHOR_NAME", "pint")
21 t.Setenv("GIT_AUTHOR_EMAIL", "pint@example.com")
22 t.Setenv("GIT_COMMITTER_NAME", "pint")
23 t.Setenv("GIT_COMMITTER_EMAIL", "pint")
24 _, err := git.RunGit("commit", "-am", fmt.Sprintf("commit %s", message))
25 require.NoError(t, err, "git commit %s", message)
26}
27
28func commitFile(t *testing.T, path, content, message string) {
29 err := os.WriteFile("rules.yml", []byte(content), 0o644)
30 require.NoError(t, err, "write %s", path)
31 _, err = git.RunGit("add", path)
32 require.NoError(t, err, "git add")
33 gitCommit(t, message)
34}
35
36func TestGitBranchFinder(t *testing.T) {
37 includeAll := []*regexp.Regexp{regexp.MustCompile(".*")}
38
39 mustParse := func(offset int, s string) parser.Rule {
40 p := parser.NewParser()
41 r, err := p.Parse([]byte(strings.Repeat("\n", offset) + s))
42 if err != nil {
43 panic(fmt.Sprintf("failed to parse rule:\n---\n%s\n---\nerror: %s", s, err))
44 }
45 if len(r) != 1 {
46 panic(fmt.Sprintf("wrong number of rules returned: %d\n---\n%s\n---", len(r), s))
47 }
48 return r[0]
49 }
50
51 mustErr := func(s string) error {
52 _, errs := rulefmt.Parse([]byte(s))
53 if len(errs) == 0 {
54 panic(s)
55 }
56 return errs[0]
57 }
58
59 type setupFn func(t *testing.T)
60
61 type testCaseT struct {
62 title string
63 setup setupFn
64 finder discovery.GitBranchFinder
65 entries []discovery.Entry
66 err string
67 }
68
69 testCases := []testCaseT{
70 {
71 title: "git list PR commits error - main",
72 setup: func(t *testing.T) {},
73 finder: discovery.NewGitBranchFinder(
74 func(args ...string) ([]byte, error) {
75 return nil, fmt.Errorf("mock git error: %v", args)
76 },
77 includeAll,
78 "main",
79 50,
80 nil,
81 ),
82 entries: nil,
83 err: "failed to get the list of commits to scan: mock git error: [log --format=%H --no-abbrev-commit --reverse main..HEAD]",
84 },
85 {
86 title: "git list PR commits error - master",
87 setup: func(t *testing.T) {},
88 finder: discovery.NewGitBranchFinder(
89 func(args ...string) ([]byte, error) {
90 return nil, fmt.Errorf("mock git error: %v", args)
91 },
92 includeAll,
93 "master",
94 50,
95 nil,
96 ),
97 entries: nil,
98 err: "failed to get the list of commits to scan: mock git error: [log --format=%H --no-abbrev-commit --reverse master..HEAD]",
99 },
100 {
101 title: "too many commits",
102 setup: func(t *testing.T) {},
103 finder: discovery.NewGitBranchFinder(
104 func(args ...string) ([]byte, error) {
105 switch strings.Join(args, " ") {
106 case "log --format=%H --no-abbrev-commit --reverse main..HEAD":
107 return []byte("c1\nc2\nc3\nc4\n"), nil
108 default:
109 return nil, fmt.Errorf("mock git error: %v", args)
110 }
111 },
112 includeAll,
113 "main",
114 3,
115 nil,
116 ),
117 entries: nil,
118 err: "number of commits to check (4) is higher than maxCommits (3), exiting",
119 },
120 {
121 title: "git list modified files error",
122 setup: func(t *testing.T) {},
123 finder: discovery.NewGitBranchFinder(
124 func(args ...string) ([]byte, error) {
125 switch strings.Join(args, " ") {
126 case "log --format=%H --no-abbrev-commit --reverse main..HEAD":
127 return []byte("c1\nc2\nc3\nc4\n"), nil
128 default:
129 return nil, fmt.Errorf("mock git error: %v", args)
130 }
131 },
132 includeAll,
133 "main",
134 4,
135 nil,
136 ),
137 entries: nil,
138 err: "failed to get the list of modified files from git: mock git error: [log --reverse --no-merges --format=%H --name-status c1^..c4]",
139 },
140 {
141 title: "git get commit message error",
142 setup: func(t *testing.T) {},
143 finder: discovery.NewGitBranchFinder(
144 func(args ...string) ([]byte, error) {
145 switch strings.Join(args, " ") {
146 case "log --format=%H --no-abbrev-commit --reverse main..HEAD":
147 return []byte("c1\nc2\nc3\nc4\n"), nil
148 case "log --reverse --no-merges --format=%H --name-status c1^..c4":
149 return []byte("c1\nA\trules.yml\n"), nil
150 default:
151 return nil, fmt.Errorf("mock git error: %v", args)
152 }
153 },
154 includeAll,
155 "main",
156 4,
157 nil,
158 ),
159 entries: nil,
160 err: "failed to get commit message for c1: mock git error: [show -s --format=%B c1]",
161 },
162 {
163 title: "git blame error",
164 setup: func(t *testing.T) {},
165 finder: discovery.NewGitBranchFinder(
166 func(args ...string) ([]byte, error) {
167 switch strings.Join(args, " ") {
168 case "log --format=%H --no-abbrev-commit --reverse main..HEAD":
169 return []byte("c1\nc2\nc3\nc4\n"), nil
170 case "log --reverse --no-merges --format=%H --name-status c1^..c4":
171 return []byte("c1\nA\trules.yml\n"), nil
172 case "ls-tree --format=%(objectmode) %(objecttype) %(path) c1^ rules.yml":
173 return []byte("100644 blob rules.yml"), nil
174 case "ls-tree --format=%(objectmode) %(objecttype) %(path) c1 rules.yml":
175 return []byte("100644 blob rules.yml"), nil
176 case "show -s --format=%B c1":
177 return []byte(""), nil
178 default:
179 return nil, fmt.Errorf("mock git error: %v", args)
180 }
181 },
182 includeAll,
183 "main",
184 4,
185 nil,
186 ),
187 entries: nil,
188 err: "failed to run git blame for rules.yml: mock git error: [blame --line-porcelain -- rules.yml]",
189 },
190 {
191 title: "no rules in file",
192 setup: func(t *testing.T) {
193 commitFile(t, "rules.yml", "# v1\n", "v1")
194
195 _, err := git.RunGit("checkout", "-b", "v2")
196 require.NoError(t, err, "git checkout v2")
197
198 commitFile(t, "rules.yml", "# v2\n", "v2")
199 },
200 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, nil),
201 entries: nil,
202 },
203 {
204 title: "no rule changes",
205 setup: func(t *testing.T) {
206 commitFile(t, "rules.yml", `
207groups:
208- name: v1
209 rules:
210 - record: up:count
211 expr: count(up == 1)
212`, "v1")
213
214 _, err := git.RunGit("checkout", "-b", "v2")
215 require.NoError(t, err, "git checkout v2")
216
217 commitFile(t, "rules.yml", `
218groups:
219- name: v2
220 rules:
221 - record: up:count
222 expr: count(up == 1)
223`, "v2")
224 },
225 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, nil),
226 entries: nil,
227 },
228 {
229 title: "rule changed - strict",
230 setup: func(t *testing.T) {
231 commitFile(t, "rules.yml", `
232groups:
233- name: v1
234 rules:
235 - record: up:count
236 expr: count(up)
237`, "v1")
238
239 _, err := git.RunGit("checkout", "-b", "v2")
240 require.NoError(t, err, "git checkout v2")
241
242 commitFile(t, "rules.yml", `
243groups:
244- name: v2
245 rules:
246 - record: up:count
247 expr: count(up == 1)
248`, "v2")
249 },
250 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, nil),
251 entries: []discovery.Entry{
252 {
253 State: discovery.Modified,
254 ReportedPath: "rules.yml",
255 SourcePath: "rules.yml",
256 ModifiedLines: []int{6},
257 Rule: mustParse(4, "- record: up:count\n expr: count(up == 1)\n"),
258 },
259 },
260 },
261 {
262 title: "rule changed - relaxed",
263 setup: func(t *testing.T) {
264 commitFile(t, "rules.yml", `
265- record: up:count
266 expr: count(up)
267`, "v1")
268
269 _, err := git.RunGit("checkout", "-b", "v2")
270 require.NoError(t, err, "git checkout v2")
271
272 commitFile(t, "rules.yml", `
273- record: up:count
274 expr: count(up == 1)
275`, "v2")
276 },
277 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, includeAll),
278 entries: []discovery.Entry{
279 {
280 State: discovery.Modified,
281 ReportedPath: "rules.yml",
282 SourcePath: "rules.yml",
283 ModifiedLines: []int{3},
284 Rule: mustParse(1, "- record: up:count\n expr: count(up == 1)\n"),
285 },
286 },
287 },
288 {
289 title: "rule changed - empty include list",
290 setup: func(t *testing.T) {
291 commitFile(t, "rules.yml", `
292- record: up:count
293 expr: count(up)
294`, "v1")
295
296 _, err := git.RunGit("checkout", "-b", "v2")
297 require.NoError(t, err, "git checkout v2")
298
299 commitFile(t, "rules.yml", `
300- record: up:count
301 expr: count(up == 1)
302`, "v2")
303 },
304 finder: discovery.NewGitBranchFinder(git.RunGit, nil, "main", 4, includeAll),
305 entries: []discovery.Entry{
306 {
307 State: discovery.Modified,
308 ReportedPath: "rules.yml",
309 SourcePath: "rules.yml",
310 ModifiedLines: []int{3},
311 Rule: mustParse(1, "- record: up:count\n expr: count(up == 1)\n"),
312 },
313 },
314 },
315 {
316 title: "rule changed but file excluded",
317 setup: func(t *testing.T) {
318 commitFile(t, "rules.yml", `
319groups:
320- name: v1
321 rules:
322 - record: up:count
323 expr: count(up)
324`, "v1")
325
326 _, err := git.RunGit("checkout", "-b", "v2")
327 require.NoError(t, err, "git checkout v2")
328
329 commitFile(t, "rules.yml", `
330groups:
331- name: v2
332 rules:
333 - record: up:count
334 expr: count(up == 1)
335`, "v2")
336 },
337 finder: discovery.NewGitBranchFinder(git.RunGit, []*regexp.Regexp{regexp.MustCompile("^foo#")}, "main", 4, nil),
338 entries: nil,
339 },
340 {
341 title: "rule changed - [skip ci]",
342 setup: func(t *testing.T) {
343 commitFile(t, "rules.yml", `
344groups:
345- name: v1
346 rules:
347 - record: up:count
348 expr: count(up)
349`, "v1")
350
351 _, err := git.RunGit("checkout", "-b", "v2")
352 require.NoError(t, err, "git checkout v2")
353
354 commitFile(t, "rules.yml", `
355groups:
356- name: v2
357 rules:
358 - record: up:count
359 expr: count(up == 1)
360`, "v2\nskip this commit\n[skip ci]\n")
361 },
362 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, nil),
363 entries: nil,
364 },
365 {
366 title: "rule changed - [no ci]",
367 setup: func(t *testing.T) {
368 commitFile(t, "rules.yml", `
369groups:
370- name: v1
371 rules:
372 - record: up:count
373 expr: count(up)
374`, "v1")
375
376 _, err := git.RunGit("checkout", "-b", "v2")
377 require.NoError(t, err, "git checkout v2")
378
379 commitFile(t, "rules.yml", `
380groups:
381- name: v2
382 rules:
383 - record: up:count
384 expr: count(up == 1)
385`, "v2\nskip this commit\n[no ci]\n")
386 },
387 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, nil),
388 entries: nil,
389 },
390 {
391 title: "rule symlinked",
392 setup: func(t *testing.T) {
393 commitFile(t, "rules.yml", `
394- record: up:count
395 expr: count(up)
396`, "v1")
397
398 _, err := git.RunGit("checkout", "-b", "v2")
399 require.NoError(t, err, "git checkout v2")
400
401 err = os.Symlink("rules.yml", "symlink.yml")
402 require.NoError(t, err, "symlink")
403 _, err = git.RunGit("add", "symlink.yml")
404 require.NoError(t, err, "git add")
405 gitCommit(t, "v2")
406 },
407 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, includeAll),
408 entries: []discovery.Entry{
409 {
410 State: discovery.Added,
411 ReportedPath: "rules.yml",
412 SourcePath: "symlink.yml",
413 ModifiedLines: []int{2, 3},
414 Rule: mustParse(1, "- record: up:count\n expr: count(up)\n"),
415 },
416 },
417 },
418 {
419 title: "rule changed - multiple rules",
420 setup: func(t *testing.T) {
421 commitFile(t, "rules.yml", `
422groups:
423- name: v1
424 rules:
425 - record: up:count:1
426 expr: count(up)
427 - record: up:count:2
428 expr: count(up)
429 - record: up:count:3
430 expr: count(up)
431`, "v1")
432
433 _, err := git.RunGit("checkout", "-b", "v2")
434 require.NoError(t, err, "git checkout v2")
435
436 commitFile(t, "rules.yml", `
437groups:
438- name: v2
439 rules:
440 - record: up:count:1
441 expr: count(up == 1)
442 - record: up:count:2a
443 expr: count(up)
444 - record: up:count:3
445 expr: count(up)
446 - record: up:count:4
447 expr: count(up)
448`, "v2")
449 },
450 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, nil),
451 entries: []discovery.Entry{
452 {
453 State: discovery.Modified,
454 ReportedPath: "rules.yml",
455 SourcePath: "rules.yml",
456 ModifiedLines: []int{6},
457 Rule: mustParse(4, "- record: up:count:1\n expr: count(up == 1)\n"),
458 },
459 {
460 State: discovery.Added,
461 ReportedPath: "rules.yml",
462 SourcePath: "rules.yml",
463 ModifiedLines: []int{7},
464 Rule: mustParse(6, "- record: up:count:2a\n expr: count(up)\n"),
465 },
466 {
467 State: discovery.Added,
468 ReportedPath: "rules.yml",
469 SourcePath: "rules.yml",
470 ModifiedLines: []int{11, 12},
471 Rule: mustParse(10, "- record: up:count:4\n expr: count(up)\n"),
472 },
473 {
474 State: discovery.Removed,
475 ReportedPath: "rules.yml",
476 SourcePath: "rules.yml",
477 ModifiedLines: []int{7, 8},
478 Rule: mustParse(6, "- record: up:count:2\n expr: count(up)\n"),
479 },
480 },
481 },
482 {
483 title: "rule changed - added extra line",
484 setup: func(t *testing.T) {
485 commitFile(t, "rules.yml", `
486- alert: rule1
487 expr: sum(foo) by(job)
488- alert: rule2
489 expr: sum(foo) by(job)
490 for: 0s
491`, "v1")
492
493 _, err := git.RunGit("checkout", "-b", "v2")
494 require.NoError(t, err, "git checkout v2")
495
496 commitFile(t, "rules.yml", `
497- alert: rule1
498 expr: sum(foo) by(job)
499 for: 0s
500- alert: rule2
501 expr: sum(foo) by(job)
502 for: 0s
503`, "v2")
504 },
505 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, includeAll),
506 entries: []discovery.Entry{
507 {
508 State: discovery.Modified,
509 ReportedPath: "rules.yml",
510 SourcePath: "rules.yml",
511 ModifiedLines: []int{4},
512 Rule: mustParse(1, "- alert: rule1\n expr: sum(foo) by(job)\n for: 0s\n"),
513 },
514 },
515 },
516 {
517 title: "rule removed - head",
518 setup: func(t *testing.T) {
519 commitFile(t, "rules.yml", `
520- alert: rule1
521 expr: sum(foo) by(job)
522- alert: rule2
523 expr: sum(foo) by(job)
524`, "v1")
525
526 _, err := git.RunGit("checkout", "-b", "v2")
527 require.NoError(t, err, "git checkout v2")
528
529 commitFile(t, "rules.yml", `
530- alert: rule2
531 expr: sum(foo) by(job)
532`, "v2")
533 },
534 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, includeAll),
535 entries: []discovery.Entry{
536 {
537 State: discovery.Removed,
538 ReportedPath: "rules.yml",
539 SourcePath: "rules.yml",
540 ModifiedLines: []int{2, 3},
541 Rule: mustParse(1, "- alert: rule1\n expr: sum(foo) by(job)\n"),
542 },
543 },
544 },
545 {
546 title: "rule removed - tail",
547 setup: func(t *testing.T) {
548 commitFile(t, "rules.yml", `
549- alert: rule1
550 expr: sum(foo) by(job)
551- alert: rule2
552 expr: sum(foo) by(job)
553`, "v1")
554
555 _, err := git.RunGit("checkout", "-b", "v2")
556 require.NoError(t, err, "git checkout v2")
557
558 commitFile(t, "rules.yml", `
559- alert: rule1
560 expr: sum(foo) by(job)
561`, "v2")
562 },
563 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, includeAll),
564 entries: []discovery.Entry{
565 {
566 State: discovery.Removed,
567 ReportedPath: "rules.yml",
568 SourcePath: "rules.yml",
569 ModifiedLines: []int{4, 5},
570 Rule: mustParse(3, "- alert: rule2\n expr: sum(foo) by(job)\n"),
571 },
572 },
573 },
574 {
575 title: "rule removed - middle",
576 setup: func(t *testing.T) {
577 commitFile(t, "rules.yml", `
578- alert: rule1
579 expr: sum(foo) by(job)
580- alert: rule2
581 expr: sum(foo) by(job)
582- alert: rule3
583 expr: sum(foo) by(job)
584`, "v1")
585
586 _, err := git.RunGit("checkout", "-b", "v2")
587 require.NoError(t, err, "git checkout v2")
588
589 commitFile(t, "rules.yml", `
590- alert: rule1
591 expr: sum(foo) by(job)
592- alert: rule3
593 expr: sum(foo) by(job)
594`, "v2")
595 },
596 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, includeAll),
597 entries: []discovery.Entry{
598 {
599 State: discovery.Removed,
600 ReportedPath: "rules.yml",
601 SourcePath: "rules.yml",
602 ModifiedLines: []int{4, 5},
603 Rule: mustParse(3, "- alert: rule2\n expr: sum(foo) by(job)\n"),
604 },
605 },
606 },
607 {
608 title: "rule fixed",
609 setup: func(t *testing.T) {
610 commitFile(t, "rules.yml", `
611groups:
612- name: v1
613 rules:
614 - record: up:count
615 expr: count(up)
616 expr: sum(up)
617`, "v1")
618
619 _, err := git.RunGit("checkout", "-b", "v2")
620 require.NoError(t, err, "git checkout v2")
621
622 commitFile(t, "rules.yml", `
623groups:
624- name: v2
625 rules:
626 - record: up:count
627 expr: count(up)
628`, "v2")
629 },
630 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, nil),
631 entries: []discovery.Entry{
632 {
633 State: discovery.Added,
634 ReportedPath: "rules.yml",
635 SourcePath: "rules.yml",
636 ModifiedLines: nil,
637 Rule: mustParse(4, "- record: up:count\n expr: count(up)\n"),
638 },
639 {
640 State: discovery.Removed,
641 ReportedPath: "rules.yml",
642 SourcePath: "rules.yml",
643 ModifiedLines: []int{1, 2, 3, 4, 5, 6, 7},
644 PathError: mustErr(`
645groups:
646- name: v2
647 rules:
648 - record: up:count
649 expr: count(up)
650 expr: sum(up)
651`),
652 },
653 },
654 },
655 {
656 title: "rules duplicated",
657 setup: func(t *testing.T) {
658 commitFile(t, "rules.yml", `
659- alert: rule1
660 expr: sum(foo) by(job)
661- alert: rule2
662 expr: sum(foo) by(job)
663`, "v1")
664
665 _, err := git.RunGit("checkout", "-b", "v2")
666 require.NoError(t, err, "git checkout v2")
667
668 commitFile(t, "rules.yml", `
669- alert: rule1
670 expr: sum(foo) by(job)
671- alert: rule2
672 expr: sum(foo) by(job)
673- alert: rule2
674 expr: sum(foo) by(job)
675- alert: rule1
676 expr: sum(foo) by(job)
677`, "v2")
678 },
679 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, includeAll),
680 entries: []discovery.Entry{
681 {
682 State: discovery.Added,
683 ReportedPath: "rules.yml",
684 SourcePath: "rules.yml",
685 ModifiedLines: []int{6, 7},
686 Rule: mustParse(5, "- alert: rule2\n expr: sum(foo) by(job)\n"),
687 },
688 {
689 State: discovery.Added,
690 ReportedPath: "rules.yml",
691 SourcePath: "rules.yml",
692 ModifiedLines: []int{8, 9},
693 Rule: mustParse(7, "- alert: rule1\n expr: sum(foo) by(job)\n"),
694 },
695 },
696 },
697 {
698 title: "rules duplicated with different query",
699 setup: func(t *testing.T) {
700 commitFile(t, "rules.yml", `
701- alert: rule1
702 expr: sum(foo) by(job)
703`, "v1")
704
705 _, err := git.RunGit("checkout", "-b", "v2")
706 require.NoError(t, err, "git checkout v2")
707
708 commitFile(t, "rules.yml", `
709- alert: rule1
710 expr: up == 0
711- alert: rule1
712 expr: up == 1
713- alert: rule1
714 expr: up != 0
715- alert: rule2
716 expr: sum(foo) by(job)
717`, "v2")
718 },
719 finder: discovery.NewGitBranchFinder(git.RunGit, includeAll, "main", 4, includeAll),
720 entries: []discovery.Entry{
721 {
722 State: discovery.Modified,
723 ReportedPath: "rules.yml",
724 SourcePath: "rules.yml",
725 ModifiedLines: []int{3},
726 Rule: mustParse(1, "- alert: rule1\n expr: up == 0\n"),
727 },
728 {
729 State: discovery.Added,
730 ReportedPath: "rules.yml",
731 SourcePath: "rules.yml",
732 ModifiedLines: []int{4, 5},
733 Rule: mustParse(3, "- alert: rule1\n expr: up == 1\n"),
734 },
735 {
736 State: discovery.Added,
737 ReportedPath: "rules.yml",
738 SourcePath: "rules.yml",
739 ModifiedLines: []int{6, 7},
740 Rule: mustParse(5, "- alert: rule1\n expr: up != 0\n"),
741 },
742 {
743 State: discovery.Added,
744 ReportedPath: "rules.yml",
745 SourcePath: "rules.yml",
746 ModifiedLines: []int{8},
747 Rule: mustParse(7, "- alert: rule2\n expr: sum(foo) by(job)\n"),
748 },
749 },
750 },
751 }
752
753 for _, tc := range testCases {
754 t.Run(tc.title, func(t *testing.T) {
755 dir := t.TempDir()
756 err := os.Chdir(dir)
757 require.NoError(t, err, "chdir")
758
759 _, err = git.RunGit("init", "--initial-branch=main", ".")
760 require.NoError(t, err, "git init")
761
762 tc.setup(t)
763 entries, err := tc.finder.Find()
764 if tc.err != "" {
765 require.EqualError(t, err, tc.err)
766 } else {
767 require.NoError(t, err, "tc.finder.Find()")
768
769 expected, err := json.MarshalIndent(tc.entries, "", " ")
770 require.NoError(t, err, "json(expected)")
771 got, err := json.MarshalIndent(entries, "", " ")
772 require.NoError(t, err, "json(got)")
773 require.Equal(t, string(expected), string(got))
774 }
775 })
776 }
777}
778