Skip to content

Commit e2e5ecb

Browse files
author
Robert Stam
committed
Getting unit tests ready for work on CSHARP-423.
1 parent 055744e commit e2e5ecb

File tree

1 file changed

+41
-41
lines changed

1 file changed

+41
-41
lines changed

‎DriverUnitTests/Linq/SelectQueryTests.cs

Lines changed: 41 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -150,7 +150,7 @@ public void Setup()
150150
// documents inserted deliberately out of order to test sorting
151151
_collection.Drop();
152152
_collection.Insert(new C { Id = _id2, X = 2, Y = 11, D = new D { Z = 22 }, A = new [] { 2, 3, 4 }, L = new List<int> { 2, 3, 4 } });
153-
_collection.Insert(new C { Id = _id1, X = 1, Y = 11, D = new D { Z = 11 }, S = "x is 1", SA = new string[] { "Tom", "Dick", "Harry" } });
153+
_collection.Insert(new C { Id = _id1, X = 1, Y = 11, D = new D { Z = 11 }, S = "abc", SA = new string[] { "Tom", "Dick", "Harry" } });
154154
_collection.Insert(new C { Id = _id3, X = 3, Y = 33, D = new D { Z = 33 }, B = true, BA = new bool[] { true }, E = E.A, EA = new E[] { E.A, E.B } });
155155
_collection.Insert(new C { Id = _id5, X = 5, Y = 44, D = new D { Z = 55 }, DBRef = new MongoDBRef("db", "c", 1) });
156156
_collection.Insert(new C { Id = _id4, X = 4, Y = 44, D = new D { Z = 44 } });
@@ -518,7 +518,7 @@ public void TestDistinctS()
518518
select c.S).Distinct();
519519
var results = query.ToList();
520520
Assert.AreEqual(1, results.Count);
521-
Assert.IsTrue(results.Contains("x is 1"));
521+
Assert.IsTrue(results.Contains("abc"));
522522
}
523523

524524
[Test]
@@ -4213,10 +4213,10 @@ public void TestWhereSASub0StartsWithTNot()
42134213
}
42144214

42154215
[Test]
4216-
public void TestWhereSContainsX()
4216+
public void TestWhereSContainsAbc()
42174217
{
42184218
var query = from c in _collection.AsQueryable<C>()
4219-
where c.S.Contains("x")
4219+
where c.S.Contains("abc")
42204220
select c;
42214221

42224222
var translatedQuery = MongoQueryTranslator.Translate(query);
@@ -4225,21 +4225,21 @@ where c.S.Contains("x")
42254225
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
42264226

42274227
var selectQuery = (SelectQuery)translatedQuery;
4228-
Assert.AreEqual("(C c) => c.S.Contains(\"x\")", ExpressionFormatter.ToString(selectQuery.Where));
4228+
Assert.AreEqual("(C c) => c.S.Contains(\"abc\")", ExpressionFormatter.ToString(selectQuery.Where));
42294229
Assert.IsNull(selectQuery.OrderBy);
42304230
Assert.IsNull(selectQuery.Projection);
42314231
Assert.IsNull(selectQuery.Skip);
42324232
Assert.IsNull(selectQuery.Take);
42334233

4234-
Assert.AreEqual("{ \"s\" : /x/ }", selectQuery.BuildQuery().ToJson());
4234+
Assert.AreEqual("{ \"s\" : /abc/ }", selectQuery.BuildQuery().ToJson());
42354235
Assert.AreEqual(1, Consume(query));
42364236
}
42374237

42384238
[Test]
4239-
public void TestWhereSContainsXNot()
4239+
public void TestWhereSContainsAbcNot()
42404240
{
42414241
var query = from c in _collection.AsQueryable<C>()
4242-
where !c.S.Contains("x")
4242+
where !c.S.Contains("abc")
42434243
select c;
42444244

42454245
var translatedQuery = MongoQueryTranslator.Translate(query);
@@ -4248,21 +4248,21 @@ public void TestWhereSContainsXNot()
42484248
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
42494249

42504250
var selectQuery = (SelectQuery)translatedQuery;
4251-
Assert.AreEqual("(C c) => !c.S.Contains(\"x\")", ExpressionFormatter.ToString(selectQuery.Where));
4251+
Assert.AreEqual("(C c) => !c.S.Contains(\"abc\")", ExpressionFormatter.ToString(selectQuery.Where));
42524252
Assert.IsNull(selectQuery.OrderBy);
42534253
Assert.IsNull(selectQuery.Projection);
42544254
Assert.IsNull(selectQuery.Skip);
42554255
Assert.IsNull(selectQuery.Take);
42564256

4257-
Assert.AreEqual("{ \"s\" : { \"$not\" : /x/ } }", selectQuery.BuildQuery().ToJson());
4257+
Assert.AreEqual("{ \"s\" : { \"$not\" : /abc/ } }", selectQuery.BuildQuery().ToJson());
42584258
Assert.AreEqual(4, Consume(query));
42594259
}
42604260

