public void CtorKeySegmentTemplate_ForAlternateKey_SetsProperties()
{
// Arrange & Act
IDictionary <string, object> keys = new Dictionary <string, object>
{
{ "name", BuildExpression("{nameValue}") }
};
KeySegment keySegment = new KeySegment(keys, _customerType, _customers);
IEdmStructuralProperty nameProperty = _customerType.StructuralProperties().First(c => c.Name == "Name");
IDictionary <string, IEdmProperty> properties = new Dictionary <string, IEdmProperty>
{
{ "name", nameProperty }
};
KeySegmentTemplate segmentTemplate = new KeySegmentTemplate(keySegment, properties);
// Assert
KeyValuePair <string, string> keyMapping = Assert.Single(segmentTemplate.KeyMappings);
Assert.Equal("name", keyMapping.Key);
Assert.Equal("nameValue", keyMapping.Value);
KeyValuePair <string, IEdmProperty> keyProperty = Assert.Single(segmentTemplate.KeyProperties);
Assert.Equal("name", keyProperty.Key);
Assert.Equal("Name", keyProperty.Value.Name);
Assert.Same(_customers, segmentTemplate.NavigationSource);
Assert.Same(_customerType, segmentTemplate.EntityType);
Assert.Equal(1, segmentTemplate.Count);
}
public void CtorKeySegmentTemplate_SetsProperties()
{
// 1) Arrange & Act
IDictionary <string, string> keys1 = new Dictionary <string, string>
{
{ "customerId", "{key}" }
};
KeySegmentTemplate segment1 = new KeySegmentTemplate(keys1, _customerType, _customers);
// 2) Arrange & Act
IDictionary <string, object> keys2 = new Dictionary <string, object>
{
{ "customerId", BuildExpression("{key}") }
};
KeySegment keySegment = new KeySegment(keys2, _customerType, _customers);
KeySegmentTemplate segment2 = new KeySegmentTemplate(keySegment);
// Assert
foreach (var segment in new[] { segment1, segment2 })
{
KeyValuePair <string, string> keyMapping = Assert.Single(segment.KeyMappings);
Assert.Equal("customerId", keyMapping.Key);
Assert.Equal("key", keyMapping.Value);
KeyValuePair <string, IEdmProperty> keyProperty = Assert.Single(segment.KeyProperties);
Assert.Equal("customerId", keyProperty.Key);
Assert.Equal("customerId", keyProperty.Value.Name);
Assert.Same(_customers, segment.NavigationSource);
Assert.Same(_customerType, segment.EntityType);
Assert.Equal(1, segment.Count);
}
}
public void GetTemplatesWorksForODataPathWithDollarRefOnSingleNavigation()
{
// Arrange
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
var entitySet = container.AddEntitySet("Customers", customer);
var navigation = customer.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
TargetMultiplicity = EdmMultiplicity.One,
Name = "SubCustomer",
Target = customer
});
ODataPathTemplate template = new ODataPathTemplate(
new EntitySetSegmentTemplate(entitySet),
KeySegmentTemplate.CreateKeySegment(customer, entitySet),
new NavigationLinkSegmentTemplate(navigation, entitySet));
// Act
IEnumerable <string> actual = template.GetTemplates();
// Assert
Assert.Equal(2, actual.Count());
Assert.Equal(new[]
{
"Customers({key})/SubCustomer/$ref",
"Customers/{key}/SubCustomer/$ref"
}, actual);
}
public void BuildKeyMappingsKeySegmentTemplate_ReturnsKeyMapping_UriTemplateExpression()
{
// Arrange
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
EdmStructuralProperty idProperty = customerType.AddStructuralProperty("customerId", EdmPrimitiveTypeKind.Int32);
customerType.AddKeys(idProperty);
UriTemplateExpression tempateExpression = BuildExpression("{yourId}", idProperty.Type);
IDictionary <string, object> keys = new Dictionary <string, object>
{
{ "customerId", tempateExpression }
};
// Act
IDictionary <string, string> mapped = KeySegmentTemplate.BuildKeyMappings(keys, customerType);
// Assert
Assert.NotNull(mapped);
KeyValuePair <string, string> actual = Assert.Single(mapped);
Assert.Equal("customerId", actual.Key);
Assert.Equal("yourId", actual.Value);
}
public void CtorKeySegmentTemplate_SetsProperties_ForCompositeKeys()
{
// Arrange & Act
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
EdmStructuralProperty firstProperty = customerType.AddStructuralProperty("firstName", EdmPrimitiveTypeKind.String);
EdmStructuralProperty lastProperty = customerType.AddStructuralProperty("lastName", EdmPrimitiveTypeKind.String);
customerType.AddKeys(firstProperty, lastProperty);
IDictionary <string, object> keys = new Dictionary <string, object>
{
{ "firstName", "{key1}" },
{ "lastName", "{key2}" }
};
KeySegment segment = new KeySegment(keys, customerType, null);
KeySegmentTemplate template = new KeySegmentTemplate(segment);
// Assert
Assert.Collection(template.KeyMappings,
e =>
{
Assert.Equal("firstName", e.Key);
Assert.Equal("key1", e.Value);
},
e =>
{
Assert.Equal("lastName", e.Key);
Assert.Equal("key2", e.Value);
});
}
public void Translate_ReturnsODataKeySegment()
{
// Arrange
EdmModel model = new EdmModel();
model.AddElement(_customerType);
model.AddElement(_container);
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "customerId", "{key}" }
};
RouteValueDictionary routeValueDictionary = new RouteValueDictionary(new { key = "42" });
KeySegmentTemplate template = new KeySegmentTemplate(keys, _customerType, _customers);
HttpContext httpContext = new DefaultHttpContext();
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext(httpContext, routeValueDictionary, model);
// Act
ODataPathSegment actual = template.Translate(context);
// Assert
Assert.NotNull(actual);
KeySegment keySegment = Assert.IsType <KeySegment>(actual);
var actualKey = Assert.Single(keySegment.Keys);
Assert.Equal("customerId", actualKey.Key);
Assert.Equal(42, actualKey.Value);
}
public void ParseODataUriTemplate_ForCompositeKeys(string template)
{
// Arrange
// function with optional parameters
EdmEntityType person = new EdmEntityType("NS", "Person");
EdmStructuralProperty firstName = person.AddStructuralProperty("firstName", EdmPrimitiveTypeKind.String);
EdmStructuralProperty lastName = person.AddStructuralProperty("lastName", EdmPrimitiveTypeKind.String);
person.AddKeys(firstName, lastName);
_edmModel.AddElement(person);
EdmEntityContainer container = _edmModel.SchemaElements.OfType <EdmEntityContainer>().First();
container.AddEntitySet("People", person);
IODataPathTemplateParser parser = new DefaultODataPathTemplateParser();
// Act
ODataPathTemplate path = parser.Parse(_edmModel, template, null);
// Assert
Assert.NotNull(path);
Assert.Equal(2, path.Count);
KeySegmentTemplate keySegment = Assert.IsType <KeySegmentTemplate>(path[1]);
Assert.Equal(2, keySegment.KeyMappings.Count);
Assert.Equal(new[] { "firstName", "lastName" }, keySegment.KeyMappings.Keys);
Assert.Equal(new[] { "first", "last" }, keySegment.KeyMappings.Values);
}
public bool AppliesToAction(ODataControllerActionContext context)
{
if (context.Action.ActionName == "Get")
{
var entitySet = context.Model.EntityContainer.FindEntitySet("Order Details");
var route = new EntitySetSegmentTemplate(entitySet);
var parameters = context.Action.ActionMethod.GetParameters();
if (parameters.Length == 0)
{
var path = new ODataPathTemplate(route);
context.Action.AddSelector("get", context.Prefix, context.Model, path, context.Options.RouteOptions);
return(true);
}
if (parameters.Length == 2 &&
parameters[0].Name == "keyOrderId" &&
parameters[1].Name == "keyProductId")
{
var keys = new Dictionary <string, string> {
{ "OrderID", "{keyOrderId}" }, { "ProductID", "{keyProductId}" }
};
var keyTemplate = new KeySegmentTemplate(keys, entitySet.EntityType(), entitySet);
var path = new ODataPathTemplate(route, keyTemplate);
context.Action.AddSelector("get", context.Prefix, context.Model, path, context.Options.RouteOptions);
return(true);
}
}
return(false);
}
public void TryTranslateKeySegmentTemplate_ReturnsODataKeySegment()
{
// Arrange
EdmModel model = new EdmModel();
model.AddElement(_customerType);
model.AddElement(_container);
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "customerId", "{key}" }
};
KeySegmentTemplate template = new KeySegmentTemplate(keys, _customerType, _customers);
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext
{
RouteValues = new RouteValueDictionary(new { key = "42" }),
Model = model
};
// Act
bool ok = template.TryTranslate(context);
// Assert
Assert.True(ok);
ODataPathSegment actual = Assert.Single(context.Segments);
KeySegment keySegment = Assert.IsType <KeySegment>(actual);
var actualKey = Assert.Single(keySegment.Keys);
Assert.Equal("customerId", actualKey.Key);
Assert.Equal(42, actualKey.Value);
}
internal static bool ProcessNonNavigationProperty(string httpMethod, ODataControllerActionContext context,
ActionModel action,
IEdmNavigationSource navigationSource,
IEdmEntityType entityType, IEdmStructuredType castType)
{
// Action parameter should have a (string navigationProperty) parameter
if (!action.HasParameter <string>("navigationProperty"))
{
return(false);
}
// Let's only handle single-key convention, for composite key, use attribute routing or non-generic navigation.
bool hasRelatedKey = action.Parameters.Any(p => p.Name == "relatedKey"); // case sensitive?
bool hasRelatedId = action.Parameters.Any(p => p.Name == "relatedId");
IList <ODataSegmentTemplate> segments = new List <ODataSegmentTemplate>();
if (context.EntitySet != null)
{
segments.Add(new EntitySetSegmentTemplate(context.EntitySet));
segments.Add(KeySegmentTemplate.CreateKeySegment(entityType, context.EntitySet));
}
else
{
segments.Add(new SingletonSegmentTemplate(context.Singleton));
}
if (entityType != castType)
{
segments.Add(new CastSegmentTemplate(castType, entityType, navigationSource));
}
if (hasRelatedKey)
{
segments.Add(new NavigationLinkTemplateSegmentTemplate(entityType, navigationSource)
{
RelatedKey = "relatedKey"
});
}
else if (hasRelatedId)
{
segments.Add(new NavigationLinkTemplateSegmentTemplate(entityType, navigationSource)
{
RelatedKey = "relatedId"
});
}
else
{
segments.Add(new NavigationLinkTemplateSegmentTemplate(entityType, navigationSource));
}
ODataPathTemplate template = new ODataPathTemplate(segments);
action.AddSelector(httpMethod, context.Prefix, context.Model, template, context.Options?.RouteOptions);
return(true);
}
public void TryTranslateNavigationLinkSegmentTemplate_ReturnsODataNavigationSegment()
{
// Arrange
EdmModel model = new EdmModel();
model.AddElement(_employee);
NavigationLinkSegmentTemplate linkSegment = new NavigationLinkSegmentTemplate(_navigation, null);
RouteValueDictionary routeValueDictionary = new RouteValueDictionary(new { id = "42" });
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext
{
RouteValues = routeValueDictionary,
Model = model
};
// Without key segment
// Act & Assert
bool ok = linkSegment.TryTranslate(context);
Assert.True(ok);
ODataPathSegment actual = Assert.Single(context.Segments);
NavigationPropertyLinkSegment navLinkSegment = Assert.IsType <NavigationPropertyLinkSegment>(actual);
Assert.Same(_navigation, navLinkSegment.NavigationProperty);
Assert.Null(navLinkSegment.NavigationSource);
// With Key segment
// Act & Assert
context = new ODataTemplateTranslateContext
{
RouteValues = routeValueDictionary,
Model = model
};
linkSegment.Key = KeySegmentTemplate.CreateKeySegment(_employee, null, "id");
ok = linkSegment.TryTranslate(context);
Assert.True(ok);
Assert.Collection(context.Segments,
e =>
{
NavigationPropertyLinkSegment navLinkSegment = Assert.IsType <NavigationPropertyLinkSegment>(e);
Assert.Same(_navigation, navLinkSegment.NavigationProperty);
Assert.Null(navLinkSegment.NavigationSource);
},
e =>
{
KeySegment keySegment = Assert.IsType <KeySegment>(e);
KeyValuePair <string, object> key = Assert.Single(keySegment.Keys);
Assert.Equal("Id", key.Key);
Assert.Equal(42, key.Value);
});
}
public void TryTranslateKeySegmentTemplate_ThrowsArgumentNull_Context()
{
// Arrange
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "customerId", "{key}" }
};
KeySegmentTemplate keySegment = new KeySegmentTemplate(keys, _customerType, _customers);
// Act & Assert
ExceptionAssert.ThrowsArgumentNull(() => keySegment.TryTranslate(null), "context");
}
private static void AddSelector(string httpMethod, ODataControllerActionContext context, ActionModel action,
IEdmNavigationSource navigationSource,
IEdmStructuralProperty edmProperty,
IEdmType cast, IEdmEntityType declaringType, bool dollarValue, bool dollarCount)
{
IEdmEntitySet entitySet = navigationSource as IEdmEntitySet;
IEdmEntityType entityType = navigationSource.EntityType();
IList <ODataSegmentTemplate> segments = new List <ODataSegmentTemplate>();
if (entitySet != null)
{
segments.Add(new EntitySetSegmentTemplate(entitySet));
segments.Add(KeySegmentTemplate.CreateKeySegment(entityType, navigationSource));
}
else
{
segments.Add(new SingletonSegmentTemplate(navigationSource as IEdmSingleton));
}
if (declaringType != null && declaringType != entityType)
{
segments.Add(new CastSegmentTemplate(declaringType, entityType, navigationSource));
}
segments.Add(new PropertySegmentTemplate(edmProperty));
if (cast != null)
{
if (edmProperty.Type.IsCollection())
{
cast = new EdmCollectionType(cast.ToEdmTypeReference(edmProperty.Type.IsNullable));
}
// TODO: maybe create the collection type for the collection????
segments.Add(new CastSegmentTemplate(cast, edmProperty.Type.Definition, navigationSource));
}
if (dollarValue)
{
segments.Add(new ValueSegmentTemplate(edmProperty.Type.Definition));
}
if (dollarCount)
{
segments.Add(CountSegmentTemplate.Instance);
}
ODataPathTemplate template = new ODataPathTemplate(segments);
action.AddSelector(httpMethod.NormalizeHttpMethod(), context.Prefix, context.Model, template, context.Options?.RouteOptions);
}
public void CreateKeySegmentKeySegmentTemplate_ReturnsKeySegmentTemplate()
{
// Arrange
KeySegmentTemplate template = KeySegmentTemplate.CreateKeySegment(_customerType, _customers, "id");
// Assert
Assert.NotNull(template);
Assert.Equal(1, template.Count);
KeyValuePair <string, string> keyMapping = Assert.Single(template.KeyMappings);
Assert.Equal("customerId", keyMapping.Key);
Assert.Equal("id", keyMapping.Value);
}
public void BuildKeyMappingsKeySegmentTemplate_ThrowsODataException_NullTemplateLiteral()
{
// Arrange
IDictionary <string, object> keys = new Dictionary <string, object>
{
{ "customerId", null }
};
// Act
Action test = () => KeySegmentTemplate.BuildKeyMappings(keys, _customerType);
// Assert
ExceptionAssert.Throws <ODataException>(test, "Key template value '' for key segment 'customerId' does not start with '{' or ends with '}'.");
}
public void BuildKeyMappingsKeySegmentTemplate_ThrowsODataException_EmptyTemplateLiteral()
{
// Arrange
IDictionary <string, object> keys = new Dictionary <string, object>
{
{ "customerId", "{}" }
};
// Act
Action test = () => KeySegmentTemplate.BuildKeyMappings(keys, _customerType);
// Assert
ExceptionAssert.Throws <ODataException>(test, "Key template value '{}' for key segment 'customerId' is empty.");
}
public void TryMatch_SingleKey_ReturnsTrueOnMatch()
{
KeySegmentTemplate template =
new KeySegmentTemplate(new KeySegment(new[] { new KeyValuePair <string, object>("ID", "{key}") }, null,
null));
KeySegment segment = new KeySegment(new[] { new KeyValuePair <string, object>("ID", 123) }, null, null);
// Act
Dictionary <string, object> values = new Dictionary <string, object>();
bool result = template.TryMatch(segment, values);
// Assert
Assert.True(result);
Assert.Equal(123, values["key"]);
}
public void TryTranslateKeySegmentTemplate_WorksWithKeyValue_UsingEscapedString()
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
EdmStructuralProperty firstName = customerType.AddStructuralProperty("FirstName", EdmPrimitiveTypeKind.String);
EdmStructuralProperty lastName = customerType.AddStructuralProperty("LastName", EdmPrimitiveTypeKind.String);
customerType.AddKeys(firstName, lastName);
model.AddElement(customerType);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmEntitySet customers = container.AddEntitySet("Customers", customerType);
model.AddElement(container);
RouteValueDictionary routeValueDictionary = new RouteValueDictionary(new { First = "'Zhang'", Last = "'Gan%2Fnng%23%20T'" });
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "FirstName", "{first}" },
{ "LastName", "{last}" }
};
KeySegmentTemplate template = new KeySegmentTemplate(keys, customerType, customers);
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext
{
RouteValues = routeValueDictionary,
Model = model
};
// Act
bool ok = template.TryTranslate(context);
// Assert
Assert.True(ok);
ODataPathSegment actual = Assert.Single(context.Segments);
KeySegment keySegment = Assert.IsType <KeySegment>(actual);
Assert.Collection(keySegment.Keys,
e =>
{
Assert.Equal("FirstName", e.Key);
Assert.Equal("Zhang", e.Value);
},
e =>
{
Assert.Equal("LastName", e.Key);
Assert.Equal("Gan/nng# T", e.Value);
});
}
public void GetTemplatesKeySegmentTemplate_ReturnsTemplates_ForCompositeKeys()
{
// Arrange
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
EdmStructuralProperty firstProperty = customerType.AddStructuralProperty("firstName", EdmPrimitiveTypeKind.String);
EdmStructuralProperty lastProperty = customerType.AddStructuralProperty("lastName", EdmPrimitiveTypeKind.String);
customerType.AddKeys(firstProperty, lastProperty);
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "firstName", "{key1}" },
{ "lastName", "{key2}" }
};
KeySegmentTemplate keySegment = new KeySegmentTemplate(keys, customerType, null);
// Act & Assert
IEnumerable <string> templates = keySegment.GetTemplates();
Assert.Collection(templates,
e =>
{
Assert.Equal("(firstName={key1},lastName={key2})", e);
},
e =>
{
Assert.Equal("/firstName={key1},lastName={key2}", e);
});
// Act & Assert
templates = keySegment.GetTemplates(new ODataRouteOptions
{
EnableKeyAsSegment = false
});
string template = Assert.Single(templates);
Assert.Equal("(firstName={key1},lastName={key2})", template);
// Act & Assert
templates = keySegment.GetTemplates(new ODataRouteOptions
{
EnableKeyInParenthesis = false
});
template = Assert.Single(templates);
Assert.Equal("/firstName={key1},lastName={key2}", template);
}
private void AddSelector(string httpMethod, ODataControllerActionContext context, ActionModel action,
IEdmNavigationSource navigationSource, string declared, IEdmEntityType declaringEntityType,
IEdmNavigationProperty navigationProperty, bool hasKey, bool dollarCount)
{
IEdmEntitySet entitySet = navigationSource as IEdmEntitySet;
IEdmEntityType entityType = navigationSource.EntityType();
// Starts the routing template
IList <ODataSegmentTemplate> segments = new List <ODataSegmentTemplate>();
if (entitySet != null)
{
segments.Add(new EntitySetSegmentTemplate(entitySet));
}
else
{
segments.Add(new SingletonSegmentTemplate(navigationSource as IEdmSingleton));
}
if (hasKey)
{
segments.Add(KeySegmentTemplate.CreateKeySegment(entityType, navigationSource));
}
if (declared != null)
{
// It should be always single type
if (entityType != declaringEntityType)
{
segments.Add(new CastSegmentTemplate(declaringEntityType, entityType, navigationSource));
}
}
IEdmNavigationSource targetNavigationSource = navigationSource.FindNavigationTarget(navigationProperty, segments, out _);
segments.Add(new NavigationSegmentTemplate(navigationProperty, targetNavigationSource));
if (dollarCount)
{
segments.Add(CountSegmentTemplate.Instance);
}
ODataPathTemplate template = new ODataPathTemplate(segments);
action.AddSelector(httpMethod.NormalizeHttpMethod(), context.Prefix, context.Model, template, context.RouteOptions);
Log.AddedODataSelector(_logger, action, template);
}
public void CreateKeySegmentKeySegmentTemplate_ReturnsKeySegmentTemplate_CompositeKey()
{
// Arrange
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
EdmStructuralProperty firstProperty = customerType.AddStructuralProperty("firstName", EdmPrimitiveTypeKind.String);
EdmStructuralProperty lastProperty = customerType.AddStructuralProperty("lastName", EdmPrimitiveTypeKind.String);
customerType.AddKeys(firstProperty, lastProperty);
// Act
KeySegmentTemplate template = KeySegmentTemplate.CreateKeySegment(customerType, null);
// Assert
Assert.NotNull(template);
Assert.Equal(2, template.Count);
}
public void GetTemplatesWorksForPathWithTypeCastAndFunction()
{
// Arrange
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
// VipCustomer
EdmEntityType vipCustomer = new EdmEntityType("NS", "VipCustomer", customer);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
var entitySet = container.AddEntitySet("Customers", customer);
// function with optional parameters
EdmFunction getSalaray = new EdmFunction("NS", "GetWholeSalary", IntType, isBound: true, entitySetPathExpression: null, isComposable: false);
getSalaray.AddParameter("entityset", new EdmEntityTypeReference(vipCustomer, false));
getSalaray.AddParameter("salary", IntType);
getSalaray.AddOptionalParameter("minSalary", IntType);
getSalaray.AddOptionalParameter("maxSalary", IntType, "129");
ODataPathTemplate template = new ODataPathTemplate(
new EntitySetSegmentTemplate(entitySet),
KeySegmentTemplate.CreateKeySegment(customer, entitySet),
new CastSegmentTemplate(vipCustomer, customer, entitySet),
new FunctionSegmentTemplate(getSalaray, null));
// Act
IEnumerable <(string, string)> actual = template.GetTemplates();
Assert.Equal(4, actual.Count());
Assert.Equal(new[]
{
"Customers({key})/NS.VipCustomer/NS.GetWholeSalary({salary;minSalary;maxSalary})",
"Customers({key})/NS.VipCustomer/GetWholeSalary({salary;minSalary;maxSalary})",
"Customers/{key}/NS.VipCustomer/NS.GetWholeSalary({salary;minSalary;maxSalary})",
"Customers/{key}/NS.VipCustomer/GetWholeSalary({salary;minSalary;maxSalary})",
}, actual.Select(a => a.Item1));
Assert.Equal(new[]
{
"Customers({key})/NS.VipCustomer/NS.GetWholeSalary(salary={salary},minSalary={minSalary},maxSalary={maxSalary})",
"Customers({key})/NS.VipCustomer/GetWholeSalary(salary={salary},minSalary={minSalary},maxSalary={maxSalary})",
"Customers/{key}/NS.VipCustomer/NS.GetWholeSalary(salary={salary},minSalary={minSalary},maxSalary={maxSalary})",
"Customers/{key}/NS.VipCustomer/GetWholeSalary(salary={salary},minSalary={minSalary},maxSalary={maxSalary})",
}, actual.Select(a => a.Item2));
}
public void ParseODataUriTemplate_ForBasicKey(string template)
{
// Arrange
IODataPathTemplateParser parser = new DefaultODataPathTemplateParser();
// Act
ODataPathTemplate path = parser.Parse(_edmModel, template, null);
// Assert
Assert.NotNull(path);
Assert.Equal(2, path.Count);
KeySegmentTemplate keySegment = Assert.IsType <KeySegmentTemplate>(path[1]);
var keyMap = Assert.Single(keySegment.KeyMappings);
Assert.Equal("Id", keyMap.Key);
Assert.Equal("idKey", keyMap.Value);
}
public void TryTranslateKeySegmentTemplate_ReturnsODataKeySegment_ForKeyAsSegment()
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
EdmStructuralProperty idProperty = customerType.AddStructuralProperty("customerId", EdmPrimitiveTypeKind.String);
customerType.AddKeys(idProperty);
model.AddElement(customerType);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmEntitySet customers = container.AddEntitySet("Customers", customerType);
model.AddElement(container);
RouteValueDictionary routeValueDictionary = new RouteValueDictionary(new { key = "Peter" });
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "customerId", "{key}" }
};
KeySegmentTemplate template = new KeySegmentTemplate(keys, customerType, customers);
RouteEndpoint endpoint = new RouteEndpoint(
c => Task.CompletedTask,
RoutePatternFactory.Parse("odata/customers/{key}/Name"),
0,
EndpointMetadataCollection.Empty,
"test");
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext
{
RouteValues = routeValueDictionary,
Model = model,
Endpoint = endpoint
};
// Act
bool ok = template.TryTranslate(context);
// Assert
Assert.True(ok);
ODataPathSegment actual = Assert.Single(context.Segments);
KeySegment keySegment = Assert.IsType <KeySegment>(actual);
KeyValuePair <string, object> actualKeys = Assert.Single(keySegment.Keys);
Assert.Equal("customerId", actualKeys.Key);
Assert.Equal("Peter", actualKeys.Value);
}
public void CommonKeySegmentTemplateProperties_ReturnsAsExpected()
{
// Assert
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "customerId", "{key}" }
};
// Act
KeySegmentTemplate template = new KeySegmentTemplate(keys, _customerType, _customers);
// Assert
Assert.Equal(ODataSegmentKind.Key, template.Kind);
Assert.Equal("{key}", template.Literal);
Assert.True(template.IsSingle);
Assert.Same(_customerType, template.EdmType);
Assert.Same(_customers, template.NavigationSource);
}
public void GetTemplatesNavigationLinkSegmentTemplate_ReturnsTemplates()
{
// Arrange
NavigationLinkSegmentTemplate linkSegment = new NavigationLinkSegmentTemplate(_navigation, null);
// Act & Assert
IEnumerable <string> templates = linkSegment.GetTemplates();
string template = Assert.Single(templates);
Assert.Equal("/DirectReports/$ref", template);
// Act & Assert
linkSegment.Key = KeySegmentTemplate.CreateKeySegment(_employee, null);
templates = linkSegment.GetTemplates();
Assert.Collection(templates,
e => Assert.Equal("/DirectReports({key})/$ref", e),
e => Assert.Equal("/DirectReports/{key}/$ref", e));
}
public void TryTranslateKeySegmentTemplate_ReturnsODataKeySegment_ForCompositeKey()
{
// Arrange
EdmModel model = new EdmModel();
EdmEntityType customerType = new EdmEntityType("NS", "Customer");
EdmStructuralProperty firstProperty = customerType.AddStructuralProperty("firstName", EdmPrimitiveTypeKind.String);
EdmStructuralProperty lastProperty = customerType.AddStructuralProperty("lastName", EdmPrimitiveTypeKind.String);
customerType.AddKeys(firstProperty, lastProperty);
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "firstName", "{key1}" },
{ "lastName", "{key2}" }
};
model.AddElement(customerType);
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
EdmEntitySet customers = container.AddEntitySet("Customers", customerType);
model.AddElement(container);
RouteValueDictionary routeValueDictionary = new RouteValueDictionary(new { key1 = "'Peter'", key2 = "'Sam'" });
KeySegmentTemplate template = new KeySegmentTemplate(keys, customerType, customers);
ODataTemplateTranslateContext context = new ODataTemplateTranslateContext
{
RouteValues = routeValueDictionary,
Model = model
};
// Act
bool ok = template.TryTranslate(context);
// Assert
Assert.True(ok);
ODataPathSegment actual = Assert.Single(context.Segments);
KeySegment keySegment = Assert.IsType <KeySegment>(actual);
Assert.Equal(2, keySegment.Keys.Count());
Assert.Equal(new[] { "firstName", "lastName" }, keySegment.Keys.Select(c => c.Key));
Assert.Equal(new[] { "Peter", "Sam" }, keySegment.Keys.Select(c => c.Value.ToString()));
}
public void GetTemplatesKeySegmentTemplate_ReturnsTemplates()
{
// Arrange
IDictionary <string, string> keys = new Dictionary <string, string>
{
{ "customerId", "{key}" }
};
KeySegmentTemplate keySegment = new KeySegmentTemplate(keys, _customerType, _customers);
// Act & Assert
IEnumerable <string> templates = keySegment.GetTemplates();
Assert.Collection(templates,
e =>
{
Assert.Equal("({key})", e);
},
e =>
{
Assert.Equal("/{key}", e);
});
// Act & Assert
templates = keySegment.GetTemplates(new ODataRouteOptions
{
EnableKeyAsSegment = false
});
string template = Assert.Single(templates);
Assert.Equal("({key})", template);
// Act & Assert
templates = keySegment.GetTemplates(new ODataRouteOptions
{
EnableKeyInParenthesis = false
});
template = Assert.Single(templates);
Assert.Equal("/{key}", template);
}
public void GetTemplatesWorksForBasicPath()
{
// Arrange
EdmEntityType customer = new EdmEntityType("NS", "Customer");
customer.AddKeys(customer.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
EdmEntityContainer container = new EdmEntityContainer("NS", "Default");
var entitySet = container.AddEntitySet("Customers", customer);
ODataPathTemplate template = new ODataPathTemplate(
new EntitySetSegmentTemplate(entitySet),
KeySegmentTemplate.CreateKeySegment(customer, entitySet));
// Act
IEnumerable <(string, string)> actual = template.GetTemplates();
// Assert
Assert.Equal(2, actual.Count());
Assert.Equal(new[] { "Customers({key})", "Customers/{key}" }, actual.Select(a => a.Item1));
}
public void BuildKeyMappingsKeySegmentTemplate_ThrowsODataException_NoProperty()
{
// Arrange
IDictionary <string, object> keys = new Dictionary <string, object>
{
{ "customerId", "{key}" }
};
IEdmStructuralProperty nameProperty = _customerType.StructuralProperties().First(c => c.Name == "Name");
IDictionary <string, IEdmProperty> properties = new Dictionary <string, IEdmProperty>
{
{ "name", nameProperty }
};
// Act
Action test = () => KeySegmentTemplate.BuildKeyMappings(keys, _customerType, properties);
// Assert
ExceptionAssert.Throws <ODataException>(test, "Cannot find key 'customerId' in the 'NS.Customer' type.");
}
