public void AppliesToActionForEntityActionWithEntityTypeNameSameAsEntityTypeOnEntitySetWorksAsExpected(string actionName)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <CustomersController>(actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = action;
EntityRoutingConvention entityConvention = ConventionHelpers.CreateConvention <EntityRoutingConvention>();
// Act
bool returnValue = entityConvention.AppliesToAction(context);
Assert.True(returnValue);
// Assert
Assert.Equal(2, action.Selectors.Count);
Assert.Equal(new[]
{
"Customers(FirstName={keyFirstName},LastName={keyLastName})",
"Customers(FirstName={keyFirstName},LastName={keyLastName})/NS.Customer"
},
action.Selectors.Select(s => s.AttributeRouteModel.Template));
}
public void AppliesToActionForEntityActionWithDerivedEntityTypeAndCaseInsensitiveWorksAsExpected()
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <CaseInsensitiveCustomersController>("GetVIPCUSTOMER");
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = action;
context.Options.RouteOptions.EnableActionNameCaseInsensitive = true;
EntityRoutingConvention entityConvention = ConventionHelpers.CreateConvention <EntityRoutingConvention>();
// Act
bool returnValue = entityConvention.AppliesToAction(context);
Assert.True(returnValue);
// Assert
Assert.Equal(2, action.Selectors.Count);
Assert.Collection(action.Selectors,
e =>
{
Assert.Equal("/CaseInsensitiveCustomers(FirstName={keyFirstName},LastName={keyLastName})/NS.VipCustomer", e.AttributeRouteModel.Template);
},
e =>
{
Assert.Equal("/CaseInsensitiveCustomers/FirstName={keyFirstName},LastName={keyLastName}/NS.VipCustomer", e.AttributeRouteModel.Template);
});
}
public void AppliesToActionForGetActionWorksAsExpected(string actionName, string expectedTemplate)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <CustomersController>(actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = action;
EntitySetRoutingConvention entitySetConvention = ConventionHelpers.CreateConvention <EntitySetRoutingConvention>();
// Act
bool returnValue = entitySetConvention.AppliesToAction(context);
Assert.True(returnValue);
// Assert
Assert.Equal(2, action.Selectors.Count);
Assert.Equal(new[]
{
$"/{expectedTemplate}",
$"/{expectedTemplate}/$count"
},
action.Selectors.Select(s => s.AttributeRouteModel.Template));
}
public void AppliesToActionForBasicEntityActionWorksAsExpected(string actionName)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <CustomersController>(actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = action;
EntityRoutingConvention entityConvention = ConventionHelpers.CreateConvention <EntityRoutingConvention>();
// Act
bool returnValue = entityConvention.AppliesToAction(context);
Assert.True(returnValue);
// Assert
Assert.Equal(2, action.Selectors.Count);
Assert.Collection(action.Selectors,
e =>
{
Assert.Equal("/Customers(FirstName={keyFirstName},LastName={keyLastName})", e.AttributeRouteModel.Template);
},
e =>
{
Assert.Equal("/Customers/FirstName={keyFirstName},LastName={keyLastName}", e.AttributeRouteModel.Template);
});
}
public void AppliesToControllerReturnsExpectedForController(Type controllerType, bool expected)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel(controllerType);
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
// Act
bool actual = FunctionConvention.AppliesToController(context);
// Assert
Assert.Equal(expected, actual);
}
public void SingletonRoutingConventionTestDataRunsAsExpected(string actionName, string[] templates)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <RefCustomersController>(actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, _edmModel, controller);
context.Action = action;
// Act
_refConvention.AppliesToAction(context);
// Assert
Assert.Equal(templates.Length, action.Selectors.Count);
Assert.Equal(templates, action.Selectors.Select(s => s.AttributeRouteModel.Template));
}
public void FunctionRoutingConventionResolveFunctionOverloadAsExpected(MethodInfo method, string[] templates)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModelByMethodInfo <CustomersController>(method);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = action;
// Act
FunctionConvention.AppliesToAction(context);
// Assert
Assert.Equal(templates.Length, action.Selectors.Count);
Assert.Equal(templates, action.Selectors.Select(s => s.AttributeRouteModel.Template));
}
public void ActionRoutingConventionTestDataWithCaseInsensitiveActionNameRunsAsExpected(Type controllerType, string actionName, string[] templates)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel(controllerType, actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Options.RouteOptions.EnableActionNameCaseInsensitive = true;
context.Action = action;
// Act
ActionConvention.AppliesToAction(context);
// Assert
Assert.Equal(templates.Length, action.Selectors.Count);
Assert.Equal(templates, action.Selectors.Select(s => s.AttributeRouteModel.Template));
}
public void OperationImportRoutingConventionDoesNothingForNotSupportedAction(string actionName)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <ODataOperationImportController>(actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = controller.Actions.First();
// Act
bool returnValue = ImportConvention.AppliesToAction(context);
Assert.True(returnValue);
// Assert
Assert.Empty(action.Selectors);
}
public void AppliesToActionDoesNothingForNonConventionAction(string actionName)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <AnotherCustomersController>(actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = controller.Actions.First();
EntitySetRoutingConvention entitySetConvention = ConventionHelpers.CreateConvention <EntitySetRoutingConvention>();
// Act
entitySetConvention.AppliesToAction(context);
// Assert
Assert.Empty(action.Selectors);
}
public void NavigationRoutingConventionTestDataRunsAsExpected(Type controllerType, string actionName, string[] templates)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel(controllerType, actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = action;
// Act
bool returnValue = NavigationConvention.AppliesToAction(context);
Assert.True(returnValue);
// Assert
Assert.Equal(templates.Length, action.Selectors.Count);
Assert.Equal(templates, action.Selectors.Select(s => s.AttributeRouteModel.Template));
}
public void ActionRoutingConventionDoesCaseSensitiveMatchingByDefault(Type controllerType, string actionName, string[] templates)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel(controllerType, actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = action;
// Act
ActionConvention.AppliesToAction(context);
// Assert
SelectorModel selector = Assert.Single(action.Selectors);
Assert.Null(selector.AttributeRouteModel);
Assert.NotEmpty(templates);
}
public void AppliesToActionAddTemplateForServiceDocumentWithPrefix(string prefix)
{
// Arrange
string expected = string.IsNullOrEmpty(prefix) ? "/" : $"/{prefix}/";
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <MetadataController>("GetServiceDocument");
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(prefix, EdmCoreModel.Instance, controller);
context.Action = action;
// Act
_metadataConvention.AppliesToAction(context);
// Assert
SelectorModel selector = Assert.Single(action.Selectors);
Assert.Equal(expected, selector.AttributeRouteModel.Template);
}
public void RefRoutingConventionDoesNothingForNotSupportedAction(string actionName)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <RefCustomersController>(actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, _edmModel, controller);
context.Action = controller.Actions.First();
// Act
bool returnValue = _refConvention.AppliesToAction(context);
Assert.False(returnValue);
// Assert
SelectorModel selector = Assert.Single(action.Selectors);
Assert.Null(selector.AttributeRouteModel);
}
public void AppliesToActionForPostActionWorksAsExpected(string actionName, string expected)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <CustomersController>(actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = controller.Actions.First();
EntitySetRoutingConvention entitySetConvention = ConventionHelpers.CreateConvention <EntitySetRoutingConvention>();
// Act
bool returnValue = entitySetConvention.AppliesToAction(context);
Assert.True(returnValue);
// Assert
SelectorModel selector = Assert.Single(action.Selectors);
Assert.Equal(expected, selector.AttributeRouteModel.Template);
}
public void AppliesToActionForEntityActionWithDerivedEntityTypeWorksAsExpected(string actionName)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel <CustomersController>(actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = action;
EntityRoutingConvention entityConvention = ConventionHelpers.CreateConvention <EntityRoutingConvention>();
// Act
bool returnValue = entityConvention.AppliesToAction(context);
Assert.True(returnValue);
// Assert
SelectorModel selector = Assert.Single(action.Selectors);
Assert.Equal("Customers(FirstName={keyFirstName},LastName={keyLastName})/NS.VipCustomer", selector.AttributeRouteModel.Template);
}
public void AppliesToAction_Works_ForPatchActionWorksAsExpected(Type controllerType, string actionName, string expected, bool ignoreCase)
{
// Arrange
ControllerModel controller = ControllerModelHelpers.BuildControllerModel(controllerType, actionName);
ActionModel action = controller.Actions.First();
ODataControllerActionContext context = ODataControllerActionContextHelpers.BuildContext(string.Empty, EdmModel, controller);
context.Action = controller.Actions.First();
context.Options.RouteOptions.EnableActionNameCaseInsensitive = ignoreCase;
EntitySetRoutingConvention entitySetConvention = ConventionHelpers.CreateConvention <EntitySetRoutingConvention>();
// Act
bool returnValue = entitySetConvention.AppliesToAction(context);
Assert.True(returnValue);
// Assert
SelectorModel selector = Assert.Single(action.Selectors);
Assert.Equal(expected, selector.AttributeRouteModel.Template);
}