Skip to content

Commit 7c55afa

Browse files
rstamrstam
committed
CSHARP-1919: Added similar tests for nullable and non-nullable ints.
1 parent 52465eb commit 7c55afa

7 files changed

+1221
-0
lines changed

‎tests/MongoDB.Driver.Tests/FilterDefinitionBuilderIntComparedToIntTests.cs

Lines changed: 195 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,195 @@
1+
/* Copyright 2017 MongoDB Inc.
2+
*
3+
* Licensed under the Apache License, Version 2.0 (the "License");
4+
* you may not use this file except in compliance with the License.
5+
* You may obtain a copy of the License at
6+
*
7+
* http://www.apache.org/licenses/LICENSE-2.0
8+
*
9+
* Unless required by applicable law or agreed to in writing, software
10+
* distributed under the License is distributed on an "AS IS" BASIS,
11+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
* See the License for the specific language governing permissions and
13+
* limitations under the License.
14+
*/
15+
16+
using FluentAssertions;
17+
using MongoDB.Bson.Serialization;
18+
using Xunit;
19+
20+
namespace MongoDB.Driver.Tests
21+
{
22+
public class FilterDefinitionBuilderIntComparedToIntTests
23+
{
24+
private static IBsonSerializerRegistry __registry = BsonSerializer.SerializerRegistry;
25+
private static IBsonSerializer<C> __serializer = BsonSerializer.SerializerRegistry.GetSerializer<C>();
26+
private static FilterDefinitionBuilder<C> __subject = Builders<C>.Filter;
27+
28+
public class C
29+
{
30+
public int I { get; set; }
31+
}
32+
33+
[Theory]
34+
[InlineData(1, "{ I : 1 }")]
35+
public void Eq_with_field_name_should_render_correctly(int value, string expectedFilter)
36+
{
37+
var filter = __subject.Eq("I", value);
38+
39+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
40+
}
41+
42+
[Theory]
43+
[InlineData(1, "{ I : 1 }")]
44+
public void Eq_with_lambda_should_render_correctly(int value, string expectedFilter)
45+
{
46+
var filter = __subject.Eq(x => x.I, value);
47+
48+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
49+
}
50+
51+
[Theory]
52+
[InlineData(1, "{ I : { $gt : 1 } }")]
53+
public void Gt_with_field_name_should_render_correctly(int value, string expectedFilter)
54+
{
55+
var filter = __subject.Gt("I", value);
56+
57+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
58+
}
59+
60+
[Theory]
61+
[InlineData(1, "{ I : { $gt : 1 } }")]
62+
public void Gt_with_lambda_should_render_correctly(int value, string expectedFilter)
63+
{
64+
var filter = __subject.Gt(x => x.I, value);
65+
66+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
67+
}
68+
69+
[Theory]
70+
[InlineData(1, "{ I : { $gte : 1 } }")]
71+
public void Gte_with_field_name_should_render_correctly(int value, string expectedFilter)
72+
{
73+
var filter = __subject.Gte("I", value);
74+
75+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
76+
}
77+
78+
[Theory]
79+
[InlineData(1, "{ I : { $gte : 1 } }")]
80+
public void Gte_with_lambda_should_render_correctly(int value, string expectedFilter)
81+
{
82+
var filter = __subject.Gte(x => x.I, value);
83+
84+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
85+
}
86+
87+
[Theory]
88+
[InlineData(1, "{ I : { $lt : 1 } }")]
89+
public void Lt_with_field_name_should_render_correctly(int value, string expectedFilter)
90+
{
91+
var filter = __subject.Lt("I", value);
92+
93+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
94+
}
95+
96+
[Theory]
97+
[InlineData(1, "{ I : { $lt : 1 } }")]
98+
public void Lt_with_lambda_should_render_correctly(int value, string expectedFilter)
99+
{
100+
var filter = __subject.Lt(x => x.I, value);
101+
102+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
103+
}
104+
105+
[Theory]
106+
[InlineData(1, "{ I : { $lte : 1 } }")]
107+
public void Lte_with_field_name_should_render_correctly(int value, string expectedFilter)
108+
{
109+
var filter = __subject.Lte("I", value);
110+
111+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
112+
}
113+
114+
[Theory]
115+
[InlineData(1, "{ I : { $lte : 1 } }")]
116+
public void Lte_with_lambda_should_render_correctly(int value, string expectedFilter)
117+
{
118+
var filter = __subject.Lte(x => x.I, value);
119+
120+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
121+
}
122+
123+
[Theory]
124+
[InlineData(1, "{ I : { $ne : 1 } }")]
125+
public void Ne_with_field_name_should_render_correctly(int value, string expectedFilter)
126+
{
127+
var filter = __subject.Ne("I", value);
128+
129+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
130+
}
131+
132+
[Theory]
133+
[InlineData(1, "{ I : { $ne : 1 } }")]
134+
public void Ne_with_lambda_should_render_correctly(int value, string expectedFilter)
135+
{
136+
var filter = __subject.Ne(x => x.I, value);
137+
138+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
139+
}
140+
141+
[Theory]
142+
[InlineData(1, "{ I : 1 }")]
143+
public void Where_operator_equals_should_render_correctly(int value, string expectedFilter)
144+
{
145+
var filter = __subject.Where(x => x.I == value);
146+
147+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
148+
}
149+
150+
[Theory]
151+
[InlineData(1, "{ I : { $gt : 1 } }")]
152+
public void Where_operator_greater_than_should_render_correctly(int value, string expectedFilter)
153+
{
154+
var filter = __subject.Where(x => x.I > value);
155+
156+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
157+
}
158+
159+
[Theory]
160+
[InlineData(1, "{ I : { $gte : 1 } }")]
161+
public void Where_operator_greater_than_or_equal_should_render_correctly(int value, string expectedFilter)
162+
{
163+
var filter = __subject.Where(x => x.I >= value);
164+
165+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
166+
}
167+
168+
[Theory]
169+
[InlineData(1, "{ I : { $lt : 1 } }")]
170+
public void Where_operator_less_than_should_render_correctly(int value, string expectedFilter)
171+
{
172+
var filter = __subject.Where(x => x.I < value);
173+
174+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
175+
}
176+
177+
[Theory]
178+
[InlineData(1, "{ I : { $lte : 1 } }")]
179+
public void Where_operator_less_than_or_equal_should_render_correctly(int value, string expectedFilter)
180+
{
181+
var filter = __subject.Where(x => x.I <= value);
182+
183+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
184+
}
185+
186+
[Theory]
187+
[InlineData(1, "{ I : { $ne : 1 } }")]
188+
public void Where_operator_not_equal_should_render_correctly(int value, string expectedFilter)
189+
{
190+
var filter = __subject.Where(x => x.I != value);
191+
192+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
193+
}
194+
}
195+
}

