Skip to content

Commit 5ca706c

Browse files
FellmonkeyFellmonkey
committed
Add operator tests and update query method assertions
1 parent f0a6764 commit 5ca706c

File tree

4 files changed

+349
-8
lines changed

4 files changed

+349
-8
lines changed

‎templates/dotnet/Package.Tests/OperatorTests.cs.twig‎

Lines changed: 335 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,335 @@
1+
using System.Collections.Generic;
2+
using System.Text.Json;
3+
using Xunit;
4+
5+
namespace {{ spec.title | caseUcfirst }}.Tests
6+
{
7+
public class OperatorTests
8+
{
9+
[Fact]
10+
public void Increment_ReturnsCorrectOperator()
11+
{
12+
var result = Operator.Increment(1);
13+
var op = JsonSerializer.Deserialize<Operator>(result);
14+
15+
Assert.NotNull(op);
16+
Assert.Equal("increment", op.Method);
17+
Assert.NotNull(op.Values);
18+
Assert.Single(op.Values);
19+
Assert.Equal(1, ((JsonElement)op.Values[0]).GetInt32());
20+
}
21+
22+
[Fact]
23+
public void Increment_WithMax_ReturnsCorrectOperator()
24+
{
25+
var result = Operator.Increment(5, 100);
26+
var op = JsonSerializer.Deserialize<Operator>(result);
27+
28+
Assert.NotNull(op);
29+
Assert.Equal("increment", op.Method);
30+
Assert.NotNull(op.Values);
31+
Assert.Equal(2, op.Values.Count);
32+
Assert.Equal(5, ((JsonElement)op.Values[0]).GetInt32());
33+
Assert.Equal(100, ((JsonElement)op.Values[1]).GetInt32());
34+
}
35+
36+
[Fact]
37+
public void Decrement_ReturnsCorrectOperator()
38+
{
39+
var result = Operator.Decrement(1);
40+
var op = JsonSerializer.Deserialize<Operator>(result);
41+
42+
Assert.NotNull(op);
43+
Assert.Equal("decrement", op.Method);
44+
Assert.NotNull(op.Values);
45+
Assert.Single(op.Values);
46+
Assert.Equal(1, ((JsonElement)op.Values[0]).GetInt32());
47+
}
48+
49+
[Fact]
50+
public void Decrement_WithMin_ReturnsCorrectOperator()
51+
{
52+
var result = Operator.Decrement(3, 0);
53+
var op = JsonSerializer.Deserialize<Operator>(result);
54+
55+
Assert.NotNull(op);
56+
Assert.Equal("decrement", op.Method);
57+
Assert.NotNull(op.Values);
58+
Assert.Equal(2, op.Values.Count);
59+
Assert.Equal(3, ((JsonElement)op.Values[0]).GetInt32());
60+
Assert.Equal(0, ((JsonElement)op.Values[1]).GetInt32());
61+
}
62+
63+
[Fact]
64+
public void Multiply_ReturnsCorrectOperator()
65+
{
66+
var result = Operator.Multiply(2);
67+
var op = JsonSerializer.Deserialize<Operator>(result);
68+
69+
Assert.NotNull(op);
70+
Assert.Equal("multiply", op.Method);
71+
Assert.NotNull(op.Values);
72+
Assert.Single(op.Values);
73+
Assert.Equal(2, ((JsonElement)op.Values[0]).GetInt32());
74+
}
75+
76+
[Fact]
77+
public void Multiply_WithMax_ReturnsCorrectOperator()
78+
{
79+
var result = Operator.Multiply(3, 1000);
80+
var op = JsonSerializer.Deserialize<Operator>(result);
81+
82+
Assert.NotNull(op);
83+
Assert.Equal("multiply", op.Method);
84+
Assert.NotNull(op.Values);
85+
Assert.Equal(2, op.Values.Count);
86+
Assert.Equal(3, ((JsonElement)op.Values[0]).GetInt32());
87+
Assert.Equal(1000, ((JsonElement)op.Values[1]).GetInt32());
88+
}
89+
90+
[Fact]
91+
public void Divide_ReturnsCorrectOperator()
92+
{
93+
var result = Operator.Divide(2);
94+
var op = JsonSerializer.Deserialize<Operator>(result);
95+
96+
Assert.NotNull(op);
97+
Assert.Equal("divide", op.Method);
98+
Assert.NotNull(op.Values);
99+
Assert.Single(op.Values);
100+
Assert.Equal(2, ((JsonElement)op.Values[0]).GetInt32());
101+
}
102+
103+
[Fact]
104+
public void Divide_WithMin_ReturnsCorrectOperator()
105+
{
106+
var result = Operator.Divide(4, 1);
107+
var op = JsonSerializer.Deserialize<Operator>(result);
108+
109+
Assert.NotNull(op);
110+
Assert.Equal("divide", op.Method);
111+
Assert.NotNull(op.Values);
112+
Assert.Equal(2, op.Values.Count);
113+
Assert.Equal(4, ((JsonElement)op.Values[0]).GetInt32());
114+
Assert.Equal(1, ((JsonElement)op.Values[1]).GetInt32());
115+
}
116+
117+
[Fact]
118+
public void Modulo_ReturnsCorrectOperator()
119+
{
120+
var result = Operator.Modulo(5);
121+
var op = JsonSerializer.Deserialize<Operator>(result);
122+
123+
Assert.NotNull(op);
124+
Assert.Equal("modulo", op.Method);
125+
Assert.NotNull(op.Values);
126+
Assert.Single(op.Values);
127+
Assert.Equal(5, ((JsonElement)op.Values[0]).GetInt32());
128+
}
129+
130+
[Fact]
131+
public void Power_ReturnsCorrectOperator()
132+
{
133+
var result = Operator.Power(2);
134+
var op = JsonSerializer.Deserialize<Operator>(result);
135+
136+
Assert.NotNull(op);
137+
Assert.Equal("power", op.Method);
138+
Assert.NotNull(op.Values);
139+
Assert.Single(op.Values);
140+
Assert.Equal(2, ((JsonElement)op.Values[0]).GetInt32());
141+
}
142+
143+
[Fact]
144+
public void Power_WithMax_ReturnsCorrectOperator()
145+
{
146+
var result = Operator.Power(3, 100);
147+
var op = JsonSerializer.Deserialize<Operator>(result);
148+
149+
Assert.NotNull(op);
150+
Assert.Equal("power", op.Method);
151+
Assert.NotNull(op.Values);
152+
Assert.Equal(2, op.Values.Count);
153+
Assert.Equal(3, ((JsonElement)op.Values[0]).GetInt32());
154+
Assert.Equal(100, ((JsonElement)op.Values[1]).GetInt32());
155+
}
156+
157+
[Fact]
158+
public void ArrayAppend_ReturnsCorrectOperator()
159+
{
160+
var result = Operator.ArrayAppend(new List<object>() { "item1", "item2" });
161+
var op = JsonSerializer.Deserialize<Operator>(result);
162+
163+
Assert.NotNull(op);
164+
Assert.Equal("arrayAppend", op.Method);
165+
Assert.NotNull(op.Values);
166+
Assert.Equal(2, op.Values.Count);
167+
}
168+
169+
[Fact]
170+
public void ArrayPrepend_ReturnsCorrectOperator()
171+
{
172+
var result = Operator.ArrayPrepend(new List<object>() { "first", "second" });
173+
var op = JsonSerializer.Deserialize<Operator>(result);
174+
175+
Assert.NotNull(op);
176+
Assert.Equal("arrayPrepend", op.Method);
177+
Assert.NotNull(op.Values);
178+
Assert.Equal(2, op.Values.Count);
179+
}
180+
181+
[Fact]
182+
public void ArrayInsert_ReturnsCorrectOperator()
183+
{
184+
var result = Operator.ArrayInsert(0, "newItem");
185+
var op = JsonSerializer.Deserialize<Operator>(result);
186+
187+
Assert.NotNull(op);
188+
Assert.Equal("arrayInsert", op.Method);
189+
Assert.NotNull(op.Values);
190+
Assert.Equal(2, op.Values.Count);
191+
Assert.Equal(0, ((JsonElement)op.Values[0]).GetInt32());
192+
Assert.Equal("newItem", op.Values[1].ToString());
193+
}
194+
195+
[Fact]
196+
public void ArrayRemove_ReturnsCorrectOperator()
197+
{
198+
var result = Operator.ArrayRemove("oldItem");
199+
var op = JsonSerializer.Deserialize<Operator>(result);
200+
201+
Assert.NotNull(op);
202+
Assert.Equal("arrayRemove", op.Method);
203+
Assert.NotNull(op.Values);
204+
Assert.Single(op.Values);
205+
Assert.Equal("oldItem", op.Values[0].ToString());
206+
}
207+
208+
[Fact]
209+
public void ArrayUnique_ReturnsCorrectOperator()
210+
{
211+
var result = Operator.ArrayUnique();
212+
var op = JsonSerializer.Deserialize<Operator>(result);
213+
214+
Assert.NotNull(op);
215+
Assert.Equal("arrayUnique", op.Method);
216+
Assert.NotNull(op.Values);
217+
Assert.Empty(op.Values);
218+
}
219+
220+
[Fact]
221+
public void ArrayIntersect_ReturnsCorrectOperator()
222+
{
223+
var result = Operator.ArrayIntersect(new List<object>() { "a", "b", "c" });
224+
var op = JsonSerializer.Deserialize<Operator>(result);
225+
226+
Assert.NotNull(op);
227+
Assert.Equal("arrayIntersect", op.Method);
228+
Assert.NotNull(op.Values);
229+
Assert.Equal(3, op.Values.Count);
230+
}
231+
232+
[Fact]
233+
public void ArrayDiff_ReturnsCorrectOperator()
234+
{
235+
var result = Operator.ArrayDiff(new List<object>() { "x", "y" });
236+
var op = JsonSerializer.Deserialize<Operator>(result);
237+
238+
Assert.NotNull(op);
239+
Assert.Equal("arrayDiff", op.Method);
240+
Assert.NotNull(op.Values);
241+
Assert.Equal(2, op.Values.Count);
242+
}
243+
244+
[Fact]
245+
public void ArrayFilter_ReturnsCorrectOperator()
246+
{
247+
var result = Operator.ArrayFilter(Condition.Equal, "test");
248+
var op = JsonSerializer.Deserialize<Operator>(result);
249+
250+
Assert.NotNull(op);
251+
Assert.Equal("arrayFilter", op.Method);
252+
Assert.NotNull(op.Values);
253+
Assert.Equal(2, op.Values.Count);
254+
Assert.Equal("equal", op.Values[0].ToString());
255+
Assert.Equal("test", op.Values[1].ToString());
256+
}
257+
258+
[Fact]
259+
public void StringConcat_ReturnsCorrectOperator()
260+
{
261+
var result = Operator.StringConcat("suffix");
262+
var op = JsonSerializer.Deserialize<Operator>(result);
263+
264+
Assert.NotNull(op);
265+
Assert.Equal("stringConcat", op.Method);
266+
Assert.NotNull(op.Values);
267+
Assert.Single(op.Values);
268+
Assert.Equal("suffix", op.Values[0].ToString());
269+
}
270+
271+
[Fact]
272+
public void StringReplace_ReturnsCorrectOperator()
273+
{
274+
var result = Operator.StringReplace("old", "new");
275+
var op = JsonSerializer.Deserialize<Operator>(result);
276+
277+
Assert.NotNull(op);
278+
Assert.Equal("stringReplace", op.Method);
279+
Assert.NotNull(op.Values);
280+
Assert.Equal(2, op.Values.Count);
281+
Assert.Equal("old", op.Values[0].ToString());
282+
Assert.Equal("new", op.Values[1].ToString());
283+
}
284+
285+
[Fact]
286+
public void Toggle_ReturnsCorrectOperator()
287+
{
288+
var result = Operator.Toggle();
289+
var op = JsonSerializer.Deserialize<Operator>(result);
290+
291+
Assert.NotNull(op);
292+
Assert.Equal("toggle", op.Method);
293+
Assert.NotNull(op.Values);
294+
Assert.Empty(op.Values);
295+
}
296+
297+
[Fact]
298+
public void DateAddDays_ReturnsCorrectOperator()
299+
{
300+
var result = Operator.DateAddDays(7);
301+
var op = JsonSerializer.Deserialize<Operator>(result);
302+
303+
Assert.NotNull(op);
304+
Assert.Equal("dateAddDays", op.Method);
305+
Assert.NotNull(op.Values);
306+
Assert.Single(op.Values);
307+
Assert.Equal(7, ((JsonElement)op.Values[0]).GetInt32());
308+
}
309+
310+
[Fact]
311+
public void DateSubDays_ReturnsCorrectOperator()
312+
{
313+
var result = Operator.DateSubDays(3);
314+
var op = JsonSerializer.Deserialize<Operator>(result);
315+
316+
Assert.NotNull(op);
317+
Assert.Equal("dateSubDays", op.Method);
318+
Assert.NotNull(op.Values);
319+
Assert.Single(op.Values);
320+
Assert.Equal(3, ((JsonElement)op.Values[0]).GetInt32());
321+
}
322+
323+
[Fact]
324+
public void DateSetNow_ReturnsCorrectOperator()
325+
{
326+
var result = Operator.DateSetNow();
327+
var op = JsonSerializer.Deserialize<Operator>(result);
328+
329+
Assert.NotNull(op);
330+
Assert.Equal("dateSetNow", op.Method);
331+
Assert.NotNull(op.Values);
332+
Assert.Empty(op.Values);
333+
}
334+
}
335+
}