42614261
[Test]
4262-
public void TestWhereSEndsWith1()
4262+
public void TestWhereSEndsWithAbc()
42634263
{
42644264
var query = from c in _collection.AsQueryable<C>()
4265-
where c.S.EndsWith("1")
4265+
where c.S.EndsWith("abc")
42664266
select c;
42674267

42684268
var translatedQuery = MongoQueryTranslator.Translate(query);
@@ -4271,21 +4271,21 @@ where c.S.EndsWith("1")
42714271
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
42724272

42734273
var selectQuery = (SelectQuery)translatedQuery;
4274-
Assert.AreEqual("(C c) => c.S.EndsWith(\"1\")", ExpressionFormatter.ToString(selectQuery.Where));
4274+
Assert.AreEqual("(C c) => c.S.EndsWith(\"abc\")", ExpressionFormatter.ToString(selectQuery.Where));
42754275
Assert.IsNull(selectQuery.OrderBy);
42764276
Assert.IsNull(selectQuery.Projection);
42774277
Assert.IsNull(selectQuery.Skip);
42784278
Assert.IsNull(selectQuery.Take);
42794279

4280-
Assert.AreEqual("{ \"s\" : /1$/ }", selectQuery.BuildQuery().ToJson());
4280+
Assert.AreEqual("{ \"s\" : /abc$/ }", selectQuery.BuildQuery().ToJson());
42814281
Assert.AreEqual(1, Consume(query));
42824282
}
42834283

42844284
[Test]
4285-
public void TestWhereSEndsWith1Not()
4285+
public void TestWhereSEndsWithAbcNot()
42864286
{
42874287
var query = from c in _collection.AsQueryable<C>()
4288-
where !c.S.EndsWith("1")
4288+
where !c.S.EndsWith("abc")
42894289
select c;
42904290

42914291
var translatedQuery = MongoQueryTranslator.Translate(query);
@@ -4294,20 +4294,20 @@ public void TestWhereSEndsWith1Not()
42944294
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
42954295

42964296
var selectQuery = (SelectQuery)translatedQuery;
4297-
Assert.AreEqual("(C c) => !c.S.EndsWith(\"1\")", ExpressionFormatter.ToString(selectQuery.Where));
4297+
Assert.AreEqual("(C c) => !c.S.EndsWith(\"abc\")", ExpressionFormatter.ToString(selectQuery.Where));
42984298
Assert.IsNull(selectQuery.OrderBy);
42994299
Assert.IsNull(selectQuery.Projection);
43004300
Assert.IsNull(selectQuery.Skip);
43014301
Assert.IsNull(selectQuery.Take);
43024302

4303-
Assert.AreEqual("{ \"s\" : { \"$not\" : /1$/ } }", selectQuery.BuildQuery().ToJson());
4303+
Assert.AreEqual("{ \"s\" : { \"$not\" : /abc$/ } }", selectQuery.BuildQuery().ToJson());
43044304
Assert.AreEqual(4, Consume(query));
43054305
}
43064306

43074307
[Test]
43084308
public void TestWhereSIsMatch()
43094309
{
4310-
var regex = new Regex(@"^x");
4310+
var regex = new Regex(@"^abc");
43114311
var query = from c in _collection.AsQueryable<C>()
43124312
where regex.IsMatch(c.S)
43134313
select c;
@@ -4318,20 +4318,20 @@ where regex.IsMatch(c.S)
43184318
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
43194319

43204320
var selectQuery = (SelectQuery)translatedQuery;
4321-
Assert.AreEqual("(C c) => Regex:(@\"^x\").IsMatch(c.S)", ExpressionFormatter.ToString(selectQuery.Where));
4321+
Assert.AreEqual("(C c) => Regex:(@\"^abc\").IsMatch(c.S)", ExpressionFormatter.ToString(selectQuery.Where));
43224322
Assert.IsNull(selectQuery.OrderBy);
43234323
Assert.IsNull(selectQuery.Projection);
43244324
Assert.IsNull(selectQuery.Skip);
43254325
Assert.IsNull(selectQuery.Take);
43264326

4327-
Assert.AreEqual("{ \"s\" : /^x/ }", selectQuery.BuildQuery().ToJson());
4327+
Assert.AreEqual("{ \"s\" : /^abc/ }", selectQuery.BuildQuery().ToJson());
43284328
Assert.AreEqual(1, Consume(query));
43294329
}
43304330

