Exemplo n.º 1
0
        public void When_Query_Matches_Multiple_EntityTypes_Then_Using_ExecuteSingleAsync_Must_Fail()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(8))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery = context.CreateQuery<Product>("/" + "Products");
                IReadOnlyQueryableSet<IProduct> readOnlySet = new ReadOnlyQueryableSet<IProduct>(dQuery, context);

                //Query using linq
                var linqQuery = from prod in readOnlySet
                                orderby prod.Category
                                select prod;

                var action = new Action(() =>
                {
                    var product = linqQuery.ExecuteSingleAsync().Result;
                });

                action.ShouldThrow<AggregateException>().
                    WithInnerException<InvalidOperationException>().
                    WithInnerMessage("Sequence contains more than one element");
            }
        }
        public void When_Two_Unsuccessful_Queries_Are_Batched_Then_Two_BatchResults_Are_Failures()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(8))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                IReadOnlyQueryableSet<Product> productsSet = new ReadOnlyQueryableSet<Product>(
                                                                    context.CreateQuery<Product>("SomeRandomEntitySet"),
                                                                    context);
                IReadOnlyQueryableSet<Product> prod10 = new ReadOnlyQueryableSet<Product>(
                                                                    context.CreateQuery<Product>("Products(10)"),
                                                                    context);

                var batchResult = context.ExecuteBatchAsync(productsSet, prod10).Result;
                batchResult.Count().Should().Be(2);

                foreach (var result in batchResult)
                {
                    result.SuccessResult.Should().BeNull();
                    result.FailureResult.Should().NotBeNull();

                    result.FailureResult.
                    Should().BeOfType<DataServiceClientException>().
                    Which.
                    StatusCode.Should().Be(404);
                }
            }
        }
        public void When_Querying_For_Series_Of_NavigationProperties_Then_Each_Query_Return_Expected_EntityType_Or_Collection()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithSuppliedProducts(Any.Suppliers())
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery<SuppliedProduct>("/" + "SuppliedProducts");
                IReadOnlyQueryableSet<SuppliedProduct> productSet = new ReadOnlyQueryableSet<SuppliedProduct>(dQuery, context);
                var products = productSet.Expand(p => p.Supplier).ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(25);

                var suppliedProduct = products.CurrentPage.RandomElement() as SuppliedProduct;
                string supplierPath = suppliedProduct.GetPath("Supplier");
                var supplierQuery = context.CreateQuery<Supplier>(supplierPath);
                IReadOnlyQueryableSet<Supplier> supplierSet = new ReadOnlyQueryableSet<Supplier>(supplierQuery, context);
                //TODO - Unable to expand a collection
                var supplier = supplierSet.Expand(s => s.Products).ExecuteSingleAsync().Result;
                suppliedProduct.Supplier.Id.Should().Be(supplier.Id);

                // Hence querying for the SuppliedProducts
                string productsPath = supplier.GetPath("Products");
                dQuery = context.CreateQuery<SuppliedProduct>(productsPath);
                productSet = new ReadOnlyQueryableSet<SuppliedProduct>(dQuery, context);
                products = productSet.ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(5);
                products.CurrentPage.Should().Contain(p => p.Id == suppliedProduct.Id);
            }
        }
Exemplo n.º 4
0
        public void When_Two_Unsuccessful_Queries_Are_Batched_Then_Two_BatchResults_Are_Failures()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithProducts(Any.Products(8))
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                IReadOnlyQueryableSet <Product> productsSet = new ReadOnlyQueryableSet <Product>(
                    context.CreateQuery <Product>("SomeRandomEntitySet"),
                    context);
                IReadOnlyQueryableSet <Product> prod10 = new ReadOnlyQueryableSet <Product>(
                    context.CreateQuery <Product>("Products(10)"),
                    context);

                var batchResult = context.ExecuteBatchAsync(productsSet, prod10).Result;
                batchResult.Count().Should().Be(2);

                foreach (var result in batchResult)
                {
                    result.SuccessResult.Should().BeNull();
                    result.FailureResult.Should().NotBeNull();

                    result.FailureResult.
                    Should().BeOfType <DataServiceClientException>().
                    Which.
                    StatusCode.Should().Be(404);
                }
            }
        }
        public void When_Two_Successful_Queries_Are_Batched_Then_Two_BatchResults_Are_Successful()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(8))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                IReadOnlyQueryableSet<Product> productsSet = new ReadOnlyQueryableSet<Product>(
                                                                    context.CreateQuery<Product>("Products"),
                                                                    context);
                IReadOnlyQueryableSet<Product> prod3 = new ReadOnlyQueryableSet<Product>(
                                                                    context.CreateQuery<Product>("Products(3)"),
                                                                    context);

                var batchResult = context.ExecuteBatchAsync(productsSet, prod3).Result;
                batchResult.Count().Should().Be(2);

                foreach (var result in batchResult)
                {
                    result.SuccessResult.Should().NotBeNull();
                    result.FailureResult.Should().BeNull();
                }

                var products = batchResult[0].SuccessResult;
                products.CurrentPage.Count.Should().Be(8);

                products = batchResult[1].SuccessResult;
                products.CurrentPage.Count.Should().Be(1);
                (products.CurrentPage[0] as Product).Id.Should().Be(3);
            }
        }
