Skip to content

Commit 2812be1

Browse files
rstamrstam
committed
CSHARP-3704: Temporarily disable tests failing due to SERVER-57300
1 parent 6c8bd32 commit 2812be1

File tree

2 files changed

+116
-120
lines changed

2 files changed

+116
-120
lines changed

‎tests/MongoDB.Driver.Legacy.Tests/Linq/SelectOfTypeHierarchicalTests.cs‎

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@
1818
using MongoDB.Bson;
1919
using MongoDB.Bson.Serialization.Attributes;
2020
using MongoDB.Driver;
21+
using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
2122
using MongoDB.Driver.Linq;
2223
using Xunit;
2324

@@ -249,32 +250,31 @@ where b is D
249250
Assert.Equal(1, Consume(query));
250251
}
251252

252-
[Fact]
253+
[SkippableFact]
253254
public void TestWhereBTypeEqualsB()
254255
{
255-
if (__server.BuildInfo.Version >= new Version(2, 0, 0))
256-
{
257-
var query =
258-
from b in __collection.AsQueryable<B>()
259-
where b.GetType() == typeof(B)
260-
select b;
261-
262-
var translatedQuery = MongoQueryTranslator.Translate(query);
263-
Assert.IsType<SelectQuery>(translatedQuery);
264-
Assert.Same(__collection, translatedQuery.Collection);
265-
Assert.Same(typeof(B), translatedQuery.DocumentType);
266-
267-
var selectQuery = (SelectQuery)translatedQuery;
268-
Assert.Equal("(B b) => (b.GetType() == typeof(B))", ExpressionFormatter.ToString(selectQuery.Where));
269-
Assert.Equal(null, selectQuery.OfType); // OfType ignored because <T> was the same as <TDocument>
270-
Assert.Null(selectQuery.OrderBy);
271-
Assert.Null(selectQuery.Projection);
272-
Assert.Null(selectQuery.Skip);
273-
Assert.Null(selectQuery.Take);
274-
275-
Assert.Equal("{ \"_t.0\" : { \"$exists\" : false }, \"_t\" : \"B\" }", selectQuery.BuildQuery().ToJson());
276-
Assert.Equal(1, Consume(query));
277-
}
256+
RequireServer.Check().VersionGreaterThanOrEqualTo("2.0.0").VersionLessThan("5.0.0-");
257+
258+
var query =
259+
from b in __collection.AsQueryable<B>()
260+
where b.GetType() == typeof(B)
261+
select b;
262+
263+
var translatedQuery = MongoQueryTranslator.Translate(query);
264+
Assert.IsType<SelectQuery>(translatedQuery);
265+
Assert.Same(__collection, translatedQuery.Collection);
266+
Assert.Same(typeof(B), translatedQuery.DocumentType);
267+
268+
var selectQuery = (SelectQuery)translatedQuery;
269+
Assert.Equal("(B b) => (b.GetType() == typeof(B))", ExpressionFormatter.ToString(selectQuery.Where));
270+
Assert.Equal(null, selectQuery.OfType); // OfType ignored because <T> was the same as <TDocument>
271+
Assert.Null(selectQuery.OrderBy);
272+
Assert.Null(selectQuery.Projection);
273+
Assert.Null(selectQuery.Skip);
274+
Assert.Null(selectQuery.Take);
275+
276+
Assert.Equal("{ \"_t.0\" : { \"$exists\" : false }, \"_t\" : \"B\" }", selectQuery.BuildQuery().ToJson());
277+
Assert.Equal(1, Consume(query));
278278
}
279279

280280
[Fact]

‎tests/MongoDB.Driver.Legacy.Tests/Linq/SelectQueryTests.cs‎

Lines changed: 92 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
using MongoDB.Bson.Serialization.Attributes;
2323
using MongoDB.Driver;
2424
using MongoDB.Driver.Builders;
25+
using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
2526
using MongoDB.Driver.Linq;
2627
using Xunit;
2728

@@ -4474,30 +4475,29 @@ where c.SA[0].Contains("o")
44744475
}
44754476
}
44764477

