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

Branches

Tags

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

Clone

HTTPS

Download ZIP

pint/internal/parser

internal/parser/models_test.go

260lines · modecode

RawDownload
Latest commit unavailable.
1package parser_test
2
3import (
4 "strconv"
5 "strings"
6 "testing"
7
8 "github.com/prometheus/common/model"
9 "github.com/stretchr/testify/require"
10
11 "github.com/cloudflare/pint/internal/parser"
12)
13
14func newMustRule(content string) parser.Rule {
15 p := parser.NewParser(false, parser.PrometheusSchema, model.UTF8Validation)
16 file := p.Parse(strings.NewReader(content))
17 if file.Error.Err != nil {
18 panic(file.Error.Err)
19 }
20 for _, group := range file.Groups {
21 for _, rule := range group.Rules {
22 return rule
23 }
24 }
25 return parser.Rule{}
26}
27
28func TestRuleIsIdentical(t *testing.T) {
29 type testCaseT struct {
30 a parser.Rule
31 b parser.Rule
32 equal bool
33 }
34
35 testCases := []testCaseT{
36 {
37 a: parser.Rule{},
38 b: parser.Rule{},
39 equal: true,
40 },
41 {
42 a: newMustRule("- record: foo\n expr: bob\n"),
43 b: newMustRule("- record: foo\n expr: bob\n"),
44 equal: true,
45 },
46 {
47 a: newMustRule("- record: bob\n expr: bob\n"),
48 b: newMustRule("- record: foo\n expr: bob\n"),
49 equal: false,
50 },
51 {
52 a: newMustRule("- record: foo\n expr: bob\n"),
53 b: newMustRule("- record: foo\n expr: bob\n labels: {}\n"),
54 equal: true,
55 },
56 {
57 a: newMustRule("- record: foo\n expr: bob\n labels: {}\n"),
58 b: newMustRule("- record: foo\n expr: bob\n"),
59 equal: true,
60 },
61 {
62 a: newMustRule("- record: foo\n expr: bob\n"),
63 b: newMustRule("- expr: bob\n record: foo\n"),
64 equal: true,
65 },
66 {
67 a: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n"),
68 b: newMustRule("- record: foo\n expr: bob\n"),
69 equal: false,
70 },
71 {
72 a: newMustRule("- record: foo\n expr: bob\n"),
73 b: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n"),
74 equal: false,
75 },
76 {
77 a: newMustRule("- record: foo\n expr: bob\n labels:\n bar: bar\n"),
78 b: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n"),
79 equal: false,
80 },
81 {
82 a: newMustRule("- record: foo\n expr: bob\n"),
83 b: newMustRule("- alert: foo\n expr: bob\n"),
84 equal: false,
85 },
86 {
87 a: newMustRule("- record: foo\n expr: bob\n"),
88 b: newMustRule("- record: foo\n xxx: bob\n"),
89 equal: false,
90 },
91 {
92 a: newMustRule("- record: foo\n expr: bob\n"),
93 b: newMustRule("- record: foo\n expr: bob == 0\n"),
94 equal: false,
95 },
96 {
97 a: newMustRule("- alert: foo\n expr: bob\n"),
98 b: newMustRule("- alert: foo\n expr: bob\n for: 4m\n"),
99 equal: false,
100 },
101 {
102 a: newMustRule("- alert: foo\n expr: bob\n"),
103 b: newMustRule("- record: foo\n expr: bob\n"),
104 equal: false,
105 },
106 {
107 a: newMustRule("- alert: foo\n expr: bob\n"),
108 b: newMustRule("- alert: foo\n expr: bob\n"),
109 equal: true,
110 },
111 {
112 a: newMustRule("- alert: foo\n expr: bob\n"),
113 b: newMustRule("- alert: foo\n expr: bob(\n"),
114 equal: false,
115 },
116 {
117 a: newMustRule("- alert: foo\n expr: bob\n"),
118 b: newMustRule("- alert: foo1\n expr: bob\n"),
119 equal: false,
120 },
121 {
122 a: newMustRule("- alert: foo\n expr: bob\n"),
123 b: newMustRule("- alert: foo\n expr: bob1\n"),
124 equal: false,
125 },
126 {
127 a: newMustRule("- alert: foo\n expr: bob\n for: 4m\n"),
128 b: newMustRule("- alert: foo\n expr: bob\n for: 5m\n"),
129 equal: false,
130 },
131 {
132 a: newMustRule("- alert: foo\n expr: bob\n for: 4m\n"),
133 b: newMustRule("- alert: foo\n expr: bob\n keep_firing_for: 4m\n"),
134 equal: false,
135 },
136 {
137 a: newMustRule("- alert: foo\n expr: bob\n keep_firing_for: 4m\n"),
138 b: newMustRule("- alert: foo\n expr: bob\n for: 4m\n"),
139 equal: false,
140 },
141 {
142 a: newMustRule("- alert: foo\n expr: bob\n keep_firing_for: 3m\n"),
143 b: newMustRule("- alert: foo\n expr: bob\n keep_firing_for: 4m\n"),
144 equal: false,
145 },
146 {
147 a: newMustRule("- alert: foo\n expr: bob\n"),
148 b: newMustRule("- alert: foo\n expr: bob\n labels:\n foo: bar\n"),
149 equal: false,
150 },
151 {
152 a: newMustRule("- alert: foo\n expr: bob\n labels:\n bar: bar\n"),
153 b: newMustRule("- alert: foo\n expr: bob\n labels:\n foo: bar\n"),
154 equal: false,
155 },
156 {
157 a: newMustRule("- alert: foo\n expr: bob\n"),
158 b: newMustRule("- alert: foo\n expr: bob\n annotations:\n foo: bar\n"),
159 equal: false,
160 },
161 {
162 a: newMustRule("- alert: foo\n expr: bob\n annotations:\n bar: bar\n"),
163 b: newMustRule("- alert: foo\n expr: bob\n annotations:\n foo: bar\n"),
164 equal: false,
165 },
166 {
167 a: newMustRule("- alert: foo\n # pint disable promql/series\n expr: bob\n"),
168 b: newMustRule("- alert: foo\n expr: bob\n"),
169 equal: false,
170 },
171 {
172 a: newMustRule("- alert: foo\n expr: bob\n"),
173 b: newMustRule("- alert: foo\n # pint disable promql/series\n expr: bob\n"),
174 equal: false,
175 },
176 }
177
178 for i, tc := range testCases {
179 t.Run(strconv.Itoa(i+1), func(t *testing.T) {
180 equal := tc.a.IsIdentical(tc.b)
181 require.Equal(t, tc.equal, equal)
182 })
183 }
184}
185
186func TestMergeMaps(t *testing.T) {
187 type testCaseT struct {
188 a *parser.YamlMap
189 b *parser.YamlMap
190 output *parser.YamlMap
191 }
192
193 testCases := []testCaseT{
194 {
195 a: nil,
196 b: nil,
197 output: nil,
198 },
199 {
200 a: &parser.YamlMap{},
201 b: nil,
202 output: &parser.YamlMap{},
203 },
204 {
205 a: nil,
206 b: &parser.YamlMap{},
207 output: &parser.YamlMap{},
208 },
209 {
210 a: &parser.YamlMap{},
211 b: &parser.YamlMap{},
212 output: &parser.YamlMap{},
213 },
214 {
215 a: &parser.YamlMap{
216 Key: &parser.YamlNode{Value: "a"},
217 Items: []*parser.YamlKeyValue{
218 {
219 Key: &parser.YamlNode{Value: "1"},
220 },
221 {
222 Key: &parser.YamlNode{Value: "2"},
223 },
224 },
225 },
226 b: &parser.YamlMap{
227 Key: &parser.YamlNode{Value: "b"},
228 Items: []*parser.YamlKeyValue{
229 {
230 Key: &parser.YamlNode{Value: "2"},
231 },
232 {
233 Key: &parser.YamlNode{Value: "3"},
234 },
235 },
236 },
237 output: &parser.YamlMap{
238 Key: &parser.YamlNode{Value: "a"},
239 Items: []*parser.YamlKeyValue{
240 {
241 Key: &parser.YamlNode{Value: "1"},
242 },
243 {
244 Key: &parser.YamlNode{Value: "2"},
245 },
246 {
247 Key: &parser.YamlNode{Value: "3"},
248 },
249 },
250 },
251 },
252 }
253
254 for i, tc := range testCases {
255 t.Run(strconv.Itoa(i+1), func(t *testing.T) {
256 output := parser.MergeMaps(tc.a, tc.b)
257 require.Equal(t, tc.output, output)
258 })
259 }
260}
261