Exemplo n.º 6
0
        public void When_Using_OrderBy_Clause_Then_Returned_Sequence_Is_Sorted_Ascending()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(8))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery = context.CreateQuery<Product>("/" + "Products");
                IReadOnlyQueryableSet<IProduct> readOnlySet = new ReadOnlyQueryableSet<IProduct>(dQuery, context);

                //Query directly
                var products = readOnlySet.OrderBy(p => p.Name).ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(8);
                products.CurrentPage.Should().BeInAscendingOrder(p => p.Name);

                //Query using linq
                var linqQuery = from prod in readOnlySet
                                orderby prod.Category
                                select prod;
                products = linqQuery.ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(8);
                products.CurrentPage.Should().BeInAscendingOrder(p => p.Category);
            }
        }
Exemplo n.º 7
0
        public void When_Two_Successful_Queries_Are_Batched_Then_Two_BatchResults_Are_Successful()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithProducts(Any.Products(8))
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                IReadOnlyQueryableSet <Product> productsSet = new ReadOnlyQueryableSet <Product>(
                    context.CreateQuery <Product>("Products"),
                    context);
                IReadOnlyQueryableSet <Product> prod3 = new ReadOnlyQueryableSet <Product>(
                    context.CreateQuery <Product>("Products(3)"),
                    context);

                var batchResult = context.ExecuteBatchAsync(productsSet, prod3).Result;
                batchResult.Count().Should().Be(2);

                foreach (var result in batchResult)
                {
                    result.SuccessResult.Should().NotBeNull();
                    result.FailureResult.Should().BeNull();
                }

                var products = batchResult[0].SuccessResult;
                products.CurrentPage.Count.Should().Be(8);

                products = batchResult[1].SuccessResult;
                products.CurrentPage.Count.Should().Be(1);
                (products.CurrentPage[0] as Product).Id.Should().Be(3);
            }
        }
Exemplo n.º 8
0
        public void When_Querying_For_Existing_EntitySet_Using_EntityType_Interface_Then_Return_The_EntitySet()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products())
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery = context.CreateQuery<Product>("/" + "Products");
                IReadOnlyQueryableSet<IProduct> readOnlySet = new ReadOnlyQueryableSet<IProduct>(dQuery, context);

                var products = readOnlySet.ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(5);
                (products.CurrentPage[2] as Product).Id.Should().Be(3);
            }
        }
Exemplo n.º 9
0
        public void When_Querying_For_Existing_EntitySet_Using_EntityType_Interface_Then_Return_The_EntitySet()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithProducts(Any.Products())
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery  = context.CreateQuery <Product>("/" + "Products");
                IReadOnlyQueryableSet <IProduct> readOnlySet = new ReadOnlyQueryableSet <IProduct>(dQuery, context);

                var products = readOnlySet.ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(5);
                (products.CurrentPage[2] as Product).Id.Should().Be(3);
            }
        }
Exemplo n.º 10
0
        public void When_Using_Filter_Clause_On_Expanded_Navigation_Property_Then_Returned_Sequence_Is_Filtered()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithSuppliedProducts(Any.Suppliers())
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery <SuppliedProduct>("/" + "SuppliedProducts");
                IReadOnlyQueryableSet <ISuppliedProduct> productSet = new ReadOnlyQueryableSet <ISuppliedProduct>(dQuery, context);
                var products = productSet.Expand(p => (p as SuppliedProduct).Supplier).
                               Where(p => p.Supplier.Id == 2).
                               ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(5);
            }
        }
