public StandardCopierSelect(DBInitializerAdvanced init)
 {
     repository       = init.Repository;
     provider         = new ODataQueryProvider();
     provider.Filter  = standardWhere;
     provider.OrderBy = standardSorting;
 }
        public void ItShouldCountSelectManyOperationsWhenNavigationPropertyIsNotDecorated()
        {
            var navProp = new MockNavigationProperty {
                Value = "provided"
            };
            var entity = new MockEntity {
                NavigationProperties = new[] { navProp }
            };

            var repository = new Mock <MockeableRepository>();

            repository.Setup(r => r.GetOne(It.Is <ODataSelectOneQueryOperation>(o => o.Key == "key" && o.OfType == typeof(MockEntity))))
            .Returns(entity);

            var operation = new ODataSelectManyQueryOperation {
                OfType = typeof(MockEntity), Keys = new Dictionary <string, string> {
                    { "key", "key" }
                }, NavigationProperty = "NavigationProperties", IsCountRequest = true
            };

            var provider = new ODataQueryProvider <MockEntity>(n => repository.Object);
            var result   = (long)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result, 1);
        }
    public void SelectFiltered()
    {
        ODataQueryProvider     odqp = new ODataQueryProvider();
        ODataQuery <Highscore> q    = new ODataQuery <Highscore>(odqp);

        string pn    = "d";
        var    query = q.Where(x => x.score > 500 || x.playername.StartsWith(pn)).OrderBy(x => x.score);

        AzureUnityServices.Instance.SelectFiltered <Highscore>(query, x =>
        {
            if (x.Status == CallBackResult.Success)
            {
                foreach (var item in x.Result)
                {
                    Debug.Log("score is " + item.score);
                }
                StatusText.text = "success, found " + x.Result.Count() + " results";
            }
            else
            {
                Debug.Log(x.Exception.Message);
            }
        });
        StatusText.text = "Loading...";
    }
        public void ItShouldExecuteProjectionsOnSelectManyQueryOperation()
        {
            var navProp = new MockNavigationProperty {
                Value = "provided"
            };
            var entity = new MockEntity {
                NavigationProperties = new[] { navProp }
            };

            var repository = new Mock <MockeableRepository>();

            repository.Setup(r => r.GetOne(It.Is <ODataSelectOneQueryOperation>(o => o.Key == "key" && o.OfType == typeof(MockEntity))))
            .Returns(entity);

            Expression <Func <MockNavigationProperty, dynamic> > projectionExpression = e => e == null ? null : new { e.Value };

            var operation = new ODataSelectManyQueryOperation
            {
                OfType = typeof(MockEntity),
                Keys   = new Dictionary <string, string> {
                    { "key", "key" }
                },
                NavigationProperty   = "NavigationProperties",
                ProjectionExpression = projectionExpression,
                ProjectedType        = typeof(object)
            };

            var provider = new ODataQueryProvider <MockEntity>(n => repository.Object);
            var result   = (IEnumerable <dynamic>)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result.First().Value, "provided");
        }
 public StandardCopierUpdate(DBInitializerAdvanced init)
 {
     repository       = init.Repository;
     context          = init.Context;
     provider         = new ODataQueryProvider();
     provider.Filter  = standardWhere;
     provider.OrderBy = standardSorting;
 }
        public void ItShouldRemoteCountMockEntity2WhenCollectionCountSupportsIt()
        {
            var operation = new ODataQueryOperation {
                OfType = typeof(MockEntity2), IsCountRequest = true
            };
            var provider = new ODataQueryProvider <MockEntity>(n => new MockRepository2());
            var result   = (long)provider.ExecuteQuery(operation);

            Assert.AreEqual(result, 1);
        }
        public ODataQuery(IODataClient <T> client)
        {
            if (client == null)
            {
                throw new ArgumentNullException(nameof(client));
            }

            this._provider   = new ODataQueryProvider <T>(client);
            this._expression = Expression.Constant(this);
        }
        public void ItShouldExecuteProjectionEvenWhenItHandlesSelect()
        {
            Expression<Func<MockEntity, dynamic>> projectionExpression = e => e == null ? null : new { e.Value };

            var operation = new ODataSelectOneQueryOperation { OfType = typeof(MockEntity), Keys = new Dictionary<string, string> { { "key", "key" } }, ProjectionExpression = projectionExpression, ProjectedType = typeof(object) };
            var provider = new ODataQueryProvider<MockEntity>(n => new HandlesSelectRepository(new MockEntity { Value = "value" }));
            var result = (IEnumerable<object>)provider.ExecuteQuery(operation);

            dynamic item = result.FirstOrDefault();
            Assert.AreEqual(item.Value, "value");
            Assert.IsNotInstanceOfType(result.FirstOrDefault(), typeof(MockEntity));
        }
        public void ItShouldRemoteDecoratedCountNavigationProperties()
        {
            var operation = new ODataSelectManyQueryOperation {
                OfType = typeof(MockEntity), Keys = new Dictionary <string, string> {
                    { "key", "key" }
                }, NavigationProperty = "RemoteCountedNavigationProperty", IsCountRequest = true
            };
            var provider = new ODataQueryProvider <MockEntity>(n => new RepositoryStub());
            var result   = (long)provider.ExecuteQuery(operation);

            Assert.IsNotNull(result);
            Assert.AreEqual(result, 10);
        }
        public void ItShouldNotThrowWhenRepositoryReturnsNullOnGetAll()
        {
            var repository = new Mock <IRepository <MockEntity> >();

            repository.Setup(r => r.GetAll()).Returns(default(MockEntity[]));
            var provider  = new ODataQueryProvider <MockEntity>(n => repository.Object);
            var operation = new ODataQueryOperation {
                OfType = typeof(MockEntity)
            };
            var result = provider.ExecuteQuery(operation);

            Assert.IsNull(result);
        }
