public QueryableFilterVisitor( InputObjectType initialType, Type source, ITypeConversion converter, IEnumerable <IExpressionOperationHandler> operationHandlers, IEnumerable <IExpressionFieldHandler> fieldHandlers, bool inMemory) : base(initialType) { if (initialType is null) { throw new ArgumentNullException(nameof(initialType)); } if (source is null) { throw new ArgumentNullException(nameof(source)); } if (operationHandlers is null) { throw new ArgumentNullException(nameof(operationHandlers)); } if (converter is null) { throw new ArgumentNullException(nameof(converter)); } _context = new QueryableFilterVisitorContext( operationHandlers.ToArray(), fieldHandlers.ToArray(), converter, new QueryableClosure(source, "r", inMemory), inMemory); }
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_StringNotEndsWith_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("bar_not_ends_with", new StringValueNode("a"))); FooFilterType fooType = CreateType(new FooFilterType()); // act var filterContext = new QueryableFilterVisitorContext( fooType, typeof(Foo), DefaultTypeConverter.Default, true); QueryableFilterVisitor.Default.Visit(value, filterContext); Func <Foo, bool> func = filterContext.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 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_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); 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 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_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 async Task InvokeAsync(IMiddlewareContext context) { await _next(context).ConfigureAwait(false); IValueNode filter = context.ArgumentLiteral <IValueNode>(_contextData.ArgumentName); if (filter is NullValueNode) { return; } IQueryable <T>?source = null; if (context.Result is IQueryable <T> q) { source = q; } else if (context.Result is IEnumerable <T> e) { source = e.AsQueryable(); } if (source is not null && context.Field.Arguments[_contextData.ArgumentName].Type is InputObjectType iot && iot is IFilterInputType fit) { var visitorContext = new QueryableFilterVisitorContext( iot, fit.EntityType, _converter, source is EnumerableQuery); QueryableFilterVisitor.Default.Visit(filter, visitorContext); source = source.Where(visitorContext.CreateFilter <T>()); context.Result = source; } }
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_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); 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 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), DefaultTypeConverter.Default, true); QueryableFilterVisitor.Default.Visit(value, filterContext); Func <Recursive, bool> func = filterContext.CreateFilter <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_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_NullableShortNotIn_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode( "barShort_not_in", new ListValueNode( new[] { new IntValueNode(13), new IntValueNode(14) } )) ); FooNullableFilterType fooNullableType = CreateType(new FooNullableFilterType()); // act var context = new QueryableFilterVisitorContext( fooNullableType, typeof(FooNullable), DefaultTypeConverter.Default, true); QueryableFilterVisitor.Default.Visit(value, context); Func <FooNullable, bool> func = context.CreateFilter <FooNullable>().Compile(); // assert var a = new FooNullable { BarShort = 12 }; Assert.True(func(a)); var b = new FooNullable { BarShort = 13 }; Assert.False(func(b)); var c = new FooNullable { BarShort = null }; Assert.True(func(c)); }
public void Create_ArrayAnyStringEqual_Expression() { // arrange var value = new ObjectValueNode( new ObjectFieldNode("bar_any", new BooleanValueNode(true) ) ); FooSimpleFilterType fooType = CreateType(new FooSimpleFilterType()); // act var filter = new QueryableFilterVisitorContext( fooType, typeof(FooSimple), DefaultTypeConverter.Default, true); QueryableFilterVisitor.Default.Visit(value, filter); Func <FooSimple, bool> func = filter.CreateFilter <FooSimple>().Compile(); // assert var a = new FooSimple { Bar = new[] { "c", "d", "a" } }; Assert.True(func(a)); var b = new FooSimple { Bar = new string[0] }; Assert.False(func(b)); var c = new FooSimple { Bar = null }; 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)); }