public void Create_ShortGreaterThan_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("barShort_gt",
new IntValueNode(12)));
FooFilterType fooType = CreateType(new FooFilterType());
// act
var context = new QueryableFilterVisitorContext(
fooType, typeof(Foo), TypeConversion.Default, true);
QueryableFilterVisitor.Default.Visit(value, context);
Func <Foo, bool> func = context.CreateFilter <Foo>().Compile();
// assert
var a = new Foo {
BarShort = 11
};
Assert.False(func(a));
var b = new Foo {
BarShort = 12
};
Assert.False(func(b));
var c = new Foo {
BarShort = 13
};
Assert.True(func(c));
}
public void Create_StringNotStartsWith_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("bar_not_starts_with",
new StringValueNode("a")));
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filterContext = new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
DefaultTypeConverter.Default,
true,
new(new DefaultTypeConverter()));
QueryableFilterVisitor.Default.Visit(value, filterContext);
Func <Foo, bool> func = filterContext.CreateFilter <Foo>().Compile();
// assert
var a = new Foo {
Bar = "ab"
};
Assert.False(func(a));
var b = new Foo {
Bar = "ba"
};
Assert.True(func(b));
}
public void Create_StringIn_SingleValue_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("bar_in",
new StringValueNode("a")));
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filter = new QueryableFilterVisitor(
fooType,
typeof(Foo),
TypeConversion.Default,
true);
value.Accept(filter);
Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile();
// assert
var a = new Foo {
Bar = "a"
};
Assert.True(func(a));
var b = new Foo {
Bar = "b"
};
Assert.False(func(b));
}
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_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 FilterConvention_Should_Fail_When_OperationsIsNotNamed()
{
// arrange
var provider = new QueryableFilterProvider(
descriptor =>
{
descriptor.AddFieldHandler <QueryableStringEqualsHandler>();
descriptor.AddFieldHandler <QueryableDefaultFieldHandler>();
});
var convention = new FilterConvention(
descriptor =>
{
descriptor.Operation(DefaultOperations.Equals).Description("eq");
descriptor.BindRuntimeType <string, TestOperationFilterType>();
descriptor.Provider(provider);
});
var type = new FooFilterType();
//act
ArgumentException error =
Assert.Throws <ArgumentException>(() => CreateSchemaWith(type, convention));
#if NETCOREAPP2_1
error.Message.MatchSnapshot(new SnapshotNameExtension("NETCOREAPP2_1"));
#else
error.Message.MatchSnapshot();
#endif
}
public void Create_BooleanNotEqual_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode(
"bar",
new BooleanValueNode(false)));
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filter = new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
DefaultTypeConverter.Default,
true,
new(new DefaultTypeConverter()));
QueryableFilterVisitor.Default.Visit(value, filter);
Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile();
// assert
var a = new Foo {
Bar = false
};
Assert.True(func(a));
var b = new Foo {
Bar = true
};
Assert.False(func(b));
}
public void FilterConvention_Should_Fail_When_NoMatchingBindingWasFound()
{
// arrange
var provider = new QueryableFilterProvider(
descriptor =>
{
descriptor.AddFieldHandler <QueryableStringEqualsHandler>();
descriptor.AddFieldHandler <QueryableDefaultFieldHandler>();
});
var convention = new FilterConvention(
descriptor =>
{
descriptor.Operation(DefaultOperations.Equals).Name("eq");
descriptor.Provider(provider);
});
var type = new FooFilterType();
//act
SchemaException?error =
Assert.Throws <SchemaException>(() => CreateSchemaWith(type, convention));
Assert.Single(error.Errors);
#if NETCOREAPP2_1
error.Errors[0].Message.MatchSnapshot(new SnapshotNameExtension("NETCOREAPP2_1"));
#else
error.Errors[0].Message.MatchSnapshot();
#endif
}
public void Create_StringContains_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("bar_contains",
new StringValueNode("a")));
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filterContext = new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filterContext);
Func <Foo, bool> func = filterContext.CreateFilter <Foo>().Compile();
// assert
var a = new Foo {
Bar = "testatest"
};
Assert.True(func(a));
var b = new Foo {
Bar = "testbtest"
};
Assert.False(func(b));
}
public void Create_StringNotEndsWith_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("bar_not_ends_with",
new StringValueNode("a")));
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filter = new QueryableFilterVisitor(
fooType,
typeof(Foo),
TypeConversion.Default,
true);
filter.Visit(value, null);
Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile();
// assert
var a = new Foo {
Bar = "ab"
};
Assert.True(func(a));
var b = new Foo {
Bar = "ba"
};
Assert.False(func(b));
}
public void FilterConvention_Should_Fail_When_FieldHandlerIsNotRegistered()
{
// arrange
var provider = new QueryableFilterProvider(
descriptor =>
{
descriptor.AddFieldHandler <QueryableStringEqualsHandler>();
});
var convention = new FilterConvention(
descriptor =>
{
descriptor.Operation(DefaultOperations.Equals).Name("eq");
descriptor.BindRuntimeType <string, TestOperationFilterType>();
descriptor.Provider(provider);
});
var type = new FooFilterType();
//act
SchemaException?error =
Assert.Throws <SchemaException>(() => CreateSchemaWith(type, convention));
Assert.Single(error.Errors);
error.Errors[0].Message.MatchSnapshot();
}
public void Create_ArraySomeObjectStringEqualWithNull_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("fooNested_some",
new ObjectValueNode(
new ObjectFieldNode("bar",
new StringValueNode("a")
)
)
)
);
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filter = new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
DefaultTypeConverter.Default,
true,
new(new DefaultTypeConverter()));
QueryableFilterVisitor.Default.Visit(value, filter);
Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile();
// assert
var a = new Foo
{
FooNested = new[]
{
new FooNested {
Bar = "c"
},
null,
new FooNested {
Bar = "a"
}
}
};
Assert.True(func(a));
var b = new Foo
{
FooNested = new[]
{
new FooNested {
Bar = "c"
},
null,
new FooNested {
Bar = "b"
}
}
};
Assert.False(func(b));
}
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 FilterConvention_Should_Work_With_Extensions()
{
// arrange
var provider = new QueryableFilterProvider(
descriptor =>
{
descriptor.AddFieldHandler <QueryableStringEqualsHandler>();
descriptor.AddFieldHandler <QueryableDefaultFieldHandler>();
});
var convention = new FilterConvention(
descriptor =>
{
});
var extension1 = new FilterConventionExtension(
descriptor =>
{
descriptor.BindRuntimeType <string, TestOperationFilterType>();
descriptor.Provider(provider);
});
var extension2 = new FilterConventionExtension(
descriptor =>
{
descriptor.Operation(DefaultOperations.Equals).Name("eq");
});
IValueNode value = Utf8GraphQLParser.Syntax.ParseValueLiteral("{ bar: { eq:\"a\" }}");
var type = new FooFilterType();
//act
CreateSchemaWith(type, convention, extension1, extension2);
var executor = new ExecutorBuilder(type);
Func <Foo, bool> func = executor.Build <Foo>(value);
// assert
var a = new Foo {
Bar = "a"
};
Assert.True(func(a));
var b = new Foo {
Bar = "b"
};
Assert.False(func(b));
}
public void Create_Should_Throw_IfTypeIsNull()
{
// arrange
FooFilterType fooType = CreateType(new FooFilterType());
Action action = () =>
{
new QueryableFilterVisitorContext(
fooType, null, TypeConversion.Default, true);
};
// act
// assert
Assert.Throws <ArgumentNullException>(action);
}
public void Create_Should_Throw_IfOperationHandlersIsNull()
{
// arrange
FooFilterType fooType = CreateType(new FooFilterType());
Action action = () =>
{
new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
null !,
ExpressionFieldHandlers.All,
DefaultTypeConverter.Default,
true,
new(new DefaultTypeConverter()));
};
public void Create_Should_Throw_IfTypeConversionIsNull()
{
// arrange
FooFilterType fooType = CreateType(new FooFilterType());
Action action = () =>
{
new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
MockFilterConvention.Default.GetExpressionDefinition(),
null,
true);
};
// act
// assert
Assert.Throws <ArgumentNullException>(action);
}
public void Create_Should_Throw_IfFieldHandlersIsNull()
{
// arrange
FooFilterType fooType = CreateType(new FooFilterType());
Action action = () =>
{
new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
ExpressionOperationHandlers.All,
null,
DefaultTypeConverter.Default,
true);
};
// act
// assert
Assert.Throws <ArgumentNullException>(action);
}
public void Create_ShortNotGreaterThanOrEquals_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("barShort_not_gte",
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_ObjectStringEqualWithNull_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("fooNested",
new ObjectValueNode(
new ObjectFieldNode("bar",
new StringValueNode("a")
)
)
)
);
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filterContext = new QueryableFilterVisitorContext(
fooType,
typeof(Foo),
TypeConversion.Default,
true);
QueryableFilterVisitor.Default.Visit(value, filterContext);
Func <Foo, bool> func = filterContext.CreateFilter <Foo>().Compile();
// assert
var a = new Foo {
FooNested = new FooNested {
Bar = "a"
}
};
Assert.True(func(a));
Foo b = null;
Assert.False(func(b));
}
public void Create_ArrayAllObjectStringEqual_Expression()
{
// arrange
var value = new ObjectValueNode(
new ObjectFieldNode("fooNested_all",
new ObjectValueNode(
new ObjectFieldNode("bar",
new StringValueNode("a")
)
)
)
);
FooFilterType fooType = CreateType(new FooFilterType());
// act
var filter = new QueryableFilterVisitor(
fooType,
typeof(Foo),
TypeConversion.Default,
true);
filter.Visit(value, null);
Func <Foo, bool> func = filter.CreateFilter <Foo>().Compile();
// assert
var a = new Foo
{
FooNested = new[]
{
new FooNested {
Bar = "a"
},
new FooNested {
Bar = "a"
},
new FooNested {
Bar = "a"
}
}
};
Assert.True(func(a));
var b = new Foo
{
FooNested = new[]
{
new FooNested {
Bar = "c"
},
new FooNested {
Bar = "a"
},
new FooNested {
Bar = "a"
}
}
};
Assert.False(func(b));
var c = new Foo
{
FooNested = new[]
{
new FooNested {
Bar = "a"
},
new FooNested {
Bar = "d"
},
new FooNested {
Bar = "b"
}
}
};
Assert.False(func(c));
var d = new Foo
{
FooNested = new[]
{
new FooNested {
Bar = "c"
},
new FooNested {
Bar = "d"
},
new FooNested {
Bar = "b"
}
}
};
Assert.False(func(d));
var e = new Foo
{
FooNested = new[]
{
null,
new FooNested {
Bar = null
},
new FooNested {
Bar = "d"
},
new FooNested {
Bar = "b"
}
}
};
Assert.False(func(e));
}