Example #11
0
        public void AddingQueryableToInternalFilter(string filter, string toAdd, bool isOr)
        {
            provider.Filter = filter;
            var res = provider.Parse <ReferenceType>();

            Assert.NotNull(res);
            if (!string.IsNullOrEmpty(filter))
            {
                Assert.NotNull(res.Filter);
            }
            var ifilter1 = res.Filter;
            var iRes1    = res;

            provider        = new ODataQueryProvider();
            provider.Filter = toAdd;
            res             = provider.Parse <ReferenceType>();

            Assert.NotNull(res);

            Assert.NotNull(res.Filter);

            var ifilter2 = res.Filter;
            var iRes2    = res;

            var totalFilter = isOr ? string.Format("({0}) or ({1})", filter, toAdd)
                : string.Format("({0}) and ({1})", filter, toAdd);

            provider        = new ODataQueryProvider();
            provider.Filter = string.IsNullOrEmpty(filter) ? toAdd : totalFilter;
            res             = provider.Parse <ReferenceType>();

            Assert.NotNull(res);

            Assert.NotNull(res.Filter);

            var iTotalFilter = res.Filter;

            var linQToAdd = iRes2.GetFilterExpression();

            Assert.NotNull(linQToAdd);

            iRes1.AddFilterCondition(linQToAdd, isOr);



            Assert.Equal(iRes1.Filter.ToString(), iTotalFilter.ToString());
        }
        public void ItShouldInvokeGetOneForODataGetOneQueryOperation()
        {
            var repository = new Mock <MockeableRepository>();
            var operation  = new ODataSelectOneQueryOperation {
                OfType = typeof(MockEntity), Keys = new Dictionary <string, string> {
                    { "key", "foo" }
                }
            };

            repository.Setup(r => r.GetOne(operation)).Returns(() => new MockEntity()).Verifiable();

            var provider = new ODataQueryProvider <MockEntity>(n => repository.Object);
            var result   = provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.IsNotNull(result);
        }
        public void ItShouldCountSelectManyOperationsWhenNavigationPropertyIsNotDecorated()
        {
            var navProp = new MockNavigationProperty { Value = "provided" };
            var entity = new MockEntity { NavigationProperties = new[] { navProp } };

            var repository = new Mock<MockeableRepository>();
            repository.Setup(r => r.GetOne(It.Is<ODataSelectOneQueryOperation>(o => o.Key == "key" && o.OfType == typeof(MockEntity))))
                      .Returns(entity);

            var operation = new ODataSelectManyQueryOperation { OfType = typeof(MockEntity), Keys = new Dictionary<string, string> { { "key", "key" } }, NavigationProperty = "NavigationProperties", IsCountRequest = true };

            var provider = new ODataQueryProvider<MockEntity>(n => repository.Object);
            var result = (long)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result, 1);
        }
        public void ItShouldExecuteProjectionEvenWhenItHandlesAll()
        {
            Expression <Func <MockEntity, dynamic> > projectionExpression = e => e == null ? null : new { e.Value };

            var operation = new ODataSelectOneQueryOperation {
                OfType = typeof(MockEntity), Keys = new Dictionary <string, string> {
                    { "key", "key" }
                }, ProjectionExpression = projectionExpression, ProjectedType = typeof(object)
            };
            var provider = new ODataQueryProvider <MockEntity>(n => new HandlesAllRepository(new MockEntity {
                Value = "value"
            }));
            var result = (IEnumerable <object>)provider.ExecuteQuery(operation);

            dynamic item = result.FirstOrDefault();

            Assert.AreEqual(item.Value, "value");
            Assert.IsNotInstanceOfType(result.FirstOrDefault(), typeof(MockEntity));
        }
        public void ItShouldUnwrapTargetOfInvocationExceptions()
        {
            Expression <Func <MockEntity, dynamic> > projectionExpression = e => e == null ? null : new { e.Value };
            var operation = new ODataSelectOneQueryOperation {
                OfType = typeof(MockEntity), Keys = new Dictionary <string, string> {
                    { "key", "not_found" }
                }, ProjectionExpression = projectionExpression, ProjectedType = typeof(object)
            };

            var repository = new Mock <MockeableRepository>();

            repository.Setup(r => r.GetOne(operation)).Throws(new WebException());

            var provider = new ODataQueryProvider <MockEntity>(n => repository.Object);

            provider.ExecuteQuery(operation);

            Assert.Inconclusive();
        }
        internal ODataQuery(ODataQueryProvider <T> provider, Expression expression)
        {
            if (provider == null)
            {
                throw new ArgumentNullException("provider");
            }

            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            if (!typeof(IQueryable <T>).IsAssignableFrom(expression.Type))
            {
                throw new ArgumentOutOfRangeException("expression");
            }

            this._provider   = provider;
            this._expression = expression;
        }
