public void CanHanldeEnums()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "D",
StringValue = "3",
Operator = "eq"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (par.D == C))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Skip(2)));
}
public void CanHanldeNullables()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "C",
StringValue = "3",
Operator = "gt"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => IIF(par.C.HasValue, (par.C.Value > 3), False))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Skip(2)));
}
public void EndsWithTest()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "B",
StringValue = "'A'",
Operator = "endswith"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => IIF((par.B != null), par.B.EndsWith(\"A\"), False))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Take(1)));
}
public void DoesNotContainTest()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "B",
StringValue = "'C'",
Operator = "doesnotcontain"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => IIF((par.B != null), Not(par.B.Contains(\"C\")), False))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Take(1)));
}
public void NotInTest()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "[1,5]",
Operator = "notin"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => Not(value(System.Int32[]).Contains(par.A)))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Skip(1).Take(1)));
}
public void LteTest()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "3",
Operator = "lte"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (par.A <= 3))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Take(2)));
}
public void SingleFitlerWorks()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "4",
Operator = "gt"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (par.A > 4))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(1));
Assert.That(query.Single().A, Is.EqualTo(5));
}
public void NotInTestNullableEnum()
{
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "E",
StringValue = "[1,3]",
Operator = "notin"
});
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation =
"Linq.GridQuery.Test.TestSubject[].Where(par => IIF(par.E.HasValue, Not(value(Linq.GridQuery.Test.TestEnum[]).Contains(par.E.Value)), False))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(result, Is.EquivalentTo(Collection.Skip(1).Take(1)));
}
public void AdditionalOperatorToExpressionConvertersProvidedOnPerInstanceBasisOverrideBaseOnesOfTheSameName()
{
var marker1 = "MARKER1";
var marker2 = "MARKER2";
var wasCalled = false;
Type typePassed = null;
Config.DefaultOperatorToExpressionConverters.Add(marker2, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
throw new Exception("This should never be called.");
}));
var additionalOperatorToExpressionConverters =
new Dictionary <string, OperatorHandler>()
{
{ marker2, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
wasCalled = true;
typePassed = propTypeUnwrapped;
return(Expression.Equal(Expression.Constant(marker1), Expression.Constant(marker1)));
}) }
};
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "0",
Operator = marker2
},
operatorToExpressionConvertersOverrides: additionalOperatorToExpressionConverters);
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (\"MARKER1\" == \"MARKER1\"))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(wasCalled, Is.EqualTo(true));
Assert.That(typePassed, Is.EqualTo(typeof(Int32)));
Assert.That(result, Is.EquivalentTo(Collection));
}
public void ValueDeserializationFunctionOverrideCanBeSet()
{
var marker1 = "MARKER1";
string valCapture = null;
Type typeCapture = null;
Config.DefaultValueDeserialiationFunction = (val, type) =>
{
throw new InvalidOperationException("This should not be called.");
};
Func <string, Type, object> actuallyUsedFunc = (val, type) =>
{
valCapture = val;
typeCapture = type;
return(5);
};
var filter = new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = marker1,
Operator = "eq"
},
actuallyUsedFunc);
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (par.A == 5))";
Assert.That(filter.ValueDeserializationFunctionOverride, Is.EqualTo(actuallyUsedFunc));
Assert.That(valCapture, Is.EqualTo(marker1));
Assert.That(typeCapture, Is.EqualTo(typeof(int)));
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(1));
Assert.That(query.Single().A, Is.EqualTo(5));
}
public void ThreeBranchesQueryWorks()
{
var filter = new FilterTreeNode(
new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "2",
Operator = "gt"
}),
LogicalOpertor.AND,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "4",
Operator = "lt"
})
),
LogicalOpertor.OR,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "5",
Operator = "eq"
}));
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (((par.A > 2) And (par.A < 4)) Or (par.A == 5)))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(2));
Assert.That(query.ElementAt(0).A, Is.EqualTo(3));
Assert.That(query.ElementAt(1).A, Is.EqualTo(5));
}
public void AdditionalOperatorToExpressionConvertersCanBeSetForRootOfTreeAndFunctionOfEachBranchFlowsDowntreeForNodesWithoutTheirOwn()
{
var marker2 = "MARKER2";
var marker3 = "MARKER3";
Type typePassed = null;
var additionalOperatorToExpressionConverters1 =
new Dictionary <string, OperatorHandler>()
{
{ marker3, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
typePassed = propTypeUnwrapped;
return(Expression.Equal(Expression.Constant(marker3), Expression.Constant(marker3)));
}) },
{
marker2, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
throw new Exception("This should never be called.");
})
}
};
var additionalOperatorToExpressionConverters2 =
new Dictionary <string, OperatorHandler>()
{
{ marker2, new OperatorHandler((propTypeUnwrapped, propTypeRaw, left, right) =>
{
typePassed = propTypeUnwrapped;
return(Expression.Equal(Expression.Constant(marker2), Expression.Constant(marker2)));
}) }
};
var branchWithOwnFunction = new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "1",
Operator = "eq"
}),
LogicalOpertor.OR,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "0",
Operator = marker2
}),
operatorToExpressionConvertersOverrides: additionalOperatorToExpressionConverters2);
var branchWithoutOwnFunction = new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "2",
Operator = "eq"
}),
LogicalOpertor.OR,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "0",
Operator = marker3
}));
var filter = new FilterTreeNode(
branchWithOwnFunction,
LogicalOpertor.OR,
branchWithoutOwnFunction,
operatorToExpressionConvertersOverrides: additionalOperatorToExpressionConverters1);
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (((par.A == 1) Or (\"MARKER2\" == \"MARKER2\")) Or ((par.A == 2) Or (\"MARKER3\" == \"MARKER3\"))))";
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(3));
Assert.That(query.ElementAt(0).A, Is.EqualTo(1));
Assert.That(query.ElementAt(1).A, Is.EqualTo(3));
Assert.That(query.ElementAt(2).A, Is.EqualTo(5));
}
public void ValueDeserializationFunctionCanBeSetForRootOfTreeAndFunctionOfEachBranchFlowsDowntreeForNodesWithoutTheirOwn()
{
var marker1 = "MARKER1";
var marker2 = "MARKER2";
var valCapture = new List <string>();
var typeCapture = new List <Type>();
Config.DefaultValueDeserialiationFunction = (val, type) =>
{
throw new InvalidOperationException("This should not be called.");
};
Func <string, Type, object> deserializationFunc1 = (val, type) =>
{
valCapture.Add(val);
typeCapture.Add(type);
return(val == marker1 ? 3 :
val == marker2 ? 5 :
0);
};
Func <string, Type, object> deserializationFunc2 = (val, type) =>
{
return(JsonConvert.DeserializeObject(val, type));
};
var branchWithOwnFunction = new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = marker1,
Operator = "eq"
}),
LogicalOpertor.OR,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = marker2,
Operator = "eq"
}),
deserializationFunc1);
var branchWithoutOwnFunction = new FilterTreeNode(
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "2",
Operator = "eq"
}),
LogicalOpertor.OR,
new FilterTreeNode(
new GridFilter()
{
PropName = "A",
StringValue = "4",
Operator = "eq"
}));
var filter = new FilterTreeNode(
branchWithOwnFunction,
LogicalOpertor.OR,
branchWithoutOwnFunction,
deserializationFunc2);
var query = filter.WrapFilter(Collection);
var result = query.ToArray();
var expectation = "Linq.GridQuery.Test.TestSubject[].Where(par => (((par.A == 3) Or (par.A == 5)) Or ((par.A == 2) Or (par.A == 4))))";
Assert.That(filter.ValueDeserializationFunctionOverride, Is.EqualTo(deserializationFunc2));
Assert.That(valCapture, Is.EquivalentTo(new[] { marker1, marker2 }));
Assert.That(typeCapture, Is.EquivalentTo(new[] { typeof(int), typeof(int) }));
Assert.That(query.ToString(), Is.EqualTo(expectation));
Assert.That(query.Count, Is.EqualTo(2));
Assert.That(query.ElementAt(0).A, Is.EqualTo(3));
Assert.That(query.ElementAt(1).A, Is.EqualTo(5));
}