Exemplo n.º 11
0
        public void When_Using_Expand_Clause_On_EntityType_Interface_Then_Resulting_Sequence_Must_Be_Expanded()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithSuppliedProducts(Any.Suppliers())
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery <SuppliedProduct>("/" + "SuppliedProducts");
                IReadOnlyQueryableSet <ISuppliedProduct> productSet = new ReadOnlyQueryableSet <ISuppliedProduct>(dQuery, context);

                var products = productSet.Expand(p => p.Supplier)
                               .ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(25);
                products.CurrentPage.Should().OnlyContain(p => p.Supplier != null);
            }
        }
Exemplo n.º 12
0
        public void When_SkipCount_EqualsTo_EntitySet_Count_Then_Return_EntitySet_With_Zero_Elements()
        {
            int skipCount     = 8;
            int productsCount = 8;

            using (var scenario =
                       new ODataScenario()
                       .WithProducts(Any.Products(productsCount))
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery  = context.CreateQuery <Product>("/" + "Products");
                IReadOnlyQueryableSet <IProduct> readOnlySet = new ReadOnlyQueryableSet <IProduct>(dQuery, context);

                //skip the top 8 results
                var products = readOnlySet.Skip(skipCount).ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(0);
            }
        }
Exemplo n.º 13
0
        public void When_Query_Matches_One_EntityType_Then_Using_ExecuteSingleAsync_Must_Succeed()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(8))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery = context.CreateQuery<Product>("/" + "Products");
                IReadOnlyQueryableSet<IProduct> readOnlySet = new ReadOnlyQueryableSet<IProduct>(dQuery, context);

                //Query using linq
                var linqQuery = from prod in readOnlySet
                                where prod.Id == 2
                                select prod;

                var product = linqQuery.ExecuteSingleAsync().Result;
                product.Id.Should().Be(2);
            }
        }
Exemplo n.º 14
0
        public void When_TakeCount_GreaterThan_EntitySet_Count_Then_Return_EntitySet_With_EntitySet_Count()
        {
            int takeCount     = 10;
            int productsCount = 8;

            using (var scenario =
                       new ODataScenario()
                       .WithProducts(Any.Products(productsCount))
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery  = context.CreateQuery <Product>("/" + "Products");
                IReadOnlyQueryableSet <IProduct> readOnlySet = new ReadOnlyQueryableSet <IProduct>(dQuery, context);

                //take the top 10 results
                var products = readOnlySet.Take(takeCount).ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(productsCount);
                (products.CurrentPage[7] as Product).Id.Should().Be(8);
            }
        }
Exemplo n.º 15
0
        public void When_Query_Matches_One_EntityType_Then_Using_ExecuteSingleAsync_Must_Succeed()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithProducts(Any.Products(8))
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery  = context.CreateQuery <Product>("/" + "Products");
                IReadOnlyQueryableSet <IProduct> readOnlySet = new ReadOnlyQueryableSet <IProduct>(dQuery, context);

                //Query using linq
                var linqQuery = from prod in readOnlySet
                                where prod.Id == 2
                                select prod;

                var product = linqQuery.ExecuteSingleAsync().Result;
                product.Id.Should().Be(2);
            }
        }
Exemplo n.º 16
0
        public void When_Using_Projections_Then_Returned_Sequence_Contains_ProjectedTypes()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithProducts(Any.Products(8))
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery  = context.CreateQuery <Product>("/" + "Products");
                IReadOnlyQueryableSet <Product> readOnlySet = new ReadOnlyQueryableSet <Product>(dQuery, context);

                //Query directly
                var prodNames = readOnlySet.Select(p => new { p.Name, p.Price }).ExecuteAsync().Result;
                prodNames.CurrentPage.Count.Should().Be(8);

                //Query using linq
                var linqQuery = from prod in readOnlySet
                                select new { prod.Name, prod.Price };
                prodNames = linqQuery.ExecuteAsync().Result;
                prodNames.CurrentPage.Count.Should().Be(8);
            }
        }
Exemplo n.º 17
0
        public void When_TakeCount_IsWrong_Then_Throw_ODataErrorException()
        {
            int takeCount     = -6;
            int productsCount = 8;

            using (var scenario =
                       new ODataScenario()
                       .WithProducts(Any.Products(productsCount))
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery  = context.CreateQuery <Product>("/" + "Products");
                IReadOnlyQueryableSet <IProduct> readOnlySet = new ReadOnlyQueryableSet <IProduct>(dQuery, context);

                var action = new Action(() =>
                {
                    var products = readOnlySet.Skip(takeCount).ExecuteAsync().Result;
                });

                action.ShouldThrow <AggregateException>().WithInnerException <ODataErrorException>();
            }
        }
