Пример #1
0
        public void ApplyTo_ReturnsCorrectQueryable_PropertyAlias(string filter, int[] propertyAliasIds)
        {
            // Arrange
            var model   = GetPropertyAliasModel();
            var context = new ODataQueryContext(model, typeof(PropertyAlias))
            {
                RequestContainer = new MockContainer(model)
            };
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable <PropertyAlias> propertyAliases = PropertyAliasTestData;

            // Act
            IQueryable queryable = filterOption.ApplyTo(
                propertyAliases.AsQueryable(),
                new ODataQuerySettings {
                HandleNullPropagation = HandleNullPropagationOption.True
            });

            // Assert
            Assert.NotNull(queryable);
            IEnumerable <PropertyAlias> actualPropertyAliases = Assert.IsAssignableFrom <IEnumerable <PropertyAlias> >(queryable);

            Assert.Equal(
                propertyAliasIds,
                actualPropertyAliases.Select(propertyAlias => propertyAlias.Id));
        }
Пример #2
0
        public void ApplyTo_Returns_Correct_Queryable(string filter, int[] customerIds)
        {
            // Arrange
            var model = new ODataModelBuilder()
                        .Add_Order_EntityType()
                        .Add_Customer_EntityType_With_Address()
                        .Add_CustomerOrders_Relationship()
                        .Add_Customer_EntityType_With_CollectionProperties()
                        .Add_Customers_EntitySet()
                        .GetEdmModel();
            var context      = new ODataQueryContext(model, typeof(Customer));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable <Customer> customers = CustomerFilterTestData;

            // Act
            IQueryable queryable = filterOption.ApplyTo(customers.AsQueryable(), new ODataQuerySettings {
                HandleNullPropagation = HandleNullPropagationOption.True
            });

            // Assert
            Assert.NotNull(queryable);
            IEnumerable <Customer> actualCustomers = Assert.IsAssignableFrom <IEnumerable <Customer> >(queryable);

            Assert.Equal(
                customerIds,
                actualCustomers.Select(customer => customer.CustomerId));
        }
Пример #3
0
        public void ApplyToEnums_ReturnsCorrectQueryabl_IfEnableConstantParameterizationSetFalse(string filter, int[] enumModelIds)
        {
            // Arrange
            var model   = GetEnumModel();
            var context = new ODataQueryContext(model, typeof(EnumModel))
            {
                RequestContainer = new MockContainer(model)
            };
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable <EnumModel> enumModels = EnumModelTestData;

            // Act
            IQueryable queryable = filterOption.ApplyTo(enumModels.AsQueryable(),
                                                        new ODataQuerySettings
            {
                HandleNullPropagation          = HandleNullPropagationOption.True,
                EnableConstantParameterization = false
            });

            // Assert
            Assert.NotNull(queryable);
            IEnumerable <EnumModel> actualCustomers = Assert.IsAssignableFrom <IEnumerable <EnumModel> >(queryable);

            Assert.Equal(
                enumModelIds,
                actualCustomers.Select(enumModel => enumModel.Id));
        }
Пример #4
0
        public void ApplyWithParameterAlias_ReturnsCorrectQueryable(string filter, string parameterAliasValue, int[] parameterAliasModelIds)
        {
            // Arrange
            var                  model                  = GetParameterAliasModel();
            var                  context                = new ODataQueryContext(model, typeof(DataTypes));
            IEdmType             targetEdmType          = model.FindType("System.Web.OData.Query.Expressions.DataTypes");
            IEdmNavigationSource targetNavigationSource = model.FindDeclaredEntitySet("System.Web.OData.Query.Expressions.Products");

            ODataQueryOptionParser parser = new ODataQueryOptionParser(
                model,
                targetEdmType,
                targetNavigationSource,
                new Dictionary <string, string> {
                { "$filter", filter }, { "@p", parameterAliasValue }
            });

            var filterOption = new FilterQueryOption(filter, context, parser);
            IEnumerable <DataTypes> parameterAliasModels = ParameterAliasTestData;

            // Act
            IQueryable queryable = filterOption.ApplyTo(parameterAliasModels.AsQueryable(), new ODataQuerySettings {
                HandleNullPropagation = HandleNullPropagationOption.True
            });

            // Assert
            Assert.NotNull(queryable);
            IEnumerable <DataTypes> actualResult = Assert.IsAssignableFrom <IEnumerable <DataTypes> >(queryable);

            Assert.Equal(
                parameterAliasModelIds,
                actualResult.Select(result => result.IntProp));
        }