4477-
[Fact]
4478+
[SkippableFact]
44784479
public void TestWhereSASub0ContainsONot()
44794480
{
4480-
if (__server.BuildInfo.Version >= new Version(1, 8, 0))
4481-
{
4482-
var query = from c in __collection.AsQueryable<C>()
4483-
where !c.SA[0].Contains("o")
4484-
select c;
4481+
RequireServer.Check().VersionGreaterThanOrEqualTo("1.8.0").VersionLessThan("5.0.0-");
44854482

4486-
var translatedQuery = MongoQueryTranslator.Translate(query);
4487-
Assert.IsType<SelectQuery>(translatedQuery);
4488-
Assert.Same(__collection, translatedQuery.Collection);
4489-
Assert.Same(typeof(C), translatedQuery.DocumentType);
4483+
var query = from c in __collection.AsQueryable<C>()
4484+
where !c.SA[0].Contains("o")
4485+
select c;
44904486

4491-
var selectQuery = (SelectQuery)translatedQuery;
4492-
Assert.Equal("(C c) => !c.SA[0].Contains(\"o\")", ExpressionFormatter.ToString(selectQuery.Where));
4493-
Assert.Null(selectQuery.OrderBy);
4494-
Assert.Null(selectQuery.Projection);
4495-
Assert.Null(selectQuery.Skip);
4496-
Assert.Null(selectQuery.Take);
4487+
var translatedQuery = MongoQueryTranslator.Translate(query);
4488+
Assert.IsType<SelectQuery>(translatedQuery);
4489+
Assert.Same(__collection, translatedQuery.Collection);
4490+
Assert.Same(typeof(C), translatedQuery.DocumentType);
44974491

4498-
Assert.Equal("{ \"sa.0\" : { \"$not\" : /o/s } }", selectQuery.BuildQuery().ToJson());
4499-
Assert.Equal(4, Consume(query));
4500-
}
4492+
var selectQuery = (SelectQuery)translatedQuery;
4493+
Assert.Equal("(C c) => !c.SA[0].Contains(\"o\")", ExpressionFormatter.ToString(selectQuery.Where));
4494+
Assert.Null(selectQuery.OrderBy);
4495+
Assert.Null(selectQuery.Projection);
4496+
Assert.Null(selectQuery.Skip);
4497+
Assert.Null(selectQuery.Take);
4498+
4499+
Assert.Equal("{ \"sa.0\" : { \"$not\" : /o/s } }", selectQuery.BuildQuery().ToJson());
4500+
Assert.Equal(4, Consume(query));
45014501
}
45024502

45034503
[Fact]
@@ -4526,30 +4526,29 @@ where c.SA[0].EndsWith("m")
45264526
}
45274527
}
45284528

4529-
[Fact]
4529+
[SkippableFact]
45304530
public void TestWhereSASub0EndsWithMNot()
45314531
{
4532-
if (__server.BuildInfo.Version >= new Version(1, 8, 0))
4533-
{
4534-
var query = from c in __collection.AsQueryable<C>()
4535-
where !c.SA[0].EndsWith("m")
4536-
select c;
4532+
RequireServer.Check().VersionGreaterThanOrEqualTo("1.8.0").VersionLessThan("5.0.0-");
45374533

4538-
var translatedQuery = MongoQueryTranslator.Translate(query);
4539-
Assert.IsType<SelectQuery>(translatedQuery);
4540-
Assert.Same(__collection, translatedQuery.Collection);
4541-
Assert.Same(typeof(C), translatedQuery.DocumentType);
4534+
var query = from c in __collection.AsQueryable<C>()
4535+
where !c.SA[0].EndsWith("m")
4536+
select c;
45424537

4543-
var selectQuery = (SelectQuery)translatedQuery;
4544-
Assert.Equal("(C c) => !c.SA[0].EndsWith(\"m\")", ExpressionFormatter.ToString(selectQuery.Where));
4545-
Assert.Null(selectQuery.OrderBy);
4546-
Assert.Null(selectQuery.Projection);
4547-
Assert.Null(selectQuery.Skip);
4548-
Assert.Null(selectQuery.Take);
4538+
var translatedQuery = MongoQueryTranslator.Translate(query);
4539+
Assert.IsType<SelectQuery>(translatedQuery);
4540+
Assert.Same(__collection, translatedQuery.Collection);
4541+
Assert.Same(typeof(C), translatedQuery.DocumentType);
45494542

4550-
Assert.Equal("{ \"sa.0\" : { \"$not\" : /m$/s } }", selectQuery.BuildQuery().ToJson());
4551-
Assert.Equal(4, Consume(query));
4552-
}
4543+
var selectQuery = (SelectQuery)translatedQuery;
4544+
Assert.Equal("(C c) => !c.SA[0].EndsWith(\"m\")", ExpressionFormatter.ToString(selectQuery.Where));
4545+
Assert.Null(selectQuery.OrderBy);
4546+
Assert.Null(selectQuery.Projection);
4547+
Assert.Null(selectQuery.Skip);
4548+
Assert.Null(selectQuery.Take);
4549+
4550+
Assert.Equal("{ \"sa.0\" : { \"$not\" : /m$/s } }", selectQuery.BuildQuery().ToJson());
4551+
Assert.Equal(4, Consume(query));
45534552
}
45544553