Exemplo n.º 18
0
        public void When_Querying_For_NavigationProperty_Then_Return_Single_Expected_EntityType()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithSuppliedProducts(Any.Suppliers())
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery <SuppliedProduct>("/" + "SuppliedProducts");
                IReadOnlyQueryableSet <SuppliedProduct> productSet = new ReadOnlyQueryableSet <SuppliedProduct>(dQuery, context);
                var products = productSet.Expand(p => p.Supplier).ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(25);

                var    suppliedProduct = products.CurrentPage.RandomElement() as SuppliedProduct;
                string supplierPath    = suppliedProduct.GetPath("Supplier");
                var    supplierQuery   = context.CreateQuery <Supplier>(supplierPath);

                IReadOnlyQueryableSet <Supplier> supplierSet = new ReadOnlyQueryableSet <Supplier>(supplierQuery, context);
                var supplier = supplierSet.ExecuteSingleAsync().Result;
                suppliedProduct.Supplier.Id.Should().Be(supplier.Id);
            }
        }
        public void When_Querying_For_NavigationProperty_Then_Return_Single_Expected_EntityType()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithSuppliedProducts(Any.Suppliers())
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery<SuppliedProduct>("/" + "SuppliedProducts");
                IReadOnlyQueryableSet<SuppliedProduct> productSet = new ReadOnlyQueryableSet<SuppliedProduct>(dQuery, context);
                var products = productSet.Expand(p => p.Supplier).ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(25);

                var suppliedProduct = products.CurrentPage.RandomElement() as SuppliedProduct;
                string supplierPath = suppliedProduct.GetPath("Supplier");
                var supplierQuery = context.CreateQuery<Supplier>(supplierPath);

                IReadOnlyQueryableSet<Supplier> supplierSet = new ReadOnlyQueryableSet<Supplier>(supplierQuery, context);
                var supplier = supplierSet.ExecuteSingleAsync().Result;
                suppliedProduct.Supplier.Id.Should().Be(supplier.Id);
            }
        }
Exemplo n.º 20
0
        public void When_Using_Filter_Clause_Then_Returned_Sequence_Is_Filtered()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithProducts(Any.Products(14))
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery  = context.CreateQuery <Product>("/" + "Products");
                IReadOnlyQueryableSet <Product> readOnlySet = new ReadOnlyQueryableSet <Product>(dQuery, context);

                //Query directly
                var products = readOnlySet.Where(p => p.Id <= 7).ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(7);

                //Query using linq
                var linqQuery = from prod in readOnlySet
                                where prod.Id <= 9
                                select prod;
                products = linqQuery.ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(9);
            }
        }
Exemplo n.º 21
0
        public void When_Using_Orderby_Clause_Before_Projections_Then_Returned_Sequence_Contains_ProjectedTypes_Sorted_Ascending()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithSuppliedProducts(Any.Suppliers())
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery <SuppliedProduct>("/" + "SuppliedProducts");
                IReadOnlyQueryableSet <SuppliedProduct> prodSet = new ReadOnlyQueryableSet <SuppliedProduct>(dQuery, context);

                var linqQuery =
                    from prod in prodSet
                    where prod.Id < 400
                    orderby prod.Name
                    select new { supplier = prod.Supplier, prod.Name } into x
                select x;

                var products = linqQuery.ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(15);
                products.CurrentPage.Should().BeInAscendingOrder(a => a.Name);
            }
        }
