/// <inheritdoc/>
public override bool TryMatch(ODataPathSegment pathSegment, IDictionary <string, object> values)
{
DynamicPathSegment other = pathSegment as DynamicPathSegment;
if (other == null)
{
return(false);
}
// If we're treating the property name as a parameter store the provided name in our values collection
// using the name from the template as the key.
if (TreatPropertyNameAsParameterName)
{
values[PropertyName] = other.Identifier;
values[ODataParameterValue.ParameterValuePrefix + PropertyName] =
new ODataParameterValue(other.Identifier,
EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(typeof(string)));
return(true);
}
if (PropertyName == other.Identifier)
{
return(true);
}
return(false);
}
public void TranslateWithDynamicPathSegmentReturnsFalse()
{
IsCollectionTranslator translator = new IsCollectionTranslator();
var segment = new DynamicPathSegment("test");
translator.Translate(segment).Should().BeFalse();
}
public void EqualityIsCorrect()
{
DynamicPathSegment openPropertySegment1 = new DynamicPathSegment("superbeans");
DynamicPathSegment openPropertySegment2 = new DynamicPathSegment("superbeans");
openPropertySegment1.Equals(openPropertySegment2).Should().BeTrue();
}
public void TranslateWithDynamicPathSegmentReturnsFalse()
{
IsCollectionTranslator translator = new IsCollectionTranslator();
var segment = new DynamicPathSegment("test");
Assert.False(translator.Translate(segment));
}
public async Task VisitAsync(ODataPath path)
{
NotFound = false;
BadRequest = false;
Result = null;
ResultType = null;
PropertySetter = null;
Index = 0;
foreach (var segment in path)
{
await(segment switch
{
TypeSegment typeSegment => VisitAsync(typeSegment),
NavigationPropertySegment navigationPropertySegment => VisitAsync(navigationPropertySegment),
EntitySetSegment entitySetSegment => VisitAsync(entitySetSegment),
SingletonSegment singletonSegment => VisitAsync(singletonSegment),
KeySegment keySegment => VisitAsync(keySegment),
PropertySegment propertySegment => VisitAsync(propertySegment),
AnnotationSegment annotationSegment => VisitAsync(annotationSegment),
OperationImportSegment operationImportSegment => VisitAsync(operationImportSegment),
OperationSegment operationSegment => VisitAsync(operationSegment),
DynamicPathSegment dynamicPathSegment => VisitAsync(dynamicPathSegment),
CountSegment countSegment => VisitAsync(countSegment),
FilterSegment filterSegment => VisitAsync(filterSegment),
ReferenceSegment referenceSegment => VisitAsync(referenceSegment),
EachSegment eachSegment => VisitAsync(eachSegment),
NavigationPropertyLinkSegment navigationPropertyLinkSegment => VisitAsync(navigationPropertyLinkSegment),
ValueSegment valueSegment => VisitAsync(valueSegment),
BatchSegment batchSegment => VisitAsync(batchSegment),
BatchReferenceSegment batchReferenceSegment => VisitAsync(batchReferenceSegment),
MetadataSegment metadataSegment => VisitAsync(metadataSegment),
PathTemplateSegment pathTemplateSegment => VisitAsync(pathTemplateSegment),
_ => throw new NotSupportedException()
});
public void TryTranslatePathTemplateSegmentTemplate_ReturnsDynamicPathSegment()
{
// Arrange
RouteValueDictionary routeValueDictionary = new RouteValueDictionary(new { dynamicproperty = "Dynamic" });
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext
{
RouteValues = routeValueDictionary
};
context.Segments.Add(new MySegment(_entityType));
PathTemplateSegment segment = new PathTemplateSegment("{dynamicproperty}");
PathTemplateSegmentTemplate pathSegment = new PathTemplateSegmentTemplate(segment);
// Act
Assert.True(pathSegment.TryTranslate(context));
// Assert
Assert.Equal(2, context.Segments.Count); // 1 - MySegment, 2 - Property Segment
Assert.Collection(context.Segments,
e =>
{
Assert.IsType <MySegment>(e);
},
e =>
{
DynamicPathSegment dynamicSegment = Assert.IsType <DynamicPathSegment>(e);
Assert.Equal("Dynamic", dynamicSegment.Identifier);
});
}
/// <inheritdoc />
public override bool TryTranslate(ODataTemplateTranslateContext context)
{
if (context == null)
{
throw Error.ArgumentNull(nameof(context));
}
// {property}
if (ParameterName == "property")
{
ODataPathSegment previous = context.Segments.LastOrDefault();
ODataPathSegment property = CreatePropertySegment(previous, context);
if (property != null)
{
context.Segments.Add(property);
return(true);
}
}
else if (ParameterName == "dynamicproperty")
{
// {dynamicproperty}
ODataPathSegment previous = context.Segments.LastOrDefault();
DynamicPathSegment dynamicSeg = CreateDynamicSegment(previous, context);
if (dynamicSeg != null)
{
context.Segments.Add(dynamicSeg);
return(true);
}
}
return(false);
}
private ODataUriParser ParseDynamicPathSegmentFunc_ReturnDynamicPathSegment_WithCollectionReturnType(Uri fullUri, out ODataPath odataPath, ODataUrlKeyDelimiter uriConventions = null)
{
var container = ContainerBuilderHelper.BuildContainer(builder => builder.AddService <UriPathParser, SingleSegmentUriPathParser>(ServiceLifetime.Scoped));
var uriParser = new ODataUriParser(oneDriveModel, ServiceRoot, fullUri, container);
if (uriConventions != null)
{
uriParser.UrlKeyDelimiter = uriConventions;
}
var operation = oneDriveModel.SchemaElements.OfType <IEdmOperation>().FirstOrDefault(o => o.Name == "recent");
uriParser.ParseDynamicPathSegmentFunc = (previous, identifier, parenthesisExpression) =>
{
var dynamicPathSeg = new DynamicPathSegment(identifier, operation.ReturnType.Definition, containedItemsNav, false);
var segments = new List <ODataPathSegment>
{
dynamicPathSeg
};
if (parenthesisExpression != null)
{
segments.Add(new KeySegment(dynamicPathSeg, new Dictionary <string, object>()
{
{ "id", parenthesisExpression.Trim('\'') }
}, itemType, null));
}
return(segments);
};
odataPath = uriParser.ParsePath();
return(uriParser);
}
public void EqualityIsCorrect_withTypeInfo()
{
DynamicPathSegment segment1 = new DynamicPathSegment("superbeans", HardCodedTestModel.GetPersonType(), null, true);
DynamicPathSegment segment2 = new DynamicPathSegment("superbeans", HardCodedTestModel.GetPersonType(), null, true);
Assert.True(segment1.Equals(segment2));
}
public void EqualityIsCorrect_withNavigationSourceInfo()
{
DynamicPathSegment segment1 = new DynamicPathSegment("superbeans", HardCodedTestModel.GetPersonType(), HardCodedTestModel.GetPeopleSet(), true);
DynamicPathSegment segment2 = new DynamicPathSegment("superbeans", HardCodedTestModel.GetPersonType(), HardCodedTestModel.GetPeopleSet(), true);
Assert.True(segment1.Equals(segment2));
}
/// <summary>
/// Translate OpenPropertySegment to linq expression.
/// </summary>
/// <param name="segment">The OpenPropertySegment</param>
/// <returns>The linq expression</returns>
public override Expression Translate(DynamicPathSegment segment)
{
if (!(this.LastProcessedSegment is KeySegment ||
this.LastProcessedSegment is SingletonSegment ||
this.LastProcessedSegment is NavigationPropertySegment ||
this.LastProcessedSegment is PropertySegment ||
this.LastProcessedSegment is TypeSegment))
{
throw new InvalidOperationException("Unsupported URI segment before PropertySegment");
}
// get OpenProperties
var propertyAccessExpression = Expression.Property(this.ResultExpression, "OpenProperties");
// key
var key = Expression.Constant(segment.Identifier, typeof(string));
// OpenProperties.ContainsKey(segment.PropertyName)
MethodInfo containsKeyMethod = typeof(Dictionary <string, object>).GetMethod("ContainsKey", new[] { typeof(string) });
var containsExpression = Expression.Call(propertyAccessExpression, containsKeyMethod, key);
//OpenProperties[segment.PropertyName]
var queryOpenPropertyExpression = Expression.Property(propertyAccessExpression, "Item", key);
this.ResultExpression = Expression.Condition(containsExpression, queryOpenPropertyExpression, Expression.Constant(null));
this.LastProcessedSegment = segment;
return(this.ResultExpression);
}
public void EqualityIsCorrect()
{
DynamicPathSegment openPropertySegment1 = new DynamicPathSegment("superbeans");
DynamicPathSegment openPropertySegment2 = new DynamicPathSegment("superbeans");
Assert.True(openPropertySegment1.Equals(openPropertySegment2));
}
/// <summary>
/// Handle a OpenPropertySegment
/// </summary>
/// <param name="segment">the segment to Handle</param>
public override void Handle(DynamicPathSegment segment)
{
Contract.Assert(segment != null);
_navigationSource = null;
_pathUriLiteral.Add(segment.Identifier);
}
/// <summary>
/// Handle a OpenPropertySegment
/// </summary>
/// <param name="segment">the segment to Handle</param>
public override void Handle(DynamicPathSegment segment)
{
_navigationSource = null;
_pathTemplate.Add(ODataSegmentKinds.DynamicProperty); // dynamic property
_pathUriLiteral.Add(segment.Identifier);
}
public static DynamicPathSegment ShouldBeDynamicPathSegment(this ODataPathSegment segment, string identifier)
{
Assert.NotNull(segment);
DynamicPathSegment openPropertySegment = Assert.IsType <DynamicPathSegment>(segment);
Assert.Equal(identifier, openPropertySegment.Identifier);
return(openPropertySegment);
}
public static AndConstraint <DynamicPathSegment> ShouldBeDynamicPathSegment(this ODataPathSegment segment, string identifier)
{
segment.Should().BeOfType <DynamicPathSegment>();
DynamicPathSegment openPropertySegment = segment.As <DynamicPathSegment>();
openPropertySegment.Identifier.Should().Be(identifier);
return(new AndConstraint <DynamicPathSegment>(openPropertySegment));
}
public static string ToUriLiteral(this DynamicPathSegment segment)
{
if (segment == null)
{
throw Error.ArgumentNull("segment");
}
return(segment.Identifier);
}
public void TryTranslateDynamicSegmentTemplate_ThrowsArgumentNull_Context()
{
// Arrange
DynamicPathSegment segment = new DynamicPathSegment("dynamic");
DynamicSegmentTemplate dynamicSegment = new DynamicSegmentTemplate(segment);
// Act & Assert
ExceptionAssert.ThrowsArgumentNull(() => dynamicSegment.TryTranslate(null), "context");
}
public void CtorDynamicSegmentTemplate_SetsProperties()
{
// Arrange & Act
DynamicPathSegment segment = new DynamicPathSegment("dynamic");
DynamicSegmentTemplate dynamicSegment = new DynamicSegmentTemplate(segment);
// Assert
Assert.Same(segment, dynamicSegment.Segment);
}
public void GetTemplatesDynamicSegmentTemplate_ReturnsTemplates()
{
// Arrange
DynamicPathSegment segment = new DynamicPathSegment("dynamic");
DynamicSegmentTemplate dynamicSegment = new DynamicSegmentTemplate(segment);
// Act & Assert
IEnumerable <string> templates = dynamicSegment.GetTemplates();
string template = Assert.Single(templates);
Assert.Equal("/dynamic", template);
}
public void ODataPathSegmentHandler_Handles_DynamicPathSegment()
{
// Arrange
ODataPathSegmentHandler handler = new ODataPathSegmentHandler();
DynamicPathSegment segment = new DynamicPathSegment("any");
// Act
handler.Handle(segment);
// Assert
Assert.Equal("any", handler.PathLiteral);
Assert.Null(handler.NavigationSource);
}
public void ODataPathSegmentToTemplateHandler_Handles_DynamicPath()
{
// Arrange
ODataPathSegmentToTemplateHandler handler = new ODataPathSegmentToTemplateHandler(null);
DynamicPathSegment segment = new DynamicPathSegment("any");
// Act
handler.Handle(segment);
// Assert
ODataSegmentTemplate segmentTemplate = Assert.Single(handler.Templates);
Assert.IsType <DynamicSegmentTemplate>(segmentTemplate);
}
public void TryMatch_ConditionalWhenPropertyName(bool isSamePropertyName, string propertName)
{
// Arrange
DynamicSegmentTemplate template = new DynamicSegmentTemplate(new DynamicPathSegment("matchingproperty"));
DynamicPathSegment segment = new DynamicPathSegment(propertName);
// Act
Dictionary <string, object> values = new Dictionary <string, object>();
bool result = template.TryMatch(segment, values);
// Assert
Assert.Equal(isSamePropertyName, result);
Assert.False(values.ContainsKey("matchingproperty"));
}
public override void Handle(DynamicPathSegment segment)
{
this.ThrowIfResolved();
this.NavigationSource = null;
this.Property = new EdmOpenStructuralProperty(segment.Identifier);
this.Type = segment.EdmType;
this.ElementType = this.GetElementType(this.Type);
this.PushParentSegment();
this.childSegments.Add(segment);
this.canonicalSegments.Add(segment);
}
public void TryMatch_AlwaysTrueWhenParameterName()
{
// Arrange
DynamicSegmentTemplate template = new DynamicSegmentTemplate(new DynamicPathSegment("{parameter}"));
DynamicPathSegment segment = new DynamicPathSegment("property");
// Act
Dictionary <string, object> values = new Dictionary <string, object>();
bool result = template.TryMatch(segment, values);
// Assert
Assert.True(result);
Assert.True(values.ContainsKey("parameter"));
Assert.Equal("property", values["parameter"]);
}
public void TryMatch_RetrunsTrue()
{
// Arrange
PathTemplateSegment pathTemplateSegment = new PathTemplateSegment("{pName:dynamicproperty}");
PathTemplateSegmentTemplate template = new PathTemplateSegmentTemplate(pathTemplateSegment);
DynamicPathSegment segment = new DynamicPathSegment("property");
// Act
Dictionary <string, object> values = new Dictionary <string, object>();
bool result = template.TryMatch(segment, values);
// Assert
Assert.True(result);
Assert.True(values.ContainsKey("pName"));
Assert.Equal("property", values["pName"]);
}
public void TryTranslateDynamicSegmentTemplate_ReturnsODataCountSegment()
{
// Arrange
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext();
DynamicPathSegment segment = new DynamicPathSegment("dynamic");
DynamicSegmentTemplate dynamicSegment = new DynamicSegmentTemplate(segment);
// Act
bool ok = dynamicSegment.TryTranslate(context);
// Assert
Assert.True(ok);
ODataPathSegment actual = Assert.Single(context.Segments);
DynamicPathSegment actualSegment = Assert.IsType <DynamicPathSegment>(actual);
Assert.Same(segment, actualSegment);
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicSegmentTemplate"/> class.
/// </summary>
/// <param name="segment">The open property segment</param>
public DynamicSegmentTemplate(DynamicPathSegment segment)
{
Segment = segment ?? throw new ArgumentNullException(nameof(segment));
PropertyName = segment.Identifier;
TreatPropertyNameAsParameterName = false;
if (IsRouteParameter(PropertyName))
{
PropertyName = PropertyName.Substring(1, PropertyName.Length - 2);
TreatPropertyNameAsParameterName = true;
if (string.IsNullOrEmpty(PropertyName))
{
throw new ODataException(
Error.Format(SRResources.EmptyParameterAlias, PropertyName, segment.Identifier));
}
}
}
public void InequalityIsCorrect()
{
DynamicPathSegment segment1 = new DynamicPathSegment("superbeans");
DynamicPathSegment segment2 = new DynamicPathSegment("incredibeans");
DynamicPathSegment segment3 = new DynamicPathSegment("superbeans", HardCodedTestModel.GetPersonType(), HardCodedTestModel.GetPeopleSet(), true);
DynamicPathSegment segment4 = new DynamicPathSegment("incredibeans", HardCodedTestModel.GetPersonType(), HardCodedTestModel.GetPeopleSet(), true);
DynamicPathSegment segment5 = new DynamicPathSegment("superbeans", HardCodedTestModel.GetDogType(), HardCodedTestModel.GetPeopleSet(), true);
DynamicPathSegment segment6 = new DynamicPathSegment("superbeans", HardCodedTestModel.GetPersonType(), HardCodedTestModel.GetPaintingsSet(), true);
DynamicPathSegment segment7 = new DynamicPathSegment("superbeans", HardCodedTestModel.GetPersonType(), HardCodedTestModel.GetPeopleSet(), false);
BatchSegment segment = BatchSegment.Instance;
Assert.False(segment1.Equals(segment2));
Assert.False(segment2.Equals(segment));
Assert.False(segment1.Equals(segment3));
Assert.False(segment3.Equals(segment4));
Assert.False(segment3.Equals(segment5));
Assert.False(segment3.Equals(segment6));
Assert.False(segment3.Equals(segment7));
}
public void NestedComputeWithValidExpression()
{
// Arrange
SelectToken select = ParseSelectToken("PreviousAddresses($compute=tolower(Street) as lowStreet;$select=lowStreet)");
// Act
SelectExpandClause clause = BinderForPerson.Bind(expandToken: null, selectToken: select);
// Assert
Assert.NotNull(clause);
Assert.NotNull(clause.SelectedItems);
// FavoriteColors
var selectItem = Assert.Single(clause.SelectedItems);
PathSelectItem subPathSelect = Assert.IsType <PathSelectItem>(selectItem);
Assert.NotNull(subPathSelect.ComputeOption);
ComputeExpression computeExpr = Assert.Single(subPathSelect.ComputeOption.ComputedItems);
Assert.Equal("lowStreet", computeExpr.Alias);
var functionCall = Assert.IsType <SingleValueFunctionCallNode>(computeExpr.Expression);
Assert.Equal("tolower", functionCall.Name);
Assert.Empty(functionCall.Functions);
Assert.NotNull(subPathSelect.SelectAndExpand);
selectItem = Assert.Single(subPathSelect.SelectAndExpand.SelectedItems);
// it should be "lowStreet
PathSelectItem pathSelect = Assert.IsType <PathSelectItem>(selectItem);
ODataPathSegment segment = Assert.Single(pathSelect.SelectedPath);
DynamicPathSegment dynamic = Assert.IsType <DynamicPathSegment>(segment);
Assert.Equal("lowStreet", dynamic.Identifier);
}
