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.44.2

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

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