‎tests/MongoDB.Driver.Tests/FilterDefinitionBuilderIntComparedToIntWithStringRepresentationTests.cs

Lines changed: 198 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,198 @@
1+
/* Copyright 2017 MongoDB Inc.
2+
*
3+
* Licensed under the Apache License, Version 2.0 (the "License");
4+
* you may not use this file except in compliance with the License.
5+
* You may obtain a copy of the License at
6+
*
7+
* http://www.apache.org/licenses/LICENSE-2.0
8+
*
9+
* Unless required by applicable law or agreed to in writing, software
10+
* distributed under the License is distributed on an "AS IS" BASIS,
11+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12+
* See the License for the specific language governing permissions and
13+
* limitations under the License.
14+
*/
15+
16+
using FluentAssertions;
17+
using MongoDB.Bson;
18+
using MongoDB.Bson.Serialization;
19+
using MongoDB.Bson.Serialization.Attributes;
20+
using Xunit;
21+
22+
namespace MongoDB.Driver.Tests
23+
{
24+
public class FilterDefinitionBuilderIntComparedToIntWithStringRepresentationTests
25+
{
26+
private static IBsonSerializerRegistry __registry = BsonSerializer.SerializerRegistry;
27+
private static IBsonSerializer<C> __serializer = BsonSerializer.SerializerRegistry.GetSerializer<C>();
28+
private static FilterDefinitionBuilder<C> __subject = Builders<C>.Filter;
29+
30+
public class C
31+
{
32+
[BsonRepresentation(BsonType.String)]
33+
public int I { get; set; }
34+
}
35+
36+
[Theory]
37+
[InlineData(1, "{ I : \"1\" }")]
38+
public void Eq_with_field_name_should_render_correctly(int value, string expectedFilter)
39+
{
40+
var filter = __subject.Eq("I", value);
41+
42+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
43+
}
44+
45+
[Theory]
46+
[InlineData(1, "{ I : \"1\" }")]
47+
public void Eq_with_lambda_should_render_correctly(int value, string expectedFilter)
48+
{
49+
var filter = __subject.Eq(x => x.I, value);
50+
51+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
52+
}
53+
54+
[Theory]
55+
[InlineData(1, "{ I : { $gt : \"1\" } }")]
56+
public void Gt_with_field_name_should_render_correctly(int value, string expectedFilter)
57+
{
58+
var filter = __subject.Gt("I", value);
59+
60+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
61+
}
62+
63+
[Theory]
64+
[InlineData(1, "{ I : { $gt : \"1\" } }")]
65+
public void Gt_with_lambda_should_render_correctly(int value, string expectedFilter)
66+
{
67+
var filter = __subject.Gt(x => x.I, value);
68+
69+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
70+
}
71+
72+
[Theory]
73+
[InlineData(1, "{ I : { $gte : \"1\" } }")]
74+
public void Gte_with_field_name_should_render_correctly(int value, string expectedFilter)
75+
{
76+
var filter = __subject.Gte("I", value);
77+
78+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
79+
}
80+
81+
[Theory]
82+
[InlineData(1, "{ I : { $gte : \"1\" } }")]
83+
public void Gte_with_lambda_should_render_correctly(int value, string expectedFilter)
84+
{
85+
var filter = __subject.Gte(x => x.I, value);
86+
87+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
88+
}
89+
90+
[Theory]
91+
[InlineData(1, "{ I : { $lt : \"1\" } }")]
92+
public void Lt_with_field_name_should_render_correctly(int value, string expectedFilter)
93+
{
94+
var filter = __subject.Lt("I", value);
95+
96+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
97+
}
98+
99+
[Theory]
100+
[InlineData(1, "{ I : { $lt : \"1\" } }")]
101+
public void Lt_with_lambda_should_render_correctly(int value, string expectedFilter)
102+
{
103+
var filter = __subject.Lt(x => x.I, value);
104+
105+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
106+
}
107+
108+
[Theory]
109+
[InlineData(1, "{ I : { $lte : \"1\" } }")]
110+
public void Lte_with_field_name_should_render_correctly(int value, string expectedFilter)
111+
{
112+
var filter = __subject.Lte("I", value);
113+
114+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
115+
}
116+
117+
[Theory]
118+
[InlineData(1, "{ I : { $lte : \"1\" } }")]
119+
public void Lte_with_lambda_should_render_correctly(int value, string expectedFilter)
120+
{
121+
var filter = __subject.Lte(x => x.I, value);
122+
123+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
124+
}
125+
126+
[Theory]
127+
[InlineData(1, "{ I : { $ne : \"1\" } }")]
128+
public void Ne_with_field_name_should_render_correctly(int value, string expectedFilter)
129+
{
130+
var filter = __subject.Ne("I", value);
131+
132+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
133+
}
134+
135+
[Theory]
136+
[InlineData(1, "{ I : { $ne : \"1\" } }")]
137+
public void Ne_with_lambda_should_render_correctly(int value, string expectedFilter)
138+
{
139+
var filter = __subject.Ne(x => x.I, value);
140+
141+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
142+
}
143+
144+
[Theory]
145+
[InlineData(1, "{ I : \"1\" }")]
146+
public void Where_operator_equals_should_render_correctly(int value, string expectedFilter)
147+
{
148+
var filter = __subject.Where(x => x.I == value);
149+
150+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
151+
}
152+
153+
[Theory]
154+
[InlineData(1, "{ I : { $gt : \"1\" } }")]
155+
public void Where_operator_greater_than_should_render_correctly(int value, string expectedFilter)
156+
{
157+
var filter = __subject.Where(x => x.I > value);
158+
159+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
160+
}
161+
162+
[Theory]
163+
[InlineData(1, "{ I : { $gte : \"1\" } }")]
164+
public void Where_operator_greater_than_or_equal_should_render_correctly(int value, string expectedFilter)
165+
{
166+
var filter = __subject.Where(x => x.I >= value);
167+
168+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
169+
}
170+
171+
[Theory]
172+
[InlineData(1, "{ I : { $lt : \"1\" } }")]
173+
public void Where_operator_less_than_should_render_correctly(int value, string expectedFilter)
174+
{
175+
var filter = __subject.Where(x => x.I < value);
176+
177+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
178+
}
179+
180+
[Theory]
181+
[InlineData(1, "{ I : { $lte : \"1\" } }")]
182+
public void Where_operator_less_than_or_equal_should_render_correctly(int value, string expectedFilter)
183+
{
184+
var filter = __subject.Where(x => x.I <= value);
185+
186+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
187+
}
188+
189+
[Theory]
190+
[InlineData(1, "{ I : { $ne : \"1\" } }")]
191+
public void Where_operator_not_equal_should_render_correctly(int value, string expectedFilter)
192+
{
193+
var filter = __subject.Where(x => x.I != value);
194+
195+
filter.Render(__serializer, __registry).Should().Be(expectedFilter);
196+
}
197+
}
198+
}

0 commit comments

Comments
 (0)