45554554
[Fact]
@@ -4579,31 +4578,30 @@ where regex.IsMatch(c.SA[0])
45794578
}
45804579
}
45814580

4582-
[Fact]
4581+
[SkippableFact]
45834582
public void TestWhereSASub0IsMatchNot()
45844583
{
4585-
if (__server.BuildInfo.Version >= new Version(1, 8, 0))
4586-
{
4587-
var regex = new Regex(@"^T");
4588-
var query = from c in __collection.AsQueryable<C>()
4589-
where !regex.IsMatch(c.SA[0])
4590-
select c;
4584+
RequireServer.Check().VersionGreaterThanOrEqualTo("1.8.0").VersionLessThan("5.0.0-");
45914585

4592-
var translatedQuery = MongoQueryTranslator.Translate(query);
4593-
Assert.IsType<SelectQuery>(translatedQuery);
4594-
Assert.Same(__collection, translatedQuery.Collection);
4595-
Assert.Same(typeof(C), translatedQuery.DocumentType);
4586+
var regex = new Regex(@"^T");
4587+
var query = from c in __collection.AsQueryable<C>()
4588+
where !regex.IsMatch(c.SA[0])
4589+
select c;
45964590

4597-
var selectQuery = (SelectQuery)translatedQuery;
4598-
Assert.Equal("(C c) => !Regex:(@\"^T\").IsMatch(c.SA[0])", ExpressionFormatter.ToString(selectQuery.Where));
4599-
Assert.Null(selectQuery.OrderBy);
4600-
Assert.Null(selectQuery.Projection);
4601-
Assert.Null(selectQuery.Skip);
4602-
Assert.Null(selectQuery.Take);
4591+
var translatedQuery = MongoQueryTranslator.Translate(query);
4592+
Assert.IsType<SelectQuery>(translatedQuery);
4593+
Assert.Same(__collection, translatedQuery.Collection);
4594+
Assert.Same(typeof(C), translatedQuery.DocumentType);
46034595

4604-
Assert.Equal("{ \"sa.0\" : { \"$not\" : /^T/ } }", selectQuery.BuildQuery().ToJson());
4605-
Assert.Equal(4, Consume(query));
4606-
}
4596+
var selectQuery = (SelectQuery)translatedQuery;
4597+
Assert.Equal("(C c) => !Regex:(@\"^T\").IsMatch(c.SA[0])", ExpressionFormatter.ToString(selectQuery.Where));
4598+
Assert.Null(selectQuery.OrderBy);
4599+
Assert.Null(selectQuery.Projection);
4600+
Assert.Null(selectQuery.Skip);
4601+
Assert.Null(selectQuery.Take);
4602+
4603+
Assert.Equal("{ \"sa.0\" : { \"$not\" : /^T/ } }", selectQuery.BuildQuery().ToJson());
4604+
Assert.Equal(4, Consume(query));
46074605
}
46084606

46094607
[Fact]
@@ -4632,30 +4630,29 @@ where Regex.IsMatch(c.SA[0], "^T")
46324630
}
46334631
}
46344632

