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

Branches

Tags

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

Clone

HTTPS

Download ZIP

pint/internal/parser

internal/parser/models_test.go

295lines · 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 labels:\n foo: bar\n extra: foo\n"),
83 b: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n"),
84 equal: false,
85 },
86 {
87 a: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n extra: foo\n"),
88 b: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n extra: bar\n"),
89 equal: false,
90 },
91 {
92 a: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n abc: foo\n"),
93 b: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n cba: foo\n"),
94 equal: false,
95 },
96 {
97 a: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n"),
98 b: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n extra: foo\n"),
99 equal: false,
100 },
101 {
102 a: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n extra: foo\n"),
103 b: newMustRule("- record: foo\n expr: bob\n labels:\n foo: bar\n extra: bar\n"),
104 equal: false,
105 },
106 {
107 a: newMustRule("- record: foo\n expr: bob\n"),
108 b: newMustRule("- alert: foo\n expr: bob\n"),
109 equal: false,
110 },
111 {
112 a: newMustRule("- record: foo\n expr: bob\n"),
113 b: newMustRule("- record: foo\n xxx: bob\n"),
114 equal: false,
115 },
116 {
117 a: newMustRule("- record: foo\n expr: bob\n"),
118 b: newMustRule("- record: foo\n expr: bob == 0\n"),
119 equal: false,
120 },
121 {
122 a: newMustRule("- alert: foo\n expr: bob\n"),
123 b: newMustRule("- alert: foo\n expr: bob\n for: 4m\n"),
124 equal: false,
125 },
126 {
127 a: newMustRule("- alert: foo\n expr: bob\n"),
128 b: newMustRule("- record: foo\n expr: bob\n"),
129 equal: false,
130 },
131 {
132 a: newMustRule("- alert: foo\n expr: bob\n"),
133 b: newMustRule("- alert: foo\n expr: bob\n"),
134 equal: true,
135 },
136 {
137 a: newMustRule("- alert: foo\n expr: bob\n"),
138 b: newMustRule("- alert: foo\n expr: bob(\n"),
139 equal: false,
140 },
141 {
142 a: newMustRule("- alert: foo\n expr: bob\n"),
143 b: newMustRule("- alert: foo1\n expr: bob\n"),
144 equal: false,
145 },
146 {
147 a: newMustRule("- alert: foo\n expr: bob\n"),
148 b: newMustRule("- alert: foo\n expr: bob1\n"),
149 equal: false,
150 },
151 {
152 a: newMustRule("- alert: foo\n expr: bob\n for: 4m\n"),
153 b: newMustRule("- alert: foo\n expr: bob\n for: 5m\n"),
154 equal: false,
155 },
156 {
157 a: newMustRule("- alert: foo\n expr: bob\n for: 4m\n"),
158 b: newMustRule("- alert: foo\n expr: bob\n keep_firing_for: 4m\n"),
159 equal: false,
160 },
161 {
162 a: newMustRule("- alert: foo\n expr: bob\n keep_firing_for: 4m\n"),
163 b: newMustRule("- alert: foo\n expr: bob\n for: 4m\n"),
164 equal: false,
165 },
166 {
167 a: newMustRule("- alert: foo\n expr: bob\n keep_firing_for: 3m\n"),
168 b: newMustRule("- alert: foo\n expr: bob\n keep_firing_for: 4m\n"),
169 equal: false,
170 },
171 {
172 a: newMustRule("- alert: foo\n expr: bob\n"),
173 b: newMustRule("- alert: foo\n expr: bob\n labels:\n foo: bar\n"),
174 equal: false,
175 },
176 {
177 a: newMustRule("- alert: foo\n expr: bob\n labels:\n bar: bar\n"),
178 b: newMustRule("- alert: foo\n expr: bob\n labels:\n foo: bar\n"),
179 equal: false,
180 },
181 {
182 a: newMustRule("- alert: foo\n expr: bob\n"),
183 b: newMustRule("- alert: foo\n expr: bob\n annotations:\n foo: bar\n"),
184 equal: false,
185 },
186 {
187 a: newMustRule("- alert: foo\n expr: bob\n annotations:\n bar: bar\n"),
188 b: newMustRule("- alert: foo\n expr: bob\n annotations:\n foo: bar\n"),
189 equal: false,
190 },
191 {
192 a: newMustRule("- alert: foo\n # pint disable promql/series\n expr: bob\n"),
193 b: newMustRule("- alert: foo\n expr: bob\n"),
194 equal: false,
195 },
196 {
197 a: newMustRule("- alert: foo\n expr: bob\n"),
198 b: newMustRule("- alert: foo\n # pint disable promql/series\n expr: bob\n"),
199 equal: false,
200 },
201 {
202 a: newMustRule("- record: colo:labels:equal\n expr: sum(foo) without(job)\n labels:\n same: yes\n"),
203 b: newMustRule("- record: colo:labels:equal\n expr: sum(foo) without(job)\n labels:\n same: yes\n"),
204 equal: true,
205 },
206 {
207 a: newMustRule("- record: foo\n expr: sum(foo)\n labels:\n same: yes\n a: b\n d: c\n"),
208 b: newMustRule("- record: foo\n expr: sum(foo)\n labels:\n same: yes\n a: b\n c: d\n"),
209 equal: false,
210 },
211 }
212
213 for i, tc := range testCases {
214 t.Run(strconv.Itoa(i+1), func(t *testing.T) {
215 equal := tc.a.IsIdentical(tc.b)
216 require.Equal(t, tc.equal, equal, tc.a)
217 })
218 }
219}
220
221func TestMergeMaps(t *testing.T) {
222 type testCaseT struct {
223 a *parser.YamlMap
224 b *parser.YamlMap
225 output *parser.YamlMap
226 }
227
228 testCases := []testCaseT{
229 {
230 a: nil,
231 b: nil,
232 output: nil,
233 },
234 {
235 a: &parser.YamlMap{},
236 b: nil,
237 output: &parser.YamlMap{},
238 },
239 {
240 a: nil,
241 b: &parser.YamlMap{},
242 output: &parser.YamlMap{},
243 },
244 {
245 a: &parser.YamlMap{},
246 b: &parser.YamlMap{},
247 output: &parser.YamlMap{},
248 },
249 {
250 a: &parser.YamlMap{
251 Key: &parser.YamlNode{Value: "a"},
252 Items: []*parser.YamlKeyValue{
253 {
254 Key: &parser.YamlNode{Value: "1"},
255 },
256 {
257 Key: &parser.YamlNode{Value: "2"},
258 },
259 },
260 },
261 b: &parser.YamlMap{
262 Key: &parser.YamlNode{Value: "b"},
263 Items: []*parser.YamlKeyValue{
264 {
265 Key: &parser.YamlNode{Value: "2"},
266 },
267 {
268 Key: &parser.YamlNode{Value: "3"},
269 },
270 },
271 },
272 output: &parser.YamlMap{
273 Key: &parser.YamlNode{Value: "a"},
274 Items: []*parser.YamlKeyValue{
275 {
276 Key: &parser.YamlNode{Value: "1"},
277 },
278 {
279 Key: &parser.YamlNode{Value: "2"},
280 },
281 {
282 Key: &parser.YamlNode{Value: "3"},
283 },
284 },
285 },
286 },
287 }
288
289 for i, tc := range testCases {
290 t.Run(strconv.Itoa(i+1), func(t *testing.T) {
291 output := parser.MergeMaps(tc.a, tc.b)
292 require.Equal(t, tc.output, output)
293 })
294 }
295}
296