Пример #5
0
        public void ApplyTo_Throws_Null_AssembliesResolver()
        {
            // Arrange
            var model   = new ODataModelBuilder().Add_Customer_EntityType_With_CollectionProperties().Add_Customers_EntitySet().Add_Address_ComplexType().GetEdmModel();
            var context = new ODataQueryContext(model, typeof(Customer));
            var filter  = new FilterQueryOption("Addresses/any(a: a/HouseNumber eq 1)", context);

            // Act & Assert
            Assert.ThrowsArgumentNull(() => filter.ApplyTo(new Customer[0].AsQueryable(), new ODataQuerySettings(), null), "assembliesResolver");
        }
Пример #6
0
        public void ApplyTo_WithUnTypedContext_Throws_InvalidOperation()
        {
            CustomersModelWithInheritance model   = new CustomersModelWithInheritance();
            ODataQueryContext             context = new ODataQueryContext(model.Model, model.Customer);
            FilterQueryOption             filter  = new FilterQueryOption("Id eq 42", context);
            IQueryable queryable = new Mock <IQueryable>().Object;

            Assert.Throws <NotSupportedException>(() => filter.ApplyTo(queryable, new ODataQuerySettings()),
                                                  "The query option is not bound to any CLR type. 'ApplyTo' is only supported with a query option bound to a CLR type.");
        }
Пример #7
0
        public void ApplyTo_Throws_Null_Query()
        {
            // Arrange
            var model   = new ODataModelBuilder().Add_Customer_EntityType_With_CollectionProperties().Add_Customers_EntitySet().Add_Address_ComplexType().GetEdmModel();
            var context = new ODataQueryContext(model, typeof(Customer))
            {
                RequestContainer = new MockContainer()
            };
            var filter = new FilterQueryOption("Addresses/any(a: a/HouseNumber eq 1)", context);

            // Act & Assert
            Assert.ThrowsArgumentNull(() => filter.ApplyTo(null, new ODataQuerySettings()), "query");
        }
Пример #8
0
        public void ApplyToEnums_ThrowsNotSupported_ForStringFunctions(string filter, string exceptionMessage)
        {
            // Arrange
            var model        = GetEnumModel();
            var context      = new ODataQueryContext(model, typeof(EnumModel));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable <EnumModel> enumModels = EnumModelTestData;

            // Act
            Assert.Throws <ODataException>(
                () => filterOption.ApplyTo(enumModels.AsQueryable(), new ODataQuerySettings {
                HandleNullPropagation = HandleNullPropagationOption.True
            }),
                exceptionMessage
                );
        }
Пример #9
0
        public void ApplyWithCast_Throws_WithInvalidFilter(string filter, Type exceptionType)
        {
            // Arrange
            var model        = GetCastModel();
            var context      = new ODataQueryContext(model, typeof(DataTypes));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable <DataTypes> castModels = CastModelTestData;

            // Act & Assert
            Assert.Throws(
                exceptionType,
                () => filterOption.ApplyTo(
                    castModels.AsQueryable(),
                    new ODataQuerySettings {
                HandleNullPropagation = HandleNullPropagationOption.True
            }));
        }
Пример #10
0
        public void ApplyToEnums_DoesnotThrow_ForUndefinedValue(string filter)
        {
            // Arrange
            var model        = GetEnumModel();
            var context      = new ODataQueryContext(model, typeof(EnumModel));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable <EnumModel> enumModels = EnumModelTestData;

            // Act
            Assert.DoesNotThrow(
                () => filterOption.ApplyTo(enumModels.AsQueryable(),
                                           new ODataQuerySettings
            {
                HandleNullPropagation = HandleNullPropagationOption.True
            })
                );
        }
Пример #11
0
        public void ApplyWithCast_ShouldWork_WithStringToEnumConversionFilter()
        {
            // Arrange
            string filter  = "cast('123',Microsoft.TestCommon.Types.SimpleEnum) ne 'First'";
            var    model   = GetCastModel();
            var    context = new ODataQueryContext(model, typeof(DataTypes))
            {
                RequestContainer = new MockContainer()
            };
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable <DataTypes> castModels = CastModelTestData;

            // Act & Assert
            filterOption.ApplyTo(
                castModels.AsQueryable(),
                new ODataQuerySettings {
                HandleNullPropagation = HandleNullPropagationOption.True
            });
        }