‎templates/dotnet/Package.Tests/QueryTests.cs.twig‎

Lines changed: 12 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -488,7 +488,8 @@ namespace {{ spec.title | caseUcfirst }}.Tests
488488
var query = JsonSerializer.Deserialize<Query>(result);
489489

490490
Assert.NotNull(query);
491-
Assert.Equal("createdBefore", query.Method);
491+
Assert.Equal("lessThan", query.Method);
492+
Assert.Equal("$createdAt", query.Attribute);
492493
Assert.NotNull(query.Values);
493494
Assert.Single(query.Values);
494495
Assert.Equal("2023-01-01", query.Values[0].ToString());
@@ -501,7 +502,8 @@ namespace {{ spec.title | caseUcfirst }}.Tests
501502
var query = JsonSerializer.Deserialize<Query>(result);
502503

503504
Assert.NotNull(query);
504-
Assert.Equal("createdAfter", query.Method);
505+
Assert.Equal("greaterThan", query.Method);
506+
Assert.Equal("$createdAt", query.Attribute);
505507
Assert.NotNull(query.Values);
506508
Assert.Single(query.Values);
507509
Assert.Equal("2023-01-01", query.Values[0].ToString());
@@ -514,7 +516,8 @@ namespace {{ spec.title | caseUcfirst }}.Tests
514516
var query = JsonSerializer.Deserialize<Query>(result);
515517

