public void Bind_GeneratedExpression_ContainsExpandedObject()
        {
            // Arrange
            SelectExpandQueryOption selectExpand = new SelectExpandQueryOption("Orders", "Orders,Orders($expand=Customer)", _context);
            IPropertyMapper         mapper       = new IdentityPropertyMapper();

            _model.Model.SetAnnotationValue(_model.Order, new DynamicPropertyDictionaryAnnotation(typeof(Order).GetProperty("OrderProperties")));

            // Act
            IQueryable queryable = SelectExpandBinder.Bind(_queryable, _settings, new DefaultAssembliesResolver(), selectExpand);

            // Assert
            IEnumerator enumerator = queryable.GetEnumerator();

            Assert.True(enumerator.MoveNext());
            var partialCustomer = Assert.IsAssignableFrom <SelectExpandWrapper <Customer> >(enumerator.Current);

            Assert.False(enumerator.MoveNext());
            Assert.Null(partialCustomer.Instance);
            IEnumerable <SelectExpandWrapper <Order> > innerOrders = partialCustomer.Container
                                                                     .ToDictionary(mapper)["Orders"] as IEnumerable <SelectExpandWrapper <Order> >;

            Assert.NotNull(innerOrders);
            SelectExpandWrapper <Order> partialOrder = innerOrders.Single();

            Assert.Same(_queryable.First().Orders.First(), partialOrder.Instance);
            object customer = partialOrder.Container.ToDictionary(mapper)["Customer"];
            SelectExpandWrapper <Customer> innerInnerCustomer = Assert.IsAssignableFrom <SelectExpandWrapper <Customer> >(customer);

            Assert.Same(_queryable.First(), innerInnerCustomer.Instance);
        }
        public void Bind_GeneratedExpression_DelegateCachingEnabled()
        {
            // Arrange
            SelectExpandQueryOption selectExpand = new SelectExpandQueryOption("Orders", "Orders,Orders($expand=Customer)", _context);
            IPropertyMapper         mapper       = new IdentityPropertyMapper();

            _model.Model.SetAnnotationValue(_model.Order, new DynamicPropertyDictionaryAnnotation(typeof(Order).GetProperty("OrderProperties")));
            var oldCacheExpirationTime = _settings.SelectExpandCacheExpirationTimeSeconds;

            SelectExpandBinder.ResetCache();
            _settings.SelectExpandCacheExpirationTimeSeconds = 10;

            // Act
            object result = SelectExpandBinder.Bind(_customer, _settings, selectExpand);

            // Assert
            Assert.Equal(SelectExpandBinder.DelegateCache.GetCount(), 1);
            KeyValuePair <string, object> cachedKeyValuePair = SelectExpandBinder.DelegateCache.First();

            Assert.IsAssignableFrom(typeof(Delegate), cachedKeyValuePair.Value);

            // Cleanup
            _settings.SelectExpandCacheExpirationTimeSeconds = oldCacheExpirationTime;
            SelectExpandBinder.ResetCache();
        }
        public static object Bind(object entity, ODataQuerySettings settings, SelectExpandQueryOption selectExpandQuery)
        {
            Contract.Assert(entity != null);

            SelectExpandBinder binder = new SelectExpandBinder(settings, selectExpandQuery);

            return(binder.Bind(entity));
        }
        public static IQueryable Bind(IQueryable queryable, ODataQuerySettings settings, SelectExpandQueryOption selectExpandQuery)
        {
            Contract.Assert(queryable != null);

            SelectExpandBinder binder = new SelectExpandBinder(settings, selectExpandQuery);

            return(binder.Bind(queryable));
        }
        public void Bind_ReturnsIEdmObject_WithRightEdmType()
        {
            // Arrange
            SelectExpandQueryOption selectExpand = new SelectExpandQueryOption(select: "ID", expand: null, context: _context);

            // Act
            IQueryable queryable = SelectExpandBinder.Bind(_queryable, _settings, new DefaultAssembliesResolver(), selectExpand);

            // Assert
            Assert.NotNull(queryable);
            IEdmTypeReference edmType = _model.Model.GetEdmTypeReference(queryable.GetType());

            Assert.NotNull(edmType);
            Assert.True(edmType.IsCollection());
            Assert.Same(_model.Customer, edmType.AsCollection().ElementType().Definition);
        }
Exemple #6
0
        public void Bind_GeneratedExpression_CheckNullObjectWithinChainProjectionByKey()
        {
            // Arrange
            SelectExpandQueryOption selectExpand = new SelectExpandQueryOption(null, "Orders($expand=Customer($select=City))", _context);

            _model.Model.SetAnnotationValue(_model.Order, new DynamicPropertyDictionaryAnnotation(typeof(Order).GetProperty("OrderProperties")));

            // Act
            IQueryable queryable = SelectExpandBinder.Bind(_queryable, _settings, selectExpand);

            // Assert
            var unaryExpression  = (UnaryExpression)((MethodCallExpression)queryable.Expression).Arguments.Single(a => a is UnaryExpression);
            var expressionString = unaryExpression.Operand.ToString();

            Assert.Contains("IsNull = (Convert(Param_1.Customer.ID) == null)", expressionString);
        }