4635-
[Fact]
4633+
[SkippableFact]
46364634
public void TestWhereSASub0IsMatchStaticNot()
46374635
{
4638-
if (__server.BuildInfo.Version >= new Version(1, 8, 0))
4639-
{
4640-
var query = from c in __collection.AsQueryable<C>()
4641-
where !Regex.IsMatch(c.SA[0], "^T")
4642-
select c;
4636+
RequireServer.Check().VersionGreaterThanOrEqualTo("1.8.0").VersionLessThan("5.0.0-");
46434637

4644-
var translatedQuery = MongoQueryTranslator.Translate(query);
4645-
Assert.IsType<SelectQuery>(translatedQuery);
4646-
Assert.Same(__collection, translatedQuery.Collection);
4647-
Assert.Same(typeof(C), translatedQuery.DocumentType);
4638+
var query = from c in __collection.AsQueryable<C>()
4639+
where !Regex.IsMatch(c.SA[0], "^T")
4640+
select c;
46484641

4649-
var selectQuery = (SelectQuery)translatedQuery;
4650-
Assert.Equal("(C c) => !Regex.IsMatch(c.SA[0], \"^T\")", ExpressionFormatter.ToString(selectQuery.Where));
4651-
Assert.Null(selectQuery.OrderBy);
4652-
Assert.Null(selectQuery.Projection);
4653-
Assert.Null(selectQuery.Skip);
4654-
Assert.Null(selectQuery.Take);
4642+
var translatedQuery = MongoQueryTranslator.Translate(query);
4643+
Assert.IsType<SelectQuery>(translatedQuery);
4644+
Assert.Same(__collection, translatedQuery.Collection);
4645+
Assert.Same(typeof(C), translatedQuery.DocumentType);
46554646

4656-
Assert.Equal("{ \"sa.0\" : { \"$not\" : /^T/ } }", selectQuery.BuildQuery().ToJson());
4657-
Assert.Equal(4, Consume(query));
4658-
}
4647+
var selectQuery = (SelectQuery)translatedQuery;
4648+
Assert.Equal("(C c) => !Regex.IsMatch(c.SA[0], \"^T\")", ExpressionFormatter.ToString(selectQuery.Where));
4649+
Assert.Null(selectQuery.OrderBy);
4650+
Assert.Null(selectQuery.Projection);
4651+
Assert.Null(selectQuery.Skip);
4652+
Assert.Null(selectQuery.Take);
4653+
4654+
Assert.Equal("{ \"sa.0\" : { \"$not\" : /^T/ } }", selectQuery.BuildQuery().ToJson());
4655+
Assert.Equal(4, Consume(query));
46594656
}
46604657

46614658
[Fact]
@@ -4710,30 +4707,29 @@ where c.SA[0].StartsWith("T")
47104707
}
47114708
}
47124709

4713-
[Fact]
4710+
[SkippableFact]
47144711
public void TestWhereSASub0StartsWithTNot()
47154712
{
4716-
if (__server.BuildInfo.Version >= new Version(1, 8, 0))
4717-
{
4718-
var query = from c in __collection.AsQueryable<C>()
4719-
where !c.SA[0].StartsWith("T")
4720-
select c;
4713+
RequireServer.Check().VersionGreaterThanOrEqualTo("1.8.0").VersionLessThan("5.0.0-");
47214714

4722-
var translatedQuery = MongoQueryTranslator.Translate(query);
4723-
Assert.IsType<SelectQuery>(translatedQuery);
4724-
Assert.Same(__collection, translatedQuery.Collection);
4725-
Assert.Same(typeof(C), translatedQuery.DocumentType);
4715+
var query = from c in __collection.AsQueryable<C>()
4716+
where !c.SA[0].StartsWith("T")
4717+
select c;
47264718

4727-
var selectQuery = (SelectQuery)translatedQuery;
4728-
Assert.Equal("(C c) => !c.SA[0].StartsWith(\"T\")", ExpressionFormatter.ToString(selectQuery.Where));
4729-
Assert.Null(selectQuery.OrderBy);
4730-
Assert.Null(selectQuery.Projection);
4731-
Assert.Null(selectQuery.Skip);
4732-
Assert.Null(selectQuery.Take);
4719+
var translatedQuery = MongoQueryTranslator.Translate(query);
4720+
Assert.IsType<SelectQuery>(translatedQuery);
4721+
Assert.Same(__collection, translatedQuery.Collection);
4722+
Assert.Same(typeof(C), translatedQuery.DocumentType);
47334723

4734-
Assert.Equal("{ \"sa.0\" : { \"$not\" : /^T/s } }", selectQuery.BuildQuery().ToJson());
4735-
Assert.Equal(4, Consume(query));
4736-
}
4724+
var selectQuery = (SelectQuery)translatedQuery;
4725+
Assert.Equal("(C c) => !c.SA[0].StartsWith(\"T\")", ExpressionFormatter.ToString(selectQuery.Where));
4726+
Assert.Null(selectQuery.OrderBy);
4727+
Assert.Null(selectQuery.Projection);
4728+
Assert.Null(selectQuery.Skip);
4729+
Assert.Null(selectQuery.Take);
4730+
4731+
Assert.Equal("{ \"sa.0\" : { \"$not\" : /^T/s } }", selectQuery.BuildQuery().ToJson());
4732+
Assert.Equal(4, Consume(query));
47374733
}
47384734

47394735
[Fact]

0 commit comments

Comments
 (0)