516518
Assert.NotNull(query);
517-
Assert.Equal("createdBetween", query.Method);
519+
Assert.Equal("between", query.Method);
520+
Assert.Equal("$createdAt", query.Attribute);
518521
Assert.NotNull(query.Values);
519522
Assert.Equal(2, query.Values.Count);
520523
Assert.Equal("2023-01-01", query.Values[0].ToString());
@@ -528,7 +531,8 @@ namespace {{ spec.title | caseUcfirst }}.Tests
528531
var query = JsonSerializer.Deserialize<Query>(result);
529532

530533
Assert.NotNull(query);
531-
Assert.Equal("updatedBefore", query.Method);
534+
Assert.Equal("lessThan", query.Method);
535+
Assert.Equal("$updatedAt", query.Attribute);
532536
Assert.NotNull(query.Values);
533537
Assert.Single(query.Values);
534538
Assert.Equal("2023-01-01", query.Values[0].ToString());
@@ -541,7 +545,8 @@ namespace {{ spec.title | caseUcfirst }}.Tests
541545
var query = JsonSerializer.Deserialize<Query>(result);
542546

543547
Assert.NotNull(query);
544-
Assert.Equal("updatedAfter", query.Method);
548+
Assert.Equal("greaterThan", query.Method);
549+
Assert.Equal("$updatedAt", query.Attribute);
545550
Assert.NotNull(query.Values);
546551
Assert.Single(query.Values);
547552
Assert.Equal("2023-01-01", query.Values[0].ToString());
@@ -554,7 +559,8 @@ namespace {{ spec.title | caseUcfirst }}.Tests
554559
var query = JsonSerializer.Deserialize<Query>(result);
555560

556561
Assert.NotNull(query);
557-
Assert.Equal("updatedBetween", query.Method);
562+
Assert.Equal("between", query.Method);
563+
Assert.Equal("$updatedAt", query.Attribute);
558564
Assert.NotNull(query.Values);
559565
Assert.Equal(2, query.Values.Count);
560566
Assert.Equal("2023-01-01", query.Values[0].ToString());

0 commit comments

Comments
 (0)