Exemplo n.º 22
0
        public void When_Querying_For_NavigationPropertyCollection_Then_Return_Expected_EntityTypeCollection()
        {
            using (var scenario =
                       new ODataScenario()
                       .WithSuppliedProducts(Any.Suppliers())
                       .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery <Supplier>("/" + "Suppliers");
                IReadOnlyQueryableSet <Supplier> supplierSet = new ReadOnlyQueryableSet <Supplier>(dQuery, context);
                var suppliers = supplierSet.ExecuteAsync().Result;
                suppliers.CurrentPage.Count.Should().Be(5);

                var    supplier     = suppliers.CurrentPage.RandomElement();
                string productsPath = supplier.GetPath("Products");
                var    dQueryProds  = context.CreateQuery <SuppliedProduct>(productsPath);
                var    productSet   = new ReadOnlyQueryableSet <SuppliedProduct>(dQueryProds, context);

                var products = productSet.ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(5);
                products.CurrentPage.Should().Contain(p => p.SupplierId == supplier.Id);
            }
        }
        public void When_One_Unsuccessful_And_Successful_Queries_Are_Batched_Then_Two_Corresponding_BatchResults_Are_Failure_Success()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(8))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                IReadOnlyQueryableSet<Product> productsSet = new ReadOnlyQueryableSet<Product>(
                                                                    context.CreateQuery<Product>("SomeRandomEntitySet"),
                                                                    context);
                IReadOnlyQueryableSet<Product> prod3 = new ReadOnlyQueryableSet<Product>(
                                                                    context.CreateQuery<Product>("Products(3)"),
                                                                    context);

                var batchResult = context.ExecuteBatchAsync(productsSet, prod3).Result;
                batchResult.Count().Should().Be(2);

                batchResult[0].FailureResult.
                    Should().BeOfType<DataServiceClientException>().
                    Which.
                    StatusCode.Should().Be(404);

                batchResult[1].SuccessResult.
                    CurrentPage.Count.Should().Be(1);
                batchResult[1].SuccessResult.
                    CurrentPage[0].
                    Should().BeOfType<Product>().
                    Which.
                    Id.Should().Be(3);
            }
        }
Exemplo n.º 24
0
        public void When_Using_Orderby_Clause_After_Projections_Then_Throw_NotSupportedException()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithSuppliedProducts(Any.Suppliers())
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery<SuppliedProduct>("/" + "SuppliedProducts");
                IReadOnlyQueryableSet<SuppliedProduct> prodSet = new ReadOnlyQueryableSet<SuppliedProduct>(dQuery, context);

                var linqQuery =
                           from prod in prodSet
                           where prod.Id < 400
                           select new { supplier = prod.Supplier, prod } into x
                           orderby x.supplier.Name
                           select x;

                var action = new Action(() =>
                {
                    var products = linqQuery.ExecuteAsync().Result;
                });

                action.ShouldThrow<AggregateException>().
                    WithInnerException<NotSupportedException>().
                    WithInnerMessage("The orderby query option cannot be specified after the select query option.");
            }
        }
Exemplo n.º 25
0
        public void When_Using_Filter_Clause_Then_Returned_Sequence_Is_Filtered()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(14))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery = context.CreateQuery<Product>("/" + "Products");
                IReadOnlyQueryableSet<Product> readOnlySet = new ReadOnlyQueryableSet<Product>(dQuery, context);

                //Query directly
                var products = readOnlySet.Where(p => p.Id <= 7).ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(7);

                //Query using linq
                var linqQuery = from prod in readOnlySet
                                where prod.Id <= 9
                                select prod;
                products = linqQuery.ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(9);
            }
        }
Exemplo n.º 26
0
        public void When_Using_Projections_Then_Returned_Sequence_Contains_ProjectedTypes()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(8))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery = context.CreateQuery<Product>("/" + "Products");
                IReadOnlyQueryableSet<Product> readOnlySet = new ReadOnlyQueryableSet<Product>(dQuery, context);

                //Query directly
                var prodNames = readOnlySet.Select(p => new { p.Name, p.Price }).ExecuteAsync().Result;
                prodNames.CurrentPage.Count.Should().Be(8);

                //Query using linq
                var linqQuery = from prod in readOnlySet
                                select new { prod.Name, prod.Price };
                prodNames = linqQuery.ExecuteAsync().Result;
                prodNames.CurrentPage.Count.Should().Be(8);
            }
        }
Exemplo n.º 27
0
        public void When_SkipCount_GreaterThan_EntitySet_Count_Then_Return_EntitySet_With_Zero_Elements()
        {
            int skipCount = 12;
            int productsCount = 8;
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(productsCount))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery = context.CreateQuery<Product>("/" + "Products");
                IReadOnlyQueryableSet<IProduct> readOnlySet = new ReadOnlyQueryableSet<IProduct>(dQuery, context);

                //skip the top 12 results
                var products = readOnlySet.Skip(skipCount).ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(0);
            }
        }
