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());
}
public void SelectSetCorrectly()
{
// Arrange & Act
SelectToken select = new SelectToken(new PathSegmentToken[] { new NonSystemToken("1", null, null) });
ExpandTermToken expandTerm = new ExpandTermToken(new NonSystemToken("stuff", null, null),
null /*filterOption*/,
null /*orderByOption*/,
null /*topOption*/,
null /*skipOption*/,
null /*countQueryOption*/,
null /*levelsOption*/,
null /*searchOption*/,
select,
null /*expandOption*/);
// Assert
Assert.NotNull(expandTerm.SelectOption);
Assert.NotNull(expandTerm.SelectOption.Properties);
Assert.Single(expandTerm.SelectOption.Properties);
Assert.NotNull(expandTerm.SelectOption.SelectTerms);
SelectTermToken selectTerm = Assert.Single(expandTerm.SelectOption.SelectTerms);
selectTerm.PathToProperty.ShouldBeNonSystemToken("1");
}
public void AllNestedQueryOptionsInSelectAreAllowed()
{
// Arrange & Act
SelectTermToken selectTerm = this.ParseSelectOptions("($select=one($select=subone);$filter=true;$count=true;$top=1;$skip=2)");
// Assert
Assert.NotNull(selectTerm);
// $select
Assert.NotNull(selectTerm.SelectOption);
SelectTermToken innerSelectTerms = Assert.Single(selectTerm.SelectOption.SelectTerms);
innerSelectTerms.PathToProperty.ShouldBeNonSystemToken("one");
SelectTermToken innerInnerSelectTerms = Assert.Single(innerSelectTerms.SelectOption.SelectTerms);
innerInnerSelectTerms.PathToProperty.ShouldBeNonSystemToken("subone");
// $filter
Assert.NotNull(selectTerm.FilterOption);
selectTerm.FilterOption.ShouldBeLiteralQueryToken(true);
// $count
Assert.NotNull(selectTerm.CountQueryOption);
Assert.True(selectTerm.CountQueryOption);
// $top
Assert.NotNull(selectTerm.TopOption);
Assert.Equal(1, selectTerm.TopOption);
// $skip
Assert.NotNull(selectTerm.SkipOption);
Assert.Equal(2, selectTerm.SkipOption);
}
public void NestedSearchInSelectIsAllowed(string optionsText)
{
// Arrange & Act
SelectTermToken selectTerm = this.ParseSelectOptions(optionsText);
// Assert
Assert.NotNull(selectTerm.SearchOption);
selectTerm.SearchOption.ShouldBeStringLiteralToken("Searchme");
}
public void NestedTopInSelectIsAllowed(string optionsText)
{
// Arrange & Act
SelectTermToken selectTerm = this.ParseSelectOptions(optionsText);
// Assert
Assert.NotNull(selectTerm);
Assert.NotNull(selectTerm.TopOption);
Assert.Equal(24, selectTerm.TopOption);
}
public void NestedFilterOptionInSelectIsAllowed(string optionsText)
{
// Arrange & Act
SelectTermToken selectTerm = this.ParseSelectOptions(optionsText);
// Assert
Assert.NotNull(selectTerm);
Assert.NotNull(selectTerm.FilterOption);
selectTerm.FilterOption.ShouldBeLiteralQueryToken(true);
}
public void NestedCountInSelectIsAllowed(string optionsText)
{
// Arrange & Act
SelectTermToken selectTerm = this.ParseSelectOptions(optionsText);
// Assert
Assert.NotNull(selectTerm);
Assert.NotNull(selectTerm.CountQueryOption);
Assert.True(selectTerm.CountQueryOption);
}
public void InnerCountSetCorrectly()
{
// Arrange & Act
SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null),
null, null, null, null, false, null, null, null);
// Assert
Assert.NotNull(selectTerm.CountQueryOption);
Assert.False(selectTerm.CountQueryOption);
}
public void InnerSkipSetCorrectly()
{
// Arrange & Act
long skip = 42;
SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null),
null, null, null, skip, null, null, null, null);
// Assert
Assert.NotNull(selectTerm.SkipOption);
Assert.Equal(42, selectTerm.SkipOption);
}
public void NestedOrderbyInSelectIsAllowed(string optionsText)
{
// Arrange & Act
SelectTermToken selectTerm = this.ParseSelectOptions(optionsText);
// Assert
Assert.NotNull(selectTerm);
Assert.NotNull(selectTerm.OrderByOptions);
OrderByToken orderBy = Assert.Single(selectTerm.OrderByOptions);
orderBy.Expression.ShouldBeEndPathToken("two");
}
public void InnerSearchSetCorrectly()
{
// Arrange & Act
SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null),
null, null, null, null, null, new StringLiteralToken("searchMe"), null, null);
// Assert
Assert.NotNull(selectTerm.SearchOption);
StringLiteralToken token = Assert.IsType <StringLiteralToken>(selectTerm.SearchOption);
Assert.Equal("searchMe", token.Text);
}
public void NestedExpandInSelectIsAllowed()
{
// Arrange & Act
SelectTermToken selectTerm = this.ParseSelectOptions("($expand=two)");
// Assert
Assert.NotNull(selectTerm);
Assert.NotNull(selectTerm.ExpandOption);
ExpandTermToken two = Assert.Single(selectTerm.ExpandOption.ExpandTerms);
two.PathToNavigationProp.ShouldBeNonSystemToken("two");
}
public void ParseNestedFilterInSelectWorks()
{
// Arrange & Act
SelectToken selectToken = ParseSelectClause("Address($filter=true)");
// Assert
Assert.NotNull(selectToken);
SelectTermToken selectTermToken = Assert.Single(selectToken.SelectTerms);
selectTermToken.PathToProperty.ShouldBeNonSystemToken("Address");
Assert.NotNull(selectTermToken.FilterOption);
selectTermToken.FilterOption.ShouldBeLiteralQueryToken(true);
}
public void InnerSelectSetCorrectly()
{
// Arrange & Act
SelectToken select = new SelectToken(new PathSegmentToken[] { new NonSystemToken("abc", null, null) });
SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null), select);
// Assert
Assert.NotNull(selectTerm.SelectOption);
PathSegmentToken token = Assert.Single(selectTerm.SelectOption.Properties);
NonSystemToken nonSystemToken = Assert.IsType <NonSystemToken>(token);
Assert.Equal("abc", nonSystemToken.Identifier);
}
public void InnerFilterSetCorrectly()
{
// Arrange & Act
QueryToken filter = new LiteralToken(21);
SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null),
filter, null, null, null, null, null, null, null);
// Assert
Assert.NotNull(selectTerm.FilterOption);
LiteralToken literalToken = Assert.IsType <LiteralToken>(selectTerm.FilterOption);
Assert.Equal(QueryTokenKind.Literal, literalToken.Kind);
Assert.Equal(21, literalToken.Value);
}
public void SelectTermTokenPathIsSet()
{
// Arrange
PathSegmentToken pathToken = new NonSystemToken("SomeProp", null, null);
SelectExpandOptionParser optionParser = new SelectExpandOptionParser(5);
// Act
SelectTermToken selectTermToken = optionParser.BuildSelectTermToken(pathToken, "");
// Assert
Assert.NotNull(selectTermToken);
Assert.NotNull(selectTermToken.PathToProperty);
Assert.Equal("SomeProp", selectTermToken.PathToProperty.Identifier);
}
public void NestedSelectInSelectIsAllowed(string optionsText)
{
// Arrange & Act
SelectTermToken selectTerm = this.ParseSelectOptions(optionsText);
// Assert
Assert.NotNull(selectTerm);
Assert.NotNull(selectTerm.SelectOption);
SelectTermToken[] innerSelectTerms = selectTerm.SelectOption.SelectTerms.ToArray();
Assert.Equal(2, innerSelectTerms.Length);
innerSelectTerms[0].PathToProperty.ShouldBeNonSystemToken("four");
innerSelectTerms[1].PathToProperty.ShouldBeNonSystemToken("five");
}
public void AllNestedOptionsAreNullIfNotPresentInSelect()
{
// Arrange & Act
SelectTermToken selectTerm = this.ParseSelectOptions("");
// Assert
Assert.NotNull(selectTerm);
Assert.Null(selectTerm.FilterOption);
Assert.Null(selectTerm.OrderByOptions);
Assert.Null(selectTerm.TopOption);
Assert.Null(selectTerm.SkipOption);
Assert.Null(selectTerm.CountQueryOption);
Assert.Null(selectTerm.SearchOption);
Assert.Null(selectTerm.SelectOption);
}
public void InnerQueryOptionsCanBeNull()
{
// Arrange & Act
SelectTermToken selectTermToken = new SelectTermToken(new NonSystemToken("stuff", null, null),
null, null, null, null, null, null, null, null);
// Assert
Assert.Null(selectTermToken.FilterOption);
Assert.Null(selectTermToken.OrderByOptions);
Assert.Null(selectTermToken.TopOption);
Assert.Null(selectTermToken.SkipOption);
Assert.Null(selectTermToken.CountQueryOption);
Assert.Null(selectTermToken.SearchOption);
Assert.Null(selectTermToken.SelectOption);
}
public static SelectTermToken ShouldBeSelectTermToken(this QueryToken token, string propertyName, bool checkNullParent)
{
Assert.NotNull(token);
SelectTermToken selectTermToken = Assert.IsType <SelectTermToken>(token);
Assert.Equal(QueryTokenKind.SelectTerm, selectTermToken.Kind);
Assert.Equal(propertyName, selectTermToken.PathToProperty.Identifier);
if (checkNullParent)
{
Assert.Null(selectTermToken.PathToProperty.NextToken);
}
return(selectTermToken);
}
public void ParseNestedTopAndSkipInSelectWorks()
{
// Arrange & Act
SelectToken selectToken = ParseSelectClause("Address($top=2;$skip=4)");
// Assert
Assert.NotNull(selectToken);
SelectTermToken selectTermToken = Assert.Single(selectToken.SelectTerms);
selectTermToken.PathToProperty.ShouldBeNonSystemToken("Address");
Assert.NotNull(selectTermToken.TopOption);
Assert.Equal(2, selectTermToken.TopOption);
Assert.NotNull(selectTermToken.SkipOption);
Assert.Equal(4, selectTermToken.SkipOption);
}
public void ParseOrderByThisInSelectWorks(string queryString, OrderByDirection orderByDirection)
{
// Arrange & Act
SelectToken selectToken = ParseSelectClause(queryString);
// Assert
Assert.NotNull(selectToken);
SelectTermToken selectTermToken = Assert.Single(selectToken.SelectTerms);
selectTermToken.PathToProperty.ShouldBeNonSystemToken("Emails");
Assert.NotNull(selectTermToken.OrderByOptions);
OrderByToken orderBy = Assert.Single(selectTermToken.OrderByOptions);
orderBy.Expression.ShouldBeRangeVariableToken("$this");
Assert.Equal(orderByDirection, orderBy.Direction);
}
public void InnerExpandSetCorrectly()
{
// Arrange & Act
ExpandTermToken innerExpandTerm = new ExpandTermToken(new NonSystemToken("abc", null, null), null, null);
ExpandToken expand = new ExpandToken(new[] { innerExpandTerm });
SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null), null, expand);
// Assert
Assert.NotNull(selectTerm.ExpandOption);
ExpandTermToken token = Assert.Single(selectTerm.ExpandOption.ExpandTerms);
ReferenceEquals(token.PathToNavigationProp, token.PathToProperty);
Assert.Equal("abc", token.PathToProperty.Identifier);
}
public void InnerQueryOptionsPropertySetCorrectly()
{
// Arrange & Act
SelectTermToken selectTermToken1 = new SelectTermToken(new NonSystemToken("stuff", null, null));
SelectTermToken selectTermToken2 = new SelectTermToken(new NonSystemToken("stuff", null, null), null);
// Assert
Assert.NotNull(selectTermToken1.PathToProperty);
NonSystemToken nonSystemToken = Assert.IsType <NonSystemToken>(selectTermToken1.PathToProperty);
Assert.Equal("stuff", nonSystemToken.Identifier);
Assert.NotNull(selectTermToken2.PathToProperty);
nonSystemToken = Assert.IsType <NonSystemToken>(selectTermToken2.PathToProperty);
Assert.Equal("stuff", nonSystemToken.Identifier);
}
[InlineData("($expand=two($expand=three;);)")] // Deep nested expands with semicolon
public void DeepNestedExpandsInSelectAreAllowed(string optionsText)
{
// Arrange & Act
SelectTermToken selectTerm = this.ParseSelectOptions(optionsText);
// Assert
Assert.NotNull(selectTerm);
Assert.NotNull(selectTerm.ExpandOption);
ExpandTermToken two = Assert.Single(selectTerm.ExpandOption.ExpandTerms);
two.PathToNavigationProp.ShouldBeNonSystemToken("two");
ExpandTermToken three = Assert.Single(two.ExpandOption.ExpandTerms);
three.PathToNavigationProp.ShouldBeNonSystemToken("three");
}
public void ParseNestedOrderByAndSearchInSelectWorks()
{
// Arrange & Act
SelectToken selectToken = ParseSelectClause("Address($orderby=abc;$search=xyz)");
// Assert
Assert.NotNull(selectToken);
SelectTermToken selectTermToken = Assert.Single(selectToken.SelectTerms);
selectTermToken.PathToProperty.ShouldBeNonSystemToken("Address");
Assert.NotNull(selectTermToken.OrderByOptions);
OrderByToken orderBy = Assert.Single(selectTermToken.OrderByOptions);
orderBy.Expression.ShouldBeEndPathToken("abc");
Assert.NotNull(selectTermToken.SearchOption);
selectTermToken.SearchOption.ShouldBeStringLiteralToken("xyz");
}
public void InnerComputeSetCorrectly()
{
// Arrange & Act
ComputeToken compute = new ComputeToken(new ComputeExpressionToken[] { });
SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null),
null /*filterOption*/,
null /*orderByOption*/,
null /*topOption*/,
null /*skipOption*/,
null /*countQueryOption*/,
null /*searchOption*/,
null /*selectOption*/,
compute);
// Assert
Assert.NotNull(selectTerm.ComputeOption);
Assert.Same(compute, selectTerm.ComputeOption);
}
public void InnerOrderBySetCorrectly()
{
// Arrange & Act
OrderByToken orderBy = new OrderByToken(new LiteralToken(42), OrderByDirection.Descending);
SelectTermToken selectTerm = new SelectTermToken(new NonSystemToken("stuff", null, null),
null, new OrderByToken[] { orderBy }, null, null, null, null, null, null);
// Assert
Assert.NotNull(selectTerm.OrderByOptions);
OrderByToken expectedOrderBy = Assert.Single(selectTerm.OrderByOptions);
Assert.Equal(QueryTokenKind.OrderBy, expectedOrderBy.Kind);
Assert.NotNull(expectedOrderBy.Expression);
LiteralToken literalToken = Assert.IsType <LiteralToken>(expectedOrderBy.Expression);
Assert.Equal(QueryTokenKind.Literal, literalToken.Kind);
Assert.Equal(42, literalToken.Value);
}
public void ParseNestedSelectInSelectWorks()
{
// Arrange & Act
SelectToken selectToken = ParseSelectClause("Address($select=abc,xyz)");
// Assert
Assert.NotNull(selectToken);
SelectTermToken selectTermToken = Assert.Single(selectToken.SelectTerms);
selectTermToken.PathToProperty.ShouldBeNonSystemToken("Address");
Assert.NotNull(selectTermToken.SelectOption);
Assert.Equal(2, selectTermToken.SelectOption.SelectTerms.Count());
SelectTermToken nestedSelectTermToken = selectTermToken.SelectOption.SelectTerms.First();
nestedSelectTermToken.PathToProperty.ShouldBeNonSystemToken("abc");
nestedSelectTermToken = selectTermToken.SelectOption.SelectTerms.Last();
nestedSelectTermToken.PathToProperty.ShouldBeNonSystemToken("xyz");
}
public void SelectedAndExpandedNavPropProduceExpandedNavPropSelectionItemAndPathSelectionItem()
{
// Arrange: $select=MyDog&$expand=MyDog
ExpandTermToken innerExpandTermToken = new ExpandTermToken(new NonSystemToken("MyDog", null, null));
ExpandToken expandToken = new ExpandToken(new ExpandTermToken[] { innerExpandTermToken });
SelectTermToken innerSelectTermToken = new SelectTermToken(new NonSystemToken("MyDog", null, null));
SelectToken selectToken = new SelectToken(new SelectTermToken[] { innerSelectTermToken });
// Act
SelectExpandClause clause = BinderForPerson.Bind(expandToken, selectToken);
// Assert
Assert.NotNull(clause);
Assert.False(clause.AllSelected);
Assert.Equal(2, clause.SelectedItems.Count());
clause.SelectedItems.First().ShouldBeExpansionFor(HardCodedTestModel.GetPersonMyDogNavProp());
clause.SelectedItems.Last().ShouldBePathSelectionItem(new ODataPath(new NavigationPropertySegment(HardCodedTestModel.GetPersonMyDogNavProp(), HardCodedTestModel.GetPeopleSet())));
}
