public void NormalizeTreeWorksForMultipleTerms()
        {
            // Arrange: $select=1/2/3,4/5/6
            NonSystemToken endPath1 = new NonSystemToken("3", null, new NonSystemToken("2", null, new NonSystemToken("1", null, null)));

            Assert.Equal("3/2/1", endPath1.ToPathString());

            NonSystemToken endPath2 = new NonSystemToken("6", null, new NonSystemToken("5", null, new NonSystemToken("4", null, null)));

            Assert.Equal("6/5/4", endPath2.ToPathString());

            // Act
            SelectToken selectToken = new SelectToken(new SelectTermToken[]
            {
                new SelectTermToken(endPath1), new SelectTermToken(endPath2)
            });
            SelectToken normalizedToken = SelectTreeNormalizer.NormalizeSelectTree(selectToken);

            // Assert
            List <PathSegmentToken> tokens = normalizedToken.Properties.ToList();

            Assert.Equal(2, tokens.Count);

            tokens[0].ShouldBeNonSystemToken("1")
            .NextToken.ShouldBeNonSystemToken("2")
            .NextToken.ShouldBeNonSystemToken("3");
            Assert.Equal("1/2/3", tokens[0].ToPathString());

            tokens[1].ShouldBeNonSystemToken("4")
            .NextToken.ShouldBeNonSystemToken("5")
            .NextToken.ShouldBeNonSystemToken("6");
            Assert.Equal("4/5/6", tokens[1].ToPathString());
        }
        public void NormalizeTreeResultsInReversedPath()
        {
            // Arrange: $select=1/2/3
            NonSystemToken endPath = new NonSystemToken("3", null, new NonSystemToken("2", null, new NonSystemToken("1", null, null)));

            Assert.Equal("3/2/1", endPath.ToPathString());

            SelectToken selectToken = new SelectToken(new SelectTermToken[]
            {
                new SelectTermToken(endPath)
            });

            // Act
            SelectToken normalizedToken = SelectTreeNormalizer.NormalizeSelectTree(selectToken);

            // Assert
            Assert.NotNull(normalizedToken);
            SelectTermToken  updatedSegmentToken = Assert.Single(normalizedToken.SelectTerms);
            PathSegmentToken segmentToken        = updatedSegmentToken.PathToProperty;

            segmentToken.ShouldBeNonSystemToken("1")
            .NextToken.ShouldBeNonSystemToken("2")
            .NextToken.ShouldBeNonSystemToken("3");

            Assert.Equal("1/2/3", segmentToken.ToPathString());
        }
Exemple #3
0
        /// <summary>
        /// Add semantic meaning to a Select or Expand Token
        /// </summary>
        /// <param name="elementType">the top level entity type.</param>
        /// <param name="entitySet">the top level entity set</param>
        /// <param name="expandToken">the syntactically parsed expand token</param>
        /// <param name="selectToken">the syntactically parsed select token</param>
        /// <param name="configuration">The configuration to use for parsing.</param>
        /// <returns>A select expand clause bound to metadata.</returns>
        public static SelectExpandClause Parse(
            IEdmEntityType elementType,
            IEdmEntitySet entitySet,
            ExpandToken expandToken,
            SelectToken selectToken,
            ODataUriParserConfiguration configuration)
        {
            expandToken = ExpandTreeNormalizer.NormalizeExpandTree(expandToken);
            selectToken = SelectTreeNormalizer.NormalizeSelectTree(selectToken);

            ExpandBinder       expandBinder = ExpandBinderFactory.Create(elementType, entitySet, configuration);
            SelectExpandClause clause       = expandBinder.Bind(expandToken);

            SelectBinder selectedPropertyBinder = new SelectBinder(configuration.Model, elementType, configuration.Settings.SelectExpandLimit, clause);

            clause = selectedPropertyBinder.Bind(selectToken);

            var prunedTree = SelectExpandTreeFinisher.PruneSelectExpandTree(clause);

            prunedTree.ComputeFinalSelectedItems();

            new ExpandDepthAndCountValidator(configuration.Settings.MaximumExpansionDepth, configuration.Settings.MaximumExpansionCount).Validate(prunedTree);

            return(prunedTree);
        }
Exemple #4
0
        public void NormalizeTreeResultsInReversedPath()
        {
            // $select=1/2/3
            NonSystemToken endPath         = new NonSystemToken("3", null, new NonSystemToken("2", null, new NonSystemToken("1", null, null)));
            SelectToken    selectToken     = new SelectToken(new NonSystemToken[] { endPath });
            SelectToken    normalizedToken = SelectTreeNormalizer.NormalizeSelectTree(selectToken);

            normalizedToken.Properties.Single().ShouldBeNonSystemToken("1")
            .NextToken.ShouldBeNonSystemToken("2")
            .NextToken.ShouldBeNonSystemToken("3");
        }
Exemple #5
0
        public void NormalizeTreeWorksForMultipleTerms()
        {
            // $select=1/2/3,4/5/6
            NonSystemToken          endPath         = new NonSystemToken("3", null, new NonSystemToken("2", null, new NonSystemToken("1", null, null)));
            NonSystemToken          endPath1        = new NonSystemToken("6", null, new NonSystemToken("5", null, new NonSystemToken("4", null, null)));
            SelectToken             selectToken     = new SelectToken(new NonSystemToken[] { endPath, endPath1 });
            SelectToken             normalizedToken = SelectTreeNormalizer.NormalizeSelectTree(selectToken);
            List <PathSegmentToken> tokens          = normalizedToken.Properties.ToList();

            tokens.Should().HaveCount(2);
            tokens.ElementAt(0).ShouldBeNonSystemToken("1")
            .NextToken.ShouldBeNonSystemToken("2")
            .NextToken.ShouldBeNonSystemToken("3");
            tokens.ElementAt(1).ShouldBeNonSystemToken("4")
            .NextToken.ShouldBeNonSystemToken("5")
            .NextToken.ShouldBeNonSystemToken("6");
        }
Exemple #6
0
        public void NormalizeSelectTreeThrowsForMultipleTermsWithSameSelectPath()
        {
            // Arrange: $select=1($count=true), 1($count=false)
            List <SelectTermToken> selectTerms = new List <SelectTermToken>();

            selectTerms.Add(new SelectTermToken(new NonSystemToken("1", /*namedValues*/ null, /*nextToken*/ null),
                                                null, null, null, null, true, null, null, null));

            selectTerms.Add(new SelectTermToken(new NonSystemToken("1", /*namedValues*/ null, /*nextToken*/ null),
                                                null, null, null, null, false, null, null, null));

            SelectToken select = new SelectToken(selectTerms);

            // Act
            Action test = () => SelectTreeNormalizer.NormalizeSelectTree(select);

            // Assert
            ODataException exception = Assert.Throws <ODataException>(test);

            Assert.Equal("Found mutliple select terms with same select path '1' at one $select, please combine them together.", exception.Message);
        }