Example #17
0
        public async Task ODataTransformationRepository()
        {
            var odata = new ODataTransformationRepositoryFarm()
                        .Add <ReferenceVM, ReferenceType, ReferenceTypeExtended>()
                        .Create(repository);
            var query = new ODataQueryProvider();

            query.Filter  = "AString eq 'dummy1'";
            query.OrderBy = "Id desc";
            query.Skip    = "0";
            query.Top     = "1";
            var res0 = await odata.ExecuteQuery <ReferenceVM, ReferenceVMExtended>(query);

            Assert.NotNull(res0);
            Assert.Equal(res0.TotalCount, 2);
            Assert.Equal(res0.TotalPages, 2);
            Assert.Equal(res0.Page, 1);
            Assert.NotNull(res0.Data);
            Assert.Equal(res0.Data.Count, 1);
            var el = res0.Data.First();

            Assert.Equal(el.AString, "dummy1");
            query         = new ODataQueryProvider();
            query.Filter  = "AString eq 'dummy1'";
            query.OrderBy = "Id desc";
            query.Skip    = "1";
            query.Top     = "1";
            var res1 = await odata.ExecuteQuery <ReferenceVM, ReferenceVMExtended>(query);

            Assert.NotNull(res1);
            Assert.Equal(res1.TotalCount, 2);
            Assert.Equal(res1.TotalPages, 2);
            Assert.Equal(res1.Page, 2);
            Assert.NotNull(res1.Data);
            Assert.Equal(res1.Data.Count, 1);
            var el1 = res1.Data.First();

            Assert.Equal(el1.AString, "dummy1");
            Assert.True(el.Id.Value > el1.Id.Value);
            Assert.False(el is ReferenceVMExtended);
        }
        public void GroupDetail(string grouping, string result)
        {
            provider.Apply = grouping;
            var res     = provider.Parse <ReferenceType>();
            var allKeys = res.Grouping.Keys;

            provider        = new ODataQueryProvider();
            provider.Filter = result;
            var res1   = provider.Parse <ReferenceType>();
            var filter = res1.AddToUrl("http://dummy.com/");

            object model = new ReferenceType();

            foreach (var key in allKeys)
            {
                res1.GetFilterCondition(typeof(ReferenceType), key, 0, ref model);
            }
            string computedFilter = res.GetGroupDetailUrl(model as ReferenceType, "http://dummy.com/");

            Assert.Equal(computedFilter.Replace("(", "").Replace(")", ""), filter.Replace("(", "").Replace(")", ""));
        }
        public static IEnumerable <KeyValuePair <string, string> > AsODataQueryStringArguments <T>(this IQueryable <T> queryable)
        {
            if (queryable is null)
            {
                throw new ArgumentNullException(nameof(queryable));
            }

            var client = new ArgumentCapturingODataDataClient();
            ODataExpressionConverterSettings settings = ODataExpressionConverterSettings.Default;

            if (queryable.Provider is ODataQueryProvider <T> p)
            {
                settings = p.Settings;
            }

            var provider = new ODataQueryProvider <T>(client, settings);

            provider.Execute(queryable.Expression);

            return(client.QueryStringParamaters);
        }
        public void ItShouldSortUsingLinq2ObjectsImplementationWhenTheRepositoryDoesntProvideIt()
        {
            var entity = new MockEntity
            {
                NavigationProperties = new[]
                {
                    new MockNavigationProperty {
                        Value = "2. provided"
                    },
                    new MockNavigationProperty {
                        Value = "1. provided"
                    }
                }
            };

            var repository = new Mock <MockeableRepository>();

            repository.Setup(r => r.GetOne(It.Is <ODataSelectOneQueryOperation>(o => o.Key == "key" && o.OfType == typeof(MockEntity))))
            .Returns(entity);

            Expression <Func <MockNavigationProperty, string> > order = e => e.Value;

            var operation = new ODataSelectManyQueryOperation
            {
                OfType = typeof(MockEntity),
                Keys   = new Dictionary <string, string> {
                    { "key", "key" }
                },
                NavigationProperty = "NavigationProperties",
                OrderStack         = new Stack <ODataOrderExpression>(new[] { new ODataOrderExpression {
                                                                                  OrderMethodName = "OrderBy", Expression = order
                                                                              } })
            };

            var provider = new ODataQueryProvider <MockEntity>(n => repository.Object);
            var result   = (IEnumerable <dynamic>)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result.First().Value, "1. provided");
        }
