Exemplo n.º 1
0
        public void TestQuery()
        {
            WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract> dc = new WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract>(TestURIs.LTS_Catalog)
            {
                EntityTypes = new Type[] { typeof(Product) }
            };

            var query = from p in Array.Empty <Product>().AsQueryable()
                        where p.Weight < 10.5M
                        orderby p.Weight
                        select p;

            var entityQuery = new EntityQuery <Product>(new EntityQuery <Product>(dc, "GetProducts", null, true, false), query);

            entityQuery.IncludeTotalCount = true;

            var queryTask = dc.QueryAsync(entityQuery, CancellationToken.None);

            EnqueueConditional(delegate
            {
                return(queryTask.IsCompleted);
            });
            EnqueueCallback(delegate
            {
                var result = queryTask.Result;

                Assert.AreEqual(79, result.Entities.Concat(result.IncludedEntities).Count());
                Assert.AreEqual(result.Entities.Count(), result.TotalCount);
            });

            EnqueueTestComplete();
        }
Exemplo n.º 2
0
        public async Task TestQueryEvents()
        {
            WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract> dc = new WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract>(TestURIs.LTS_Catalog)
            {
                EntityTypes = new Type[] { typeof(Product) }
            };

            var result = await dc.QueryAsync(new EntityQuery <Product>(dc, "GetProducts", null, true, false), CancellationToken.None);

            Assert.AreEqual(504, result.Entities.Concat(result.IncludedEntities).Count());
            Assert.AreEqual(result.Entities.Count(), result.TotalCount);
        }
Exemplo n.º 3
0
        public void TestQueryEvents()
        {
            WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract> dc = new WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract>(TestURIs.LTS_Catalog)
            {
                EntityTypes = new Type[] { typeof(Product) }
            };

            var queryTask = dc.QueryAsync(new EntityQuery <Product>(dc, "GetProducts", null, true, false), CancellationToken.None);

            EnqueueConditional(delegate
            {
                return(queryTask.IsCompleted);
            });
            EnqueueCallback(delegate
            {
                var result = queryTask.Result;
                Assert.AreEqual(504, result.Entities.Concat(result.IncludedEntities).Count());
                Assert.AreEqual(result.Entities.Count(), result.TotalCount);
            });

            EnqueueTestComplete();
        }
Exemplo n.º 4
0
        public void TestMethodQueryMismatch()
        {
            WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract> dc = new WebDomainClient <TestDomainServices.LTS.Catalog.ICatalogContract>(TestURIs.EF_Catalog)
            {
                EntityTypes = new Type[] { typeof(Product), typeof(PurchaseOrder), typeof(PurchaseOrderDetail) }
            };

            var query = new EntityQuery <PurchaseOrder>(new EntityQuery <Product>(dc, "GetProducts", null, true, false), Array.Empty <PurchaseOrder>().AsQueryable().Take(2));

            query.IncludeTotalCount = true;

            var queryTask = dc.QueryAsync(query, CancellationToken.None);

            EnqueueConditional(() => queryTask.IsCompleted);

            EnqueueCallback(delegate
            {
                var queryResults = queryTask.Result;
                Assert.AreEqual(2, queryResults.Entities.Concat(queryResults.IncludedEntities).Count());
                Assert.AreEqual(504, queryResults.TotalCount);
            });

            EnqueueTestComplete();
        }