Пример #12
0
        public void ApplyToEnums_Throws_WithInvalidFilter(string filter, Type exceptionType)
        {
            // Arrange
            var model   = GetEnumModel();
            var context = new ODataQueryContext(model, typeof(EnumModel))
            {
                RequestContainer = new MockContainer()
            };
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable <EnumModel> enumModels = EnumModelTestData;

            // Act & Assert
            Assert.Throws(
                exceptionType,
                () => filterOption.ApplyTo(
                    enumModels.AsQueryable(),
                    new ODataQuerySettings {
                HandleNullPropagation = HandleNullPropagationOption.True
            }));
        }
Пример #13
0
        public void ApplyWithCast_ReturnsCorrectQueryable(string filter, int[] castModelIds)
        {
            // Arrange
            var model        = GetCastModel();
            var context      = new ODataQueryContext(model, typeof(DataTypes));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable <DataTypes> castModels = CastModelTestData;

            // Act
            IQueryable queryable = filterOption.ApplyTo(castModels.AsQueryable(), new ODataQuerySettings {
                HandleNullPropagation = HandleNullPropagationOption.True
            });

            // Assert
            Assert.NotNull(queryable);
            IEnumerable <DataTypes> actualProducts = Assert.IsAssignableFrom <IEnumerable <DataTypes> >(queryable);

            Assert.Equal(
                castModelIds,
                actualProducts.Select(product => product.IntProp));
        }
        public void ApplyTo_WithUnTypedContext_Throws_InvalidOperation()
        {
            CustomersModelWithInheritance model = new CustomersModelWithInheritance();
            ODataQueryContext context = new ODataQueryContext(model.Model, model.Customer);
            FilterQueryOption filter = new FilterQueryOption("Id eq 42", context);
            IQueryable queryable = new Mock<IQueryable>().Object;

            Assert.Throws<NotSupportedException>(() => filter.ApplyTo(queryable, new ODataQuerySettings()),
                "The query option is not bound to any CLR type. 'ApplyTo' is only supported with a query option bound to a CLR type.");
        }
        public void ApplyTo_ReturnsCorrectQueryable_PropertyAlias(string filter, int[] propertyAliasIds)
        {
            // Arrange
            var model = GetPropertyAliasModel();
            var context = new ODataQueryContext(model, typeof(PropertyAlias));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable<PropertyAlias> propertyAliases = PropertyAliasTestData;

            // Act
            IQueryable queryable = filterOption.ApplyTo(
                propertyAliases.AsQueryable(),
                new ODataQuerySettings { HandleNullPropagation = HandleNullPropagationOption.True });

            // Assert
            Assert.NotNull(queryable);
            IEnumerable<PropertyAlias> actualPropertyAliases = Assert.IsAssignableFrom<IEnumerable<PropertyAlias>>(queryable);
            Assert.Equal(
                propertyAliasIds,
                actualPropertyAliases.Select(propertyAlias => propertyAlias.Id));
        }
        public void ApplyWithParameterAlias_ReturnsCorrectQueryable(string filter, string parameterAliasValue, int[] parameterAliasModelIds)
        {
            // Arrange
            var model = GetParameterAliasModel();
            var context = new ODataQueryContext(model, typeof(DataTypes));
            IEdmType targetEdmType = model.FindType("System.Web.OData.Query.Expressions.DataTypes");
            IEdmNavigationSource targetNavigationSource = model.FindDeclaredEntitySet("System.Web.OData.Query.Expressions.Products");

            ODataQueryOptionParser parser = new ODataQueryOptionParser(
                model,
                targetEdmType,
                targetNavigationSource,
                new Dictionary<string, string> { { "$filter", filter }, { "@p", parameterAliasValue } });

            var filterOption = new FilterQueryOption(filter, context, parser);
            IEnumerable<DataTypes> parameterAliasModels = ParameterAliasTestData;

            // Act
            IQueryable queryable = filterOption.ApplyTo(parameterAliasModels.AsQueryable(), new ODataQuerySettings { HandleNullPropagation = HandleNullPropagationOption.True });

            // Assert
            Assert.NotNull(queryable);
            IEnumerable<DataTypes> actualResult = Assert.IsAssignableFrom<IEnumerable<DataTypes>>(queryable);
            Assert.Equal(
                parameterAliasModelIds,
                actualResult.Select(result => result.IntProp));
        }
        public void ApplyToEnums_ThrowsNotSupported_ForStringFunctions(string filter, string exceptionMessage)
        {
            // Arrange
            var model = GetEnumModel();
            var context = new ODataQueryContext(model, typeof(EnumModel));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable<EnumModel> enumModels = EnumModelTestData;

            // Act
            Assert.Throws<ODataException>(
                () => filterOption.ApplyTo(enumModels.AsQueryable(), new ODataQuerySettings { HandleNullPropagation = HandleNullPropagationOption.True }),
                exceptionMessage
            );
        }
        public void ApplyWithCast_Throws_WithInvalidFilter(string filter, Type exceptionType)
        {
            // Arrange
            var model = GetCastModel();
            var context = new ODataQueryContext(model, typeof(DataTypes));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable<DataTypes> castModels = CastModelTestData;

            // Act & Assert
            Assert.Throws(
                exceptionType,
                () => filterOption.ApplyTo(
                    castModels.AsQueryable(),
                    new ODataQuerySettings { HandleNullPropagation = HandleNullPropagationOption.True }));
        }
        public void ApplyWithCast_ReturnsCorrectQueryable(string filter, int[] castModelIds)
        {
            // Arrange
            var model = GetCastModel();
            var context = new ODataQueryContext(model, typeof(DataTypes));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable<DataTypes> castModels = CastModelTestData;

            // Act
            IQueryable queryable = filterOption.ApplyTo(castModels.AsQueryable(), new ODataQuerySettings { HandleNullPropagation = HandleNullPropagationOption.True });

            // Assert
            Assert.NotNull(queryable);
            IEnumerable<DataTypes> actualProducts = Assert.IsAssignableFrom<IEnumerable<DataTypes>>(queryable);
            Assert.Equal(
                castModelIds,
                actualProducts.Select(product => product.IntProp));
        }
        public void ApplyToEnums_DoesnotThrow_ForUndefinedValue(string filter)
        {
            // Arrange
            var model = GetEnumModel();
            var context = new ODataQueryContext(model, typeof(EnumModel));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable<EnumModel> enumModels = EnumModelTestData;

            // Act
            Assert.DoesNotThrow(
                () => filterOption.ApplyTo(enumModels.AsQueryable(),
                    new ODataQuerySettings
                    {
                        HandleNullPropagation = HandleNullPropagationOption.True
                    })
            );
        }
        public void ApplyToEnums_ReturnsCorrectQueryable(string filter, int[] enumModelIds)
        {
            // Arrange
            var model = GetEnumModel();
            var context = new ODataQueryContext(model, typeof(EnumModel));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable<EnumModel> enumModels = EnumModelTestData;

            // Act
            IQueryable queryable = filterOption.ApplyTo(enumModels.AsQueryable(), new ODataQuerySettings { HandleNullPropagation = HandleNullPropagationOption.True });

            // Assert
            Assert.NotNull(queryable);
            IEnumerable<EnumModel> actualCustomers = Assert.IsAssignableFrom<IEnumerable<EnumModel>>(queryable);
            Assert.Equal(
                enumModelIds,
                actualCustomers.Select(enumModel => enumModel.Id));
        }
        public void ApplyTo_Returns_Correct_Queryable(string filter, int[] customerIds)
        {
            // Arrange
            var model = new ODataModelBuilder()
                            .Add_Order_EntityType()
                            .Add_Customer_EntityType_With_Address()
                            .Add_CustomerOrders_Relationship()
                            .Add_Customer_EntityType_With_CollectionProperties()
                            .Add_Customers_EntitySet()
                            .GetEdmModel();
            var context = new ODataQueryContext(model, typeof(Customer));
            var filterOption = new FilterQueryOption(filter, context);
            IEnumerable<Customer> customers = CustomerFilterTestData;

            // Act
            IQueryable queryable = filterOption.ApplyTo(customers.AsQueryable(), new ODataQuerySettings { HandleNullPropagation = HandleNullPropagationOption.True });

            // Assert
            Assert.NotNull(queryable);
            IEnumerable<Customer> actualCustomers = Assert.IsAssignableFrom<IEnumerable<Customer>>(queryable);
            Assert.Equal(
                customerIds,
                actualCustomers.Select(customer => customer.CustomerId));
        }
        public void ApplyTo_Throws_Null_AssembliesResolver()
        {
            // Arrange
            var model = new ODataModelBuilder().Add_Customer_EntityType_With_CollectionProperties().Add_Customers_EntitySet().Add_Address_ComplexType().GetEdmModel();
            var context = new ODataQueryContext(model, typeof(Customer));
            var filter = new FilterQueryOption("Addresses/any(a: a/HouseNumber eq 1)", context);

            // Act & Assert
            Assert.ThrowsArgumentNull(() => filter.ApplyTo(new Customer[0].AsQueryable(), new ODataQuerySettings(), null), "assembliesResolver");
        }