43314331
[Test]
43324332
public void TestWhereSIsMatchNot()
43334333
{
4334-
var regex = new Regex(@"^x");
4334+
var regex = new Regex(@"^abc");
43354335
var query = from c in _collection.AsQueryable<C>()
43364336
where !regex.IsMatch(c.S)
43374337
select c;
@@ -4342,21 +4342,21 @@ public void TestWhereSIsMatchNot()
43424342
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
43434343

43444344
var selectQuery = (SelectQuery)translatedQuery;
4345-
Assert.AreEqual("(C c) => !Regex:(@\"^x\").IsMatch(c.S)", ExpressionFormatter.ToString(selectQuery.Where));
4345+
Assert.AreEqual("(C c) => !Regex:(@\"^abc\").IsMatch(c.S)", ExpressionFormatter.ToString(selectQuery.Where));
43464346
Assert.IsNull(selectQuery.OrderBy);
43474347
Assert.IsNull(selectQuery.Projection);
43484348
Assert.IsNull(selectQuery.Skip);
43494349
Assert.IsNull(selectQuery.Take);
43504350

4351-
Assert.AreEqual("{ \"s\" : { \"$not\" : /^x/ } }", selectQuery.BuildQuery().ToJson());
4351+
Assert.AreEqual("{ \"s\" : { \"$not\" : /^abc/ } }", selectQuery.BuildQuery().ToJson());
43524352
Assert.AreEqual(4, Consume(query));
43534353
}
43544354

43554355
[Test]
43564356
public void TestWhereSIsMatchStatic()
43574357
{
43584358
var query = from c in _collection.AsQueryable<C>()
4359-
where Regex.IsMatch(c.S, "^x")
4359+
where Regex.IsMatch(c.S, "^abc")
43604360
select c;
43614361

43624362
var translatedQuery = MongoQueryTranslator.Translate(query);
@@ -4365,21 +4365,21 @@ where Regex.IsMatch(c.S, "^x")
43654365
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
43664366

43674367
var selectQuery = (SelectQuery)translatedQuery;
4368-
Assert.AreEqual("(C c) => Regex.IsMatch(c.S, \"^x\")", ExpressionFormatter.ToString(selectQuery.Where));
4368+
Assert.AreEqual("(C c) => Regex.IsMatch(c.S, \"^abc\")", ExpressionFormatter.ToString(selectQuery.Where));
43694369
Assert.IsNull(selectQuery.OrderBy);
43704370
Assert.IsNull(selectQuery.Projection);
43714371
Assert.IsNull(selectQuery.Skip);
43724372
Assert.IsNull(selectQuery.Take);
43734373

4374-
Assert.AreEqual("{ \"s\" : /^x/ }", selectQuery.BuildQuery().ToJson());
4374+
Assert.AreEqual("{ \"s\" : /^abc/ }", selectQuery.BuildQuery().ToJson());
43754375
Assert.AreEqual(1, Consume(query));
43764376
}
43774377

43784378
[Test]
43794379
public void TestWhereSIsMatchStaticNot()
43804380
{
43814381
var query = from c in _collection.AsQueryable<C>()
4382-
where !Regex.IsMatch(c.S, "^x")
4382+
where !Regex.IsMatch(c.S, "^abc")
43834383
select c;
43844384

43854385
var translatedQuery = MongoQueryTranslator.Translate(query);
@@ -4388,21 +4388,21 @@ public void TestWhereSIsMatchStaticNot()
43884388
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
43894389

43904390
var selectQuery = (SelectQuery)translatedQuery;
4391-
Assert.AreEqual("(C c) => !Regex.IsMatch(c.S, \"^x\")", ExpressionFormatter.ToString(selectQuery.Where));
4391+
Assert.AreEqual("(C c) => !Regex.IsMatch(c.S, \"^abc\")", ExpressionFormatter.ToString(selectQuery.Where));
43924392
Assert.IsNull(selectQuery.OrderBy);
43934393
Assert.IsNull(selectQuery.Projection);
43944394
Assert.IsNull(selectQuery.Skip);
43954395
Assert.IsNull(selectQuery.Take);
43964396

4397-
Assert.AreEqual("{ \"s\" : { \"$not\" : /^x/ } }", selectQuery.BuildQuery().ToJson());
4397+
Assert.AreEqual("{ \"s\" : { \"$not\" : /^abc/ } }", selectQuery.BuildQuery().ToJson());
43984398
Assert.AreEqual(4, Consume(query));
43994399
}
44004400

