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

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