Example #21
0
        public async Task ODataRepositoryWithGrouping()
        {
            var odata = new DefaultWebQueryRepository(repository);
            var query = new ODataQueryProvider();

            query.OrderBy = "AString asc";
            query.Apply   = "groupby((AString, AMonth))";
            query.Skip    = "0";
            query.Top     = "100";
            var res0 = await odata.ExecuteQuery <ReferenceType, ReferenceTypeExtended>(query);

            Assert.NotNull(res0);
            Assert.Equal(res0.TotalCount, 2);
            Assert.Equal(res0.TotalPages, 1);
            Assert.Equal(res0.Page, 1);
            Assert.NotNull(res0.Data);
            Assert.Equal(res0.Data.Count, 2);
            var el = res0.Data.First();

            Assert.Equal(el.AString, "dummy1");
            Assert.True(el is ReferenceTypeExtended);
        }
        public void ItShouldPerformLinq2ObjectsFilteringWhenMethodDoesntProvidedOutOfTheBox()
        {
            var entity = new MockEntity
            {
                NavigationProperties = new[]
                {
                    new MockNavigationProperty {
                        Value = "provided_one"
                    },
                    new MockNavigationProperty {
                        Value = "provided_two"
                    }
                }
            };

            var repository = new Mock <MockeableRepository>();

            repository.Setup(r => r.GetOne(It.Is <ODataSelectOneQueryOperation>(o => o.Key == "key" && o.OfType == typeof(MockEntity))))
            .Returns(entity);

            Expression <Func <MockNavigationProperty, bool> > filter = e => e.Value == "provided_one";

            var operation = new ODataSelectManyQueryOperation
            {
                OfType = typeof(MockEntity),
                Keys   = new Dictionary <string, string> {
                    { "key", "key" }
                },
                NavigationProperty = "NavigationProperties",
                FilterExpression   = filter
            };

            var provider = new ODataQueryProvider <MockEntity>(n => repository.Object);
            var result   = (IEnumerable <dynamic>)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result.First().Value, "provided_one");
            Assert.AreEqual(result.Count(), 1);
        }
        public void ItShouldInvokeGetOneForODataGetOneQueryOperationWithProjection()
        {
            var repository = new Mock <MockeableRepository>();

            Expression <Func <MockEntity, dynamic> > projectionExpression = e => e == null ? null : new { e.Value };

            var operation = new ODataSelectOneQueryOperation {
                OfType = typeof(MockEntity), Keys = new Dictionary <string, string> {
                    { "foo", "foo" }
                }, ProjectionExpression = projectionExpression, ProjectedType = typeof(object)
            };

            repository.Setup(r => r.GetOne(operation)).Returns(() => new MockEntity {
                Value = "value"
            }).Verifiable();

            var provider = new ODataQueryProvider <MockEntity>(n => repository.Object);
            var result   = (IEnumerable <object>)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result.Cast <dynamic>().First().Value, "value");
            Assert.IsNotNull(result);
        }
        public void ItShouldExecuteTopWithLinq2ObjectWhenTheUnderlyingMethodDoesntProvideIt()
        {
            var entity = new MockEntity
            {
                NavigationProperties = new[]
                {
                    new MockNavigationProperty {
                        Value = "2. provided"
                    },
                    new MockNavigationProperty {
                        Value = "1. provided"
                    }
                }
            };

            var repository = new Mock <MockeableRepository>();

            repository.Setup(r => r.GetOne(It.Is <ODataSelectOneQueryOperation>(o => o.Key == "key" && o.OfType == typeof(MockEntity))))
            .Returns(entity);

            var operation = new ODataSelectManyQueryOperation
            {
                OfType = typeof(MockEntity),
                Keys   = new Dictionary <string, string> {
                    { "key", "key" }
                },
                NavigationProperty = "NavigationProperties",
                TopCount           = 1
            };

            var provider = new ODataQueryProvider <MockEntity>(n => repository.Object);
            var result   = (IEnumerable <dynamic>)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result.First().Value, "2. provided");
            Assert.AreEqual(result.Count(), 1);
        }
        public void ItShouldRemoteDecoratedCountNavigationProperties()
        {
            var operation = new ODataSelectManyQueryOperation { OfType = typeof(MockEntity), Keys = new Dictionary<string, string> { { "key", "key" } }, NavigationProperty = "RemoteCountedNavigationProperty", IsCountRequest = true };
            var provider = new ODataQueryProvider<MockEntity>(n => new RepositoryStub());
            var result = (long)provider.ExecuteQuery(operation);

            Assert.IsNotNull(result);
            Assert.AreEqual(result, 10);
        }
        public void ItShouldRemoteCountMockEntity2WhenCollectionCountSupportsIt()
        {
            var operation = new ODataQueryOperation { OfType = typeof(MockEntity2), IsCountRequest = true };
            var provider = new ODataQueryProvider<MockEntity>(n => new MockRepository2());
            var result = (long)provider.ExecuteQuery(operation);

            Assert.AreEqual(result, 1);
        }