44014401
[Test]
44024402
public void TestWhereSIsMatchStaticWithOptions()
44034403
{
44044404
var query = from c in _collection.AsQueryable<C>()
4405-
where Regex.IsMatch(c.S, "^x", RegexOptions.IgnoreCase)
4405+
where Regex.IsMatch(c.S, "^abc", RegexOptions.IgnoreCase)
44064406
select c;
44074407

44084408
var translatedQuery = MongoQueryTranslator.Translate(query);
@@ -4411,21 +4411,21 @@ where Regex.IsMatch(c.S, "^x", RegexOptions.IgnoreCase)
44114411
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
44124412

44134413
var selectQuery = (SelectQuery)translatedQuery;
4414-
Assert.AreEqual("(C c) => Regex.IsMatch(c.S, \"^x\", RegexOptions.IgnoreCase)", ExpressionFormatter.ToString(selectQuery.Where));
4414+
Assert.AreEqual("(C c) => Regex.IsMatch(c.S, \"^abc\", RegexOptions.IgnoreCase)", ExpressionFormatter.ToString(selectQuery.Where));
44154415
Assert.IsNull(selectQuery.OrderBy);
44164416
Assert.IsNull(selectQuery.Projection);
44174417
Assert.IsNull(selectQuery.Skip);
44184418
Assert.IsNull(selectQuery.Take);
44194419

4420-
Assert.AreEqual("{ \"s\" : /^x/i }", selectQuery.BuildQuery().ToJson());
4420+
Assert.AreEqual("{ \"s\" : /^abc/i }", selectQuery.BuildQuery().ToJson());
44214421
Assert.AreEqual(1, Consume(query));
44224422
}
44234423

44244424
[Test]
4425-
public void TestWhereSStartsWithX()
4425+
public void TestWhereSStartsWithAbc()
44264426
{
44274427
var query = from c in _collection.AsQueryable<C>()
4428-
where c.S.StartsWith("x")
4428+
where c.S.StartsWith("abc")
44294429
select c;
44304430

44314431
var translatedQuery = MongoQueryTranslator.Translate(query);
@@ -4434,21 +4434,21 @@ where c.S.StartsWith("x")
44344434
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
44354435

44364436
var selectQuery = (SelectQuery)translatedQuery;
4437-
Assert.AreEqual("(C c) => c.S.StartsWith(\"x\")", ExpressionFormatter.ToString(selectQuery.Where));
4437+
Assert.AreEqual("(C c) => c.S.StartsWith(\"abc\")", ExpressionFormatter.ToString(selectQuery.Where));
44384438
Assert.IsNull(selectQuery.OrderBy);
44394439
Assert.IsNull(selectQuery.Projection);
44404440
Assert.IsNull(selectQuery.Skip);
44414441
Assert.IsNull(selectQuery.Take);
44424442

4443-
Assert.AreEqual("{ \"s\" : /^x/ }", selectQuery.BuildQuery().ToJson());
4443+
Assert.AreEqual("{ \"s\" : /^abc/ }", selectQuery.BuildQuery().ToJson());
44444444
Assert.AreEqual(1, Consume(query));
44454445
}
44464446

44474447
[Test]
4448-
public void TestWhereSStartsWithXNot()
4448+
public void TestWhereSStartsWithAbcNot()
44494449
{
44504450
var query = from c in _collection.AsQueryable<C>()
4451-
where !c.S.StartsWith("x")
4451+
where !c.S.StartsWith("abc")
44524452
select c;
44534453

44544454
var translatedQuery = MongoQueryTranslator.Translate(query);
@@ -4457,13 +4457,13 @@ public void TestWhereSStartsWithXNot()
44574457
Assert.AreSame(typeof(C), translatedQuery.DocumentType);
44584458

44594459
var selectQuery = (SelectQuery)translatedQuery;
4460-
Assert.AreEqual("(C c) => !c.S.StartsWith(\"x\")", ExpressionFormatter.ToString(selectQuery.Where));
4460+
Assert.AreEqual("(C c) => !c.S.StartsWith(\"abc\")", ExpressionFormatter.ToString(selectQuery.Where));
44614461
Assert.IsNull(selectQuery.OrderBy);
44624462
Assert.IsNull(selectQuery.Projection);
44634463
Assert.IsNull(selectQuery.Skip);
44644464
Assert.IsNull(selectQuery.Take);
44654465

4466-
Assert.AreEqual("{ \"s\" : { \"$not\" : /^x/ } }", selectQuery.BuildQuery().ToJson());
4466+
Assert.AreEqual("{ \"s\" : { \"$not\" : /^abc/ } }", selectQuery.BuildQuery().ToJson());
44674467
Assert.AreEqual(4, Consume(query));
44684468
}
44694469

0 commit comments

Comments
 (0)