public void Create_StringNotEqual_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("bar_not",
new StringValueNode("a")));
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filterContext = new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
MockFilterConvention.Default.GetExpressionDefinition(),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filterContext);
Func <Foo, bool> func = filterContext.CreateOrAssert <Foo>().Compile();
// assert
var a = new Foo {
Bar = "a"
};
Assert.False(func(a));
var b = new Foo {
Bar = "b"
};
Assert.True(func(b));
}
public void Create_ArrayAllStringEqual_Expression_Null()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("bar_all",
NullValueNode.Default));
FooSimpleFilterType fooType = CreateType(new FooSimpleFilterType());
// act
var filter = new QueryableFilterVisitorContext(
fooType,
typeof(FooSimple),
MockFilterConvention.Default.GetExpressionDefinition(),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filter);
Func <FooSimple, bool> func = filter.CreateOrAssert <FooSimple>().Compile();
// assert
var a = new FooSimple {
Bar = new string[] { null, null, null }
};
Assert.True(func(a));
var b = new FooSimple {
Bar = new[] { "c", "d", "b" }
};
Assert.False(func(b));
}
public void AssertOperation <T>(
ObjectValueNode value,
FilterKind kind,
FilterOperationKind operationKind,
FilterOperationHandler handler)
{
FilterInputType <T> fooType = CreateType(new FilterInputType <T>());
var helper = ExpressionVisitorMock.Create(handler);
FilterExpressionVisitorDefinition convention =
new MockFilterConvention(
x => x.UseDefault()
.UseExpressionVisitor()
.UseDefault()
.Kind(kind)
.Operation(operationKind)
.Handler(helper.FilterOperationHandler))
.GetExpressionDefinition();
// act
var filter = new QueryableFilterVisitorContext(
fooType,
typeof(T),
convention,
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filter);
Func <T, bool> func = filter.CreateOrAssert <T>().Compile();
// assert
Assert.Equal(1, helper.CallCount(handler));
}
public void Create_ShortNotIn_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("barShort_not_in",
new ListValueNode(new[] { new IntValueNode(13), new IntValueNode(14) }
))
);
FooFilterType fooType = CreateType(new FooFilterType());
// act
var context = new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
MockFilterConvention.Default.GetExpressionDefinition(),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, context);
Func <Foo, bool> func = context.CreateOrAssert <Foo>().Compile();
// assert
var a = new Foo {
BarShort = 12
};
Assert.True(func(a));
var b = new Foo {
BarShort = 13
};
Assert.False(func(b));
}
public void Create_ObjectStringEqualNull_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("foo",
new ObjectValueNode(
new ObjectFieldNode("fooNested",
new ObjectValueNode(
new ObjectFieldNode("bar",
new StringValueNode("a")))))));
EvenDeeperFilterType fooType = CreateType(new EvenDeeperFilterType());
// act
var filterContext = new QueryableFilterVisitorContext(
fooType,
typeof(EvenDeeper),
MockFilterConvention.Default.GetExpressionDefinition(),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filterContext);
Func <EvenDeeper, bool> func = filterContext.CreateOrAssert <EvenDeeper>().Compile();
// assert
var a = new EvenDeeper {
Foo = null
};
Assert.False(func(a));
var b = new EvenDeeper {
Foo = new Foo {
FooNested = null
}
};
Assert.False(func(b));
var c = new EvenDeeper {
Foo = new Foo {
FooNested = new FooNested {
Bar = null
}
}
};
Assert.False(func(c));
var d = new EvenDeeper {
Foo = new Foo {
FooNested = new FooNested {
Bar = "a"
}
}
};
Assert.True(func(d));
}
public void Create_ArrayAnyObjectStringEqual_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("fooNested_any",
new BooleanValueNode(true)
)
);
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filter = new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
MockFilterConvention.Default.GetExpressionDefinition(),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filter);
Func <Foo, bool> func = filter.CreateOrAssert <Foo>().Compile();
// assert
var a = new Foo
{
FooNested = new[]
{
new FooNested {
Bar = "c"
},
new FooNested {
Bar = "d"
},
new FooNested {
Bar = "a"
}
}
};
Assert.True(func(a));
var b = new Foo {
FooNested = new FooNested[] { }
};
Assert.False(func(b));
var c = new Foo {
FooNested = null
};
Assert.False(func(c));
var d = new Foo {
FooNested = new FooNested[] { null }
};
Assert.True(func(d));
}
public void Create_ArraySomeStringEqualWithNull_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("bar_some",
new ObjectValueNode(
new ObjectFieldNode("element",
new StringValueNode("a")
)
)
)
);
FooSimpleFilterType fooType = CreateType(new FooSimpleFilterType());
// act
var filter = new QueryableFilterVisitorContext(
fooType,
typeof(FooSimple),
MockFilterConvention.Default.GetExpressionDefinition(),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filter);
Func <FooSimple, bool> func = filter.CreateOrAssert <FooSimple>().Compile();
// assert
var a = new FooSimple {
Bar = new[] { "c", null, "a" }
};
Assert.True(func(a));
var b = new FooSimple {
Bar = new[] { "c", null, "b" }
};
Assert.False(func(b));
var c = new FooSimple {
Bar = null
};
Assert.False(func(c));
}
public void Create_NullableShortNotLowerThanOrEquals_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("barShort_not_lte",
new IntValueNode(12)));
FooNullableFilterType fooNullableType = CreateType(new FooNullableFilterType());
// act
var context = new QueryableFilterVisitorContext(
fooNullableType,
typeof(FooNullable),
MockFilterConvention.Default.GetExpressionDefinition(),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, context);
Func <FooNullable, bool> func = context.CreateOrAssert <FooNullable>().Compile();
// assert
var a = new FooNullable {
BarShort = 11
};
Assert.False(func(a));
var b = new FooNullable {
BarShort = 12
};
Assert.False(func(b));
var c = new FooNullable {
BarShort = 13
};
Assert.True(func(c));
var d = new FooNullable {
BarShort = null
};
Assert.True(func(d));
}
public void Create_ObjectStringEqualRecursive_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("nested",
new ObjectValueNode(
new ObjectFieldNode("nested",
new ObjectValueNode(
new ObjectFieldNode("bar",
new StringValueNode("a")))))));
FilterInputType <Recursive> fooType = CreateType(new FilterInputType <Recursive>());
// act
var filterContext = new QueryableFilterVisitorContext(
fooType,
typeof(Recursive),
MockFilterConvention.Default.GetExpressionDefinition(),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filterContext);
Func <Recursive, bool> func = filterContext.CreateOrAssert <Recursive>().Compile();
var a = new Recursive {
Nested = new Recursive {
Nested = new Recursive {
Bar = "a"
}
}
};
Assert.True(func(a));
var b = new Recursive {
Nested = new Recursive {
Nested = new Recursive {
Bar = "b"
}
}
};
Assert.False(func(b));
}
public void Create_ShortLowerThan_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("barShort_lt",
new IntValueNode(12)));
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filter = new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
MockFilterConvention.Default.GetExpressionDefinition(),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filter);
Func <Foo, bool> func = filter.CreateOrAssert <Foo>().Compile();
// assert
var a = new Foo {
BarShort = 11
};
Assert.True(func(a));
var b = new Foo {
BarShort = 12
};
Assert.False(func(b));
var c = new Foo {
BarShort = 13
};
Assert.False(func(c));
}
public void Create_NullableBooleanEqual_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("bar",
new BooleanValueNode(true)));
FooNullableFilterType fooNullableType = CreateType(new FooNullableFilterType());
// act
var filter = new QueryableFilterVisitorContext(
fooNullableType,
typeof(FooNullable),
MockFilterConvention.Default.GetExpressionDefinition(),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filter);
Func <FooNullable, bool> func = filter.CreateOrAssert <FooNullable>().Compile();
// assert
var a = new FooNullable {
Bar = true
};
Assert.True(func(a));
var b = new FooNullable {
Bar = false
};
Assert.False(func(b));
var c = new FooNullable {
Bar = null
};
Assert.False(func(c));
}
public void AssertEnterAndLeave <T>(
ObjectValueNode value,
FilterKind kind,
FilterFieldEnter enter,
FilterFieldLeave leave)
{
FilterInputType <T> fooType = CreateType(new FilterInputType <T>());
ExpressionVisitorMock helper =
ExpressionVisitorMock.Create(enter)
.Setup(leave);
FilterExpressionVisitorDefinition convention =
new MockFilterConvention(
x => x.UseDefault()
.UseExpressionVisitor()
.UseDefault()
.Kind(kind)
.Enter(helper.FilterFieldEnter)
.Leave(helper.FilterFieldLeave))
.GetExpressionDefinition();
// act
var filter = new QueryableFilterVisitorContext(
fooType,
typeof(T),
convention,
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filter);
Func <T, bool> func = filter.CreateOrAssert <T>().Compile();
// assert
Assert.Equal(1, helper.CallCount(enter));
Assert.Equal(1, helper.CallCount(leave));
}