Example #27
0
 public QueryDescriptionToSql_NestedObjects(DBInitializer init)
 {
     repository = init.Repository;
     provider   = new ODataQueryProvider();
 }
        public void ItShouldPerformLinq2ObjectsFilteringWhenMethodDoesntProvidedOutOfTheBox()
        {
            var entity = new MockEntity
            {
                NavigationProperties = new[]
                {
                    new MockNavigationProperty { Value = "provided_one" },
                    new MockNavigationProperty { Value = "provided_two" }
                }
            };

            var repository = new Mock<MockeableRepository>();
            repository.Setup(r => r.GetOne(It.Is<ODataSelectOneQueryOperation>(o => o.Key == "key" && o.OfType == typeof(MockEntity))))
                      .Returns(entity);

            Expression<Func<MockNavigationProperty, bool>> filter = e => e.Value == "provided_one";

            var operation = new ODataSelectManyQueryOperation
                                {
                                    OfType = typeof(MockEntity),
                                    Keys = new Dictionary<string, string> { { "key", "key" } },
                                    NavigationProperty = "NavigationProperties",
                                    FilterExpression = filter
                                };

            var provider = new ODataQueryProvider<MockEntity>(n => repository.Object);
            var result = (IEnumerable<dynamic>)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result.First().Value, "provided_one");
            Assert.AreEqual(result.Count(), 1);
        }
        public void ItShouldExecuteSkipWithLinq2ObjectWhenTheUnderlyingMethodDoesntProvideIt()
        {
            var entity = new MockEntity
            {
                NavigationProperties = new[]
                {
                    new MockNavigationProperty { Value = "2. provided" },
                    new MockNavigationProperty { Value = "1. provided" }
                }
            };

            var repository = new Mock<MockeableRepository>();
            repository.Setup(r => r.GetOne(It.Is<ODataSelectOneQueryOperation>(o => o.Key == "key" && o.OfType == typeof(MockEntity))))
                      .Returns(entity);

            var operation = new ODataSelectManyQueryOperation
                                {
                                    OfType = typeof(MockEntity),
                                    Keys = new Dictionary<string, string> { { "key", "key" } },
                                    NavigationProperty = "NavigationProperties",
                                    SkipCount = 1
                                };

            var provider = new ODataQueryProvider<MockEntity>(n => repository.Object);
            var result = (IEnumerable<dynamic>)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result.First().Value, "1. provided");
            Assert.AreEqual(result.Count(), 1);
        }
 public ODataQueryProvider_Integration(ITestOutputHelper output)
 {
     provider    = new ODataQueryProvider();
     this.output = output;
 }
