public void TestAddEmpty()
{
var testWhere = new DSPredicate();
var testPredicate = new DSPredicate();
testWhere.Add(testPredicate);
}
public void TestAddSecondEmpty()
{
var testWhere = new DSPredicate();
var testPredicate = new DSPredicate();
testWhere.Add(PredicateSampleData.PredicateA).Add(testPredicate);
}
public void TestIsValidAsGroup()
{
// TODO - Is there a way to test this without having to use "Add" function? Possibly reflect and set "Predicates" directly?
var groupPredicate = new DSPredicate();
groupPredicate.Add(PredicateSampleData.PredicateA).Add(PredicateSampleData.PredicateB);
Assert.IsTrue(groupPredicate.IsValid, "Group of predicates should be valid.");
}
public void TestSingleGroupPredicate()
{
var testwhere = new DSPredicate();
testwhere.Add(PredicateSampleData.PredicateA).Add(PredicateSampleData.PredicateB);
var sqlBuilder = GetBuilder(testwhere);
Assert.AreEqual("(t.A = 1 AND t.B <> 2)", sqlBuilder.ToString());
}
public void TestSinglePredicate()
{
var testwhere = new DSPredicate();
testwhere.Add(PredicateSampleData.PredicateA);
var sqlBuilder = GetBuilder(testwhere);
Assert.AreEqual("t.A = 1", sqlBuilder.ToString());
}
/// <summary>
/// Build out the supplied filter.
/// </summary>
/// <param name="predicate">Filter to build out.</param>
private void BuildFilter(DSPredicate predicate)
{
if (!predicate.IsValid)
{
return;
}
ProcessPredicate(predicate, predicate.OrGroup, true);
_searchBuilder.WhereBuilder.Complete();
}
public void TestAddSingle()
{
var testWhere = new DSPredicate();
testWhere.Add(PredicateSampleData.PredicateA);
Assert.AreEqual("A", testWhere.Column, "Column data not set properly.");
Assert.AreEqual(DSSearchOperatorEnum.Equals, testWhere.Operator, "Operator data not set properly.");
Assert.AreEqual(1, testWhere.Value, "Value data not set properly.");
Assert.AreEqual(0, testWhere.Predicates.Count, "Should only be single predicate.");
}
/// <summary>
/// Initialize a proper search builder for the supplied filter.
/// </summary>
/// <param name="testWhere">The filter to generate a search builder for.</param>
/// <returns>Search builder for the supplied filter</returns>
private DSSQLFilterBuilder GetBuilder(DSPredicate testWhere)
{
var sqlBuilder = new DSSQLSearchBuilder();
var searchParser = new DSSearchParser(_entityTypeRepository, sqlBuilder);
var search = new DSSearch(TestObjectC.ClassName);
search.Where = testWhere;
searchParser.BuildSearch(search);
return((DSSQLFilterBuilder)sqlBuilder.WhereBuilder);
}
public void TestSingleOrGroupPredicate()
{
var testwhere = new DSPredicate();
var group = new DSPredicate();
group.Add(PredicateSampleData.PredicateB).Add(PredicateSampleData.PredicateC);
testwhere.OrGroup = true;
testwhere.Add(PredicateSampleData.PredicateA).Add(group);
var sqlBuilder = GetBuilder(testwhere);
Assert.AreEqual("(t.A = 1 OR (t.B <> 2 AND t.C = 3))", sqlBuilder.ToString());
}
public void TestSingleAndGroupPredicate()
{
var testWhere = new DSPredicate();
var group = new DSPredicate();
group.Add(PredicateSampleData.PredicateB).Add(PredicateSampleData.PredicateC);
testWhere.Add(PredicateSampleData.PredicateA).Add(group);
Assert.IsTrue(testWhere.IsGroup, "Multile Add calls should create a Group.");
Assert.AreEqual(2, testWhere.Predicates.Count, "Multiple Add calls should have created a list of length 2.");
Assert.IsFalse(testWhere.Predicates[0].IsGroup, "First Item should be single predicate.");
Assert.AreEqual(2, testWhere.Predicates[1].Predicates.Count, "Second Item should be a list of length 2.");
}
public void TestMultipleGroupPredicate()
{
var testwhere = new DSPredicate();
var group1 = new DSPredicate();
group1.Add(PredicateSampleData.PredicateA).Add(PredicateSampleData.PredicateB);
var group2 = new DSPredicate();
group2.Add(PredicateSampleData.PredicateC).Add(PredicateSampleData.PredicateD);
testwhere.OrGroup = true;
testwhere.Add(group1).Add(group2);
var sqlBuilder = GetBuilder(testwhere);
Assert.AreEqual("((t.A = 1 AND t.B <> 2) OR (t.C = 3 AND t.D <> 4))", sqlBuilder.ToString());
}
public void TestAddMultiple()
{
var testWhere = new DSPredicate();
testWhere
.Add(PredicateSampleData.PredicateA)
.Add(PredicateSampleData.PredicateB)
.Add(PredicateSampleData.PredicateC);
Assert.IsTrue(testWhere.IsGroup, "Multile Add calls should create a Group.");
Assert.AreEqual(3, testWhere.Predicates.Count, "Multiple Add calls should have created a list of length 3.");
Assert.AreEqual("A", testWhere[0].Column, "First Predicate Column data not set properly.");
Assert.AreEqual(DSSearchOperatorEnum.Equals, testWhere[0].Operator, "First Predicate Operator data not set properly.");
Assert.AreEqual(1, testWhere[0].Value, "First Predicate Value data not set properly.");
Assert.AreEqual("B", testWhere[1].Column, "Second Predicate Column data not set properly.");
Assert.AreEqual(DSSearchOperatorEnum.DoesNotEqual, testWhere[1].Operator, "Second Predicate Operator data not set properly.");
Assert.AreEqual(2, testWhere[1].Value, "Second Predicate Value data not set properly.");
Assert.AreEqual("C", testWhere[2].Column, "Third Predicate Column data not set properly.");
Assert.AreEqual(DSSearchOperatorEnum.Equals, testWhere[2].Operator, "Third Predicate Operator data not set properly.");
Assert.AreEqual(3, testWhere[2].Value, "Third Predicate Value data not set properly.");
}
/// <summary>
/// Helper function to recursively build out the supplied filter.
/// </summary>
/// <param name="clause">Current filter clause to parse.</param>
/// <param name="orGroup">When true, then currently in an "or" grouping, otherwise in an "and" group.</param>
/// <param name="first">When true, this is the first clause, otherwise it is not.</param>
private void ProcessPredicate(DSPredicate clause, bool orGroup, bool first = false)
{
var filterBuilder = _searchBuilder.WhereBuilder;
if (clause.IsGroup)
{
filterBuilder.StartGroup(orGroup, first);
bool firstInGroup = true;
foreach (var predicate in clause.Predicates)
{
ProcessPredicate(predicate, clause.OrGroup, firstInGroup);
firstInGroup = false;
}
filterBuilder.CloseGroup();
}
else
{
filterBuilder.AppendPredicate(GetQualifiedName(clause.Column), clause.Operator, clause.Value, orGroup, first);
}
}
public void TestIsValidFail()
{
var testPredicate = new DSPredicate();
Assert.IsFalse(testPredicate.IsValid, "Empty predicate is not valid.");
}