Exemplo n.º 28
0
        public void When_TakeCount_IsWrong_Then_Throw_ODataErrorException()
        {
            int takeCount = -6;
            int productsCount = 8;
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(productsCount))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery = context.CreateQuery<Product>("/" + "Products");
                IReadOnlyQueryableSet<IProduct> readOnlySet = new ReadOnlyQueryableSet<IProduct>(dQuery, context);

                var action = new Action(() =>
                {
                    var products = readOnlySet.Skip(takeCount).ExecuteAsync().Result;
                });

                action.ShouldThrow<AggregateException>().WithInnerException<ODataErrorException>();
            }
        }
Exemplo n.º 29
0
        public void When_TakeCount_EqualsTo_EntitySet_Count_Then_Return_EntitySet_With_TakeCount()
        {
            int takeCount = 8;
            int productsCount = 8;
            using (var scenario =
                    new ODataScenario()
                        .WithProducts(Any.Products(productsCount))
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());
                var dQuery = context.CreateQuery<Product>("/" + "Products");
                IReadOnlyQueryableSet<IProduct> readOnlySet = new ReadOnlyQueryableSet<IProduct>(dQuery, context);

                //take the top 10 results
                var products = readOnlySet.Take(takeCount).ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(takeCount);
                (products.CurrentPage[7] as Product).Id.Should().Be(8);
            }
        }
Exemplo n.º 30
0
        public void When_Using_Expand_Clause_On_EntityType_Interface_Then_Resulting_Sequence_Must_Be_Expanded()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithSuppliedProducts(Any.Suppliers())
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery<SuppliedProduct>("/" + "SuppliedProducts");
                IReadOnlyQueryableSet<ISuppliedProduct> productSet = new ReadOnlyQueryableSet<ISuppliedProduct>(dQuery, context);

                var products = productSet.Expand(p => p.Supplier)
                    .ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(25);
                products.CurrentPage.Should().OnlyContain(p => p.Supplier != null);
            }
        }
Exemplo n.º 31
0
        public void When_Using_Orderby_Clause_Before_Projections_Then_Returned_Sequence_Contains_ProjectedTypes_Sorted_Ascending()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithSuppliedProducts(Any.Suppliers())
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery<SuppliedProduct>("/" + "SuppliedProducts");
                IReadOnlyQueryableSet<SuppliedProduct> prodSet = new ReadOnlyQueryableSet<SuppliedProduct>(dQuery, context);

                var linqQuery =
                           from prod in prodSet
                           where prod.Id < 400
                           orderby prod.Name
                           select new { supplier = prod.Supplier, prod.Name } into x
                           select x;

                var products = linqQuery.ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(15);
                products.CurrentPage.Should().BeInAscendingOrder(a => a.Name);
            }
        }
        public void When_Querying_For_NavigationPropertyCollection_Then_Return_Expected_EntityTypeCollection()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithSuppliedProducts(Any.Suppliers())
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery<Supplier>("/" + "Suppliers");
                IReadOnlyQueryableSet<Supplier> supplierSet = new ReadOnlyQueryableSet<Supplier>(dQuery, context);
                var suppliers = supplierSet.ExecuteAsync().Result;
                suppliers.CurrentPage.Count.Should().Be(5);

                var supplier = suppliers.CurrentPage.RandomElement();
                string productsPath = supplier.GetPath("Products");
                var dQueryProds = context.CreateQuery<SuppliedProduct>(productsPath);
                var productSet = new ReadOnlyQueryableSet<SuppliedProduct>(dQueryProds, context);

                var products = productSet.ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(5);
                products.CurrentPage.Should().Contain(p => p.SupplierId == supplier.Id);
            }
        }
Exemplo n.º 33
0
        public void When_Using_Filter_Clause_On_Expanded_Navigation_Property_Then_Returned_Sequence_Is_Filtered()
        {
            using (var scenario =
                    new ODataScenario()
                        .WithSuppliedProducts(Any.Suppliers())
                        .Start())
            {
                var context = GetDataServiceContext(scenario.GetBaseAddress());

                var dQuery = context.CreateQuery<SuppliedProduct>("/" + "SuppliedProducts");
                IReadOnlyQueryableSet<ISuppliedProduct> productSet = new ReadOnlyQueryableSet<ISuppliedProduct>(dQuery, context);
                var products = productSet.Expand(p => (p as SuppliedProduct).Supplier).
                    Where(p => p.Supplier.Id == 2).
                    ExecuteAsync().Result;
                products.CurrentPage.Count.Should().Be(5);
            }
        }