Example #31
0
 public QueryDescription_FromSql(ITestOutputHelper output)
 {
     provider    = new ODataQueryProvider();
     this.output = output;
 }
Example #32
0
 internal ODataQueryable(ODataQueryProvider <TType> queryProvider, ODataExpressionConverterSettings settings, Expression expression)
 {
     Provider      = queryProvider;
     Expression    = expression;
     this.settings = settings;
 }
        public void ItShouldNotThrowWhenRepositoryReturnsNullOnGetAll()
        {
            var repository = new Mock<IRepository<MockEntity>>();
            repository.Setup(r => r.GetAll()).Returns(default(MockEntity[]));
            var provider = new ODataQueryProvider<MockEntity>(n => repository.Object);
            var operation = new ODataQueryOperation { OfType = typeof(MockEntity) };
            var result = provider.ExecuteQuery(operation);

            Assert.IsNull(result);
        }
        public void ItShouldSortUsingLinq2ObjectsImplementationWhenTheRepositoryDoesntProvideIt()
        {
            var entity = new MockEntity
            {
                NavigationProperties = new[]
                {
                    new MockNavigationProperty { Value = "2. provided" },
                    new MockNavigationProperty { Value = "1. provided" }
                }
            };

            var repository = new Mock<MockeableRepository>();
            repository.Setup(r => r.GetOne(It.Is<ODataSelectOneQueryOperation>(o => o.Key == "key" && o.OfType == typeof(MockEntity))))
                      .Returns(entity);

            Expression<Func<MockNavigationProperty, string>> order = e => e.Value;

            var operation = new ODataSelectManyQueryOperation
                                {
                                    OfType = typeof(MockEntity),
                                    Keys = new Dictionary<string, string> { { "key", "key" } },
                                    NavigationProperty = "NavigationProperties",
                                    OrderStack = new Stack<ODataOrderExpression>(new[] { new ODataOrderExpression { OrderMethodName = "OrderBy", Expression = order } })
                                };

            var provider = new ODataQueryProvider<MockEntity>(n => repository.Object);
            var result = (IEnumerable<dynamic>)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result.First().Value, "1. provided");
        }
        public void ItShouldUnwrapTargetOfInvocationExceptions()
        {
            Expression<Func<MockEntity, dynamic>> projectionExpression = e => e == null ? null : new { e.Value };
            var operation = new ODataSelectOneQueryOperation { OfType = typeof(MockEntity), Keys = new Dictionary<string, string> { { "key", "not_found" } }, ProjectionExpression = projectionExpression, ProjectedType = typeof(object) };

            var repository = new Mock<MockeableRepository>();
            repository.Setup(r => r.GetOne(operation)).Throws(new WebException());

            var provider = new ODataQueryProvider<MockEntity>(n => repository.Object);
            provider.ExecuteQuery(operation);

            Assert.Inconclusive();
        }
 public ODataQueryProvider_Sorting(ITestOutputHelper output)
 {
     provider    = new ODataQueryProvider();
     this.output = output;
 }
        public void ItShouldExecuteProjectionsOnSelectManyQueryOperation()
        {
            var navProp = new MockNavigationProperty { Value = "provided" };
            var entity = new MockEntity { NavigationProperties = new[] { navProp } };

            var repository = new Mock<MockeableRepository>();
            repository.Setup(r => r.GetOne(It.Is<ODataSelectOneQueryOperation>(o => o.Key == "key" && o.OfType == typeof(MockEntity))))
                      .Returns(entity);

            Expression<Func<MockNavigationProperty, dynamic>> projectionExpression = e => e == null ? null : new { e.Value };

            var operation = new ODataSelectManyQueryOperation
                                {
                                    OfType = typeof(MockEntity),
                                    Keys = new Dictionary<string, string> { { "key", "key" } },
                                    NavigationProperty = "NavigationProperties",
                                    ProjectionExpression = projectionExpression,
                                    ProjectedType = typeof(object)
                                };

            var provider = new ODataQueryProvider<MockEntity>(n => repository.Object);
            var result = (IEnumerable<dynamic>)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result.First().Value, "provided");
        }
        public void ItShouldInvokeGetOneForODataGetOneQueryOperation()
        {
            var repository = new Mock<MockeableRepository>();
            var operation = new ODataSelectOneQueryOperation { OfType = typeof(MockEntity), Keys = new Dictionary<string, string> { { "key", "foo" } } };
            repository.Setup(r => r.GetOne(operation)).Returns(() => new MockEntity()).Verifiable();

            var provider = new ODataQueryProvider<MockEntity>(n => repository.Object);
            var result = provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.IsNotNull(result);
        }
 public QueryDescriptionToSql_Filter(DBInitializer init)
 {
     repository = init.Repository;
     provider   = new ODataQueryProvider();
 }
        public void ItShouldInvokeGetOneForODataGetOneQueryOperationWithProjection()
        {
            var repository = new Mock<MockeableRepository>();

            Expression<Func<MockEntity, dynamic>> projectionExpression = e => e == null ? null : new { e.Value };

            var operation = new ODataSelectOneQueryOperation { OfType = typeof(MockEntity), Keys = new Dictionary<string, string> { { "foo", "foo" } }, ProjectionExpression = projectionExpression, ProjectedType = typeof(object) };
            repository.Setup(r => r.GetOne(operation)).Returns(() => new MockEntity { Value = "value" }).Verifiable();

            var provider = new ODataQueryProvider<MockEntity>(n => repository.Object);
            var result = (IEnumerable<object>)provider.ExecuteQuery(operation);

            repository.VerifyAll();
            Assert.AreEqual(result.Cast<dynamic>().First().Value, "value");
            Assert.IsNotNull(result);
        }