public void TestAggregateFunctions()
{
LoadModelNumbers(100);
var queryable = new DatabaseQueryable <NumbersModel>(Db);
var result = (from x in queryable
select x.Number1).Average();
result.Should().BeApproximately(50.5, Double.Epsilon);
queryable = new DatabaseQueryable <NumbersModel>(Db);
result = (from x in queryable
select x.Number1).Count();
result.Should().Be(100);
queryable = new DatabaseQueryable <NumbersModel>(Db);
result = (from x in queryable
select x.Number1).Min();
result.Should().Be(1);
queryable = new DatabaseQueryable <NumbersModel>(Db);
result = (from x in queryable
select x.Number1).Max();
result.Should().Be(100);
queryable = new DatabaseQueryable <NumbersModel>(Db);
result = (from x in queryable
select x.Number1).Sum();
result.Should().Be(5050);
}
public void TestSelectDistinct()
{
var doc1 = new SimpleModel {
Age = 1
};
Db.Save(doc1);
var doc2 = new SimpleModel {
Age = 1
};
Db.Save(doc2);
var queryable = new DatabaseQueryable <SimpleModel>(Db);
var q = (from x in queryable
select x.Age).Distinct();
var numRows = VerifyQuery(q, (n, row) =>
{
var number = row;
number.Should().Be(1);
});
numRows.Should().Be(1, "because there is only one distinct row");
}
public void TestWhereRegex()
{
LoadJSONResource("names_100");
var regex = new Regex("^Mar.*");
var queryable = new DatabaseQueryable <NamesModel>(Db);
var q = from x in queryable
where regex.IsMatch(x.Name.First)
orderby x.Name.First
select x.Name.First;
var firstNames = new List <string>();
var numRows = VerifyQuery(q, (n, row) =>
{
var firstName = row;
if (firstName != null)
{
firstNames.Add(firstName);
}
});
numRows.Should().Be(5, "because there are 5 rows like that in the data source");
firstNames.Should()
.OnlyContain(str => regex.IsMatch(str), "because otherwise an incorrect entry came in");
}
public void TestWhereIs()
{
using (var doc1 = new SimpleModel
{
Name = "string"
}) {
Db.Save(doc1);
}
var queryable = new DatabaseQueryable <SimpleModel>(Db);
var q = from x in queryable
where x.Name == "string"
select x.Id();
var numRows = VerifyQuery(q, (n, row) =>
{
using (var doc = Db.GetDocument(row).ToModel <SimpleModel>()) {
doc.Name.Should().Be("string");
}
});
numRows.Should().Be(1, "beacuse one row matches the given query");
q = from x in queryable
where x.Name != "string1"
select x.Id();
numRows = VerifyQuery(q, (n, row) =>
{
using (var doc = Db.GetDocument(row).ToModel <SimpleModel>()) {
doc.Name.Should().Be("string");
}
});
numRows.Should().Be(1, "because one row matches the 'IS NOT' query");
}
public void TestLimit()
{
LoadModelNumbers(10);
var queryable = new DatabaseQueryable <NumbersModel>(Db);
var q = (from x in queryable
orderby x.Number1
select x.Number1).Take(5);
var expectedNumbers = new[] { 1, 2, 3, 4, 5 };
var numRows = VerifyQuery(q, (n, row) =>
{
row.Should().Be(expectedNumbers[n - 1]);
});
}
public void TestOrderBy()
{
LoadJSONResource("names_100");
foreach (var ascending in new[] { true, false })
{
var queryable = new DatabaseQueryable <NamesModel>(Db);
IQueryable <string> q = null;
if (ascending)
{
q = from x in queryable
orderby x.Name.First
select x.Name.First;
}
else
{
q = from x in queryable
orderby x.Name.First descending
select x.Name.First;
}
var firstNames = new List <object>();
var numRows = VerifyQuery(q, (n, row) =>
{
var firstName = row;
if (firstName != null)
{
firstNames.Add(firstName);
}
});
numRows.Should().Be(100, "because otherwise the wrong number of rows was retrieved");
firstNames.Should().HaveCount(numRows, "because otherwise some rows were null");
var firstNamesCopy = new List <object>(firstNames);
firstNames.Sort();
if (!ascending)
{
firstNames.Reverse();
}
firstNames.Should().ContainInOrder(firstNamesCopy, "because otherwise the results were not sorted");
}
}
public void TestWhereIn()
{
LoadJSONResource("names_100");
var expected = new[] { "Marcy", "Margaretta", "Margrett", "Marlen", "Maryjo" };
var queryable = new DatabaseQueryable <NamesModel>(Db);
var q = from x in queryable
where expected.Contains(x.Name.First)
orderby x.Name.First
select x.Name.First;
var numRows = VerifyQuery(q, (n, row) =>
{
var name = row;
name.Should().Be(expected[n - 1], "because otherwise incorrect rows were returned");
});
numRows.Should().Be(expected.Length, "because otherwise an incorrect number of rows were returned");
}
public void TestMathFunctions()
{
const double num = 0.6;
var model = new DoubleModel
{
Number = num,
Document = new MutableDocument("doc1")
};
Db.Save(model);
var expectedValues = new[] {
Math.Abs(num), Math.Acos(num), Math.Asin(num), Math.Atan(num),
Math.Ceiling(num), Math.Exp(num),
Math.Floor(num), Math.Log(num), Math.Log10(num),
Math.Round(num), Math.Sin(num), Math.Sqrt(num),
Math.Tan(num), Math.Truncate(num)
};
int index = 0;
var queryable = new DatabaseQueryable <DoubleModel>(Db);
var parameter = LinqExpression.Parameter(typeof(DoubleModel), "x");
foreach (var function in new[] {
"Abs", "Acos", "Asin", "Atan",
"Ceiling", "Exp",
"Floor", "Log", "Log10",
"Round", "Sin", "Sqrt",
"Tan", "Truncate"
})
{
var methodCall = LinqExpression.Lambda <Func <DoubleModel, double> >(LinqExpression.Call(typeof(Math).GetMethod(function, new[] { typeof(double) }), LinqExpression.Property(parameter, "Number")), parameter);
var q = queryable.Select(methodCall);
var numRows = VerifyQuery(q, (n, r) =>
{
r.Should().Be(expectedValues[index++]);
});
numRows.Should().Be(1);
}
}
public void TestJoin()
{
LoadModelNumbers(100);
var testModel = new JoinedNumbersModel
{
TheOne = 42,
Document = new MutableDocument("joinme")
};
Db.Save(testModel);
var queryable = new DatabaseQueryable <NumbersModel>(Db);
var secondQueryable = new DatabaseQueryable <JoinedNumbersModel>(Db);
var q = from x in queryable
from y in secondQueryable
join secondary in secondQueryable on x.Number1 equals secondary.TheOne
select x.Number2;
q.Should().HaveCount(1);
q.First().Should().Be(58);
}
private void RunTestWithNumbers(IList <int> expectedResultCount,
IList <Tuple <LinqExpression, Func <NumbersModel, object, bool>, object, ParameterExpression> > validator)
{
int index = 0;
var queryable = new DatabaseQueryable <NumbersModel>(Db);
foreach (var c in validator)
{
var q = queryable.Where(LinqExpression.Lambda <Func <NumbersModel, bool> >(c.Item1, c.Item4)).Select(x => x.Id());
var lastN = 0;
VerifyQuery(q, (n, row) =>
{
var doc = Db.GetDocument(row).ToModel <NumbersModel>();
c.Item2(doc, c.Item3).Should().BeTrue("because otherwise the row failed validation");
lastN = n;
});
lastN.Should()
.Be(expectedResultCount[index++], "because otherwise there was an incorrect number of rows");
}
}
public void TestArrayFunctions()
{
var model = new NamesModel
{
Contact = new Contact
{
Phone = new List <string> {
"650-123-0001", "650-123-0002"
}
},
Document = new MutableDocument("doc1")
};
Db.Save(model);
var queryable = new DatabaseQueryable <NamesModel>(Db);
var q = from x in queryable
select x.Contact.Phone.Count;
var numRows = VerifyQuery(q, (n, r) =>
{
r.Should().Be(2);
});
var q2 = from x in queryable
select new
{
TrueVal = x.Contact.Phone.Contains("650-123-0001"),
FalseVal = x.Contact.Phone.Contains("650-123-0003")
};
numRows = VerifyQuery(q2, (n, r) =>
{
r.TrueVal.Should().BeTrue();
r.FalseVal.Should().BeFalse();
});
numRows.Should().Be(1);
}
public void TestWhereLike()
{
LoadJSONResource("names_100");
var queryable = new DatabaseQueryable <NamesModel>(Db);
var q = from x in queryable
where x.Name.First.Like("%Mar%")
orderby x.Name.First ascending
select x.Name.First;
var firstNames = new List <string>();
var numRows = VerifyQuery(q, (n, row) =>
{
var firstName = row;
if (firstName != null)
{
firstNames.Add(firstName);
}
});
numRows.Should().Be(5, "because there are 5 rows like that in the data source");
firstNames.Should()
.OnlyContain(str => str.Contains("Mar"), "because otherwise an incorrect entry came in");
}
