public void CreateCollection_CopmplexType_Succeeds()
        {
            // Arrange
            CustomersModelWithInheritance model  = new CustomersModelWithInheritance();
            ODataQueryOptionParser        parser = new ODataQueryOptionParser(model.Model, model.Customer, model.Customers,
                                                                              new Dictionary <string, string> {
                { "$orderby", "Address/Street desc, Address/City asc, Account/BankAddress/City asc" }
            });

            OrderByClause orderByNode = parser.ParseOrderBy();

            // Act
            ICollection <OrderByNode> nodes = OrderByNode.CreateCollection(orderByNode);

            // Assert
            Assert.Equal(3, nodes.Count());
            Assert.Equal("Street", (nodes.ToList()[0] as OrderByPropertyNode).Property.Name);
            Assert.Equal(OrderByDirection.Descending, nodes.ToList()[0].Direction);
            Assert.Equal("Address/Street", nodes.ToList()[0].PropertyPath);

            Assert.Equal("City", (nodes.ToList()[1] as OrderByPropertyNode).Property.Name);
            Assert.Equal(OrderByDirection.Ascending, nodes.ToList()[1].Direction);
            Assert.Equal("Address/City", nodes.ToList()[1].PropertyPath);

            Assert.Equal("City", (nodes.ToList()[2] as OrderByPropertyNode).Property.Name);
            Assert.Equal(OrderByDirection.Ascending, nodes.ToList()[2].Direction);
            Assert.Equal("Account/BankAddress/City", nodes.ToList()[2].PropertyPath);
        }
        public void CreateCollection_From_OrderByNode_Succeeds()
        {
            // Arrange
            ODataConventionModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataConventionModelBuilder>();

            builder.EntitySet <SampleClass>("entityset");

            IEdmModel      model = builder.GetEdmModel();
            IEdmEntityType sampleClassEntityType = model.SchemaElements.Single(t => t.Name == "SampleClass") as IEdmEntityType;

            Assert.NotNull(sampleClassEntityType); // Guard
            IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("entityset");

            Assert.NotNull(entitySet); // Guard

            ODataQueryOptionParser parser = new ODataQueryOptionParser(model, sampleClassEntityType, entitySet,
                                                                       new Dictionary <string, string> {
                { "$orderby", "Property1 desc, Property2 asc" }
            });
            OrderByClause orderbyNode = parser.ParseOrderBy();

            // Act
            ICollection <OrderByNode> nodes = OrderByNode.CreateCollection(orderbyNode);

            // Assert
            Assert.False(nodes.OfType <OrderByItNode>().Any());
            IEnumerable <OrderByPropertyNode> propertyNodes = nodes.OfType <OrderByPropertyNode>();

            Assert.Equal(2, propertyNodes.Count());
            Assert.Equal("Property1", propertyNodes.First().Property.Name);
            Assert.Equal(OrderByDirection.Descending, propertyNodes.First().Direction);

            Assert.ReferenceEquals("Property2", propertyNodes.Last().Property.Name);
            Assert.Equal(OrderByDirection.Ascending, nodes.Last().Direction);
        }
        public void CreateCollection_PropertyAliased_IfEnabled(bool modelAliasing, string typeName, string propertyName)
        {
            // Arrange
            ODataConventionModelBuilder builder = new ODataConventionModelBuilder {
                ModelAliasingEnabled = modelAliasing
            };

            builder.EntitySet <PropertyAlias>("entityset");

            IEdmModel      model      = builder.GetEdmModel();
            IEdmEntityType entityType = model.SchemaElements.Single(t => t.Name == typeName) as IEdmEntityType;

            Assert.NotNull(entityType); // Guard
            IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("entityset");

            Assert.NotNull(entitySet); // Guard

            ODataQueryOptionParser parser = new ODataQueryOptionParser(model, entityType, entitySet,
                                                                       new Dictionary <string, string> {
                { "$orderby", propertyName + " desc, Id asc" }
            });
            OrderByClause orderbyNode = parser.ParseOrderBy();

            // Act
            ICollection <OrderByNode> nodes = OrderByNode.CreateCollection(orderbyNode);

            // Assert
            Assert.False(nodes.OfType <OrderByItNode>().Any());
            IEnumerable <OrderByPropertyNode> propertyNodes = nodes.OfType <OrderByPropertyNode>();

            Assert.Equal(2, propertyNodes.Count());
            Assert.Equal(propertyName, propertyNodes.First().Property.Name);
            Assert.Equal(OrderByDirection.Descending, propertyNodes.First().Direction);
            Assert.Equal(propertyName, propertyNodes.First().PropertyPath);

            Assert.ReferenceEquals("Id", propertyNodes.Last().Property.Name);
            Assert.Equal(OrderByDirection.Ascending, nodes.Last().Direction);
            Assert.Equal("Id", propertyNodes.Last().PropertyPath);
        }