public void apply_to_should_assign_model_with_declared_api_versions_from_mapped_convention_and_attributes()
{
// arrange
var controllerBuilder = new ControllerApiVersionConventionBuilder(typeof(DecoratedController));
var actionBuilder = new ActionApiVersionConventionBuilder(controllerBuilder);
var controllerDescriptor = new HttpControllerDescriptor()
{
ControllerType = typeof(DecoratedController)
};
var method = typeof(DecoratedController).GetMethod(nameof(DecoratedController.Get));
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, method);
var empty = Enumerable.Empty <ApiVersion>();
var controllerVersionInfo = Tuple.Create(empty, empty, empty, empty);
actionDescriptor.Properties[controllerVersionInfo.GetType()] = controllerVersionInfo;
actionBuilder.MapToApiVersion(new ApiVersion(2, 0))
.MapToApiVersion(new ApiVersion(3, 0));
// act
actionBuilder.ApplyTo(actionDescriptor);
// assert
actionDescriptor.GetApiVersionModel().Should().BeEquivalentTo(
new
{
IsApiVersionNeutral = false,
DeclaredApiVersions = new[] { new ApiVersion(2, 0), new ApiVersion(3, 0) },
SupportedApiVersions = new ApiVersion[0],
DeprecatedApiVersions = new ApiVersion[0],
ImplementedApiVersions = new ApiVersion[0],
});
}
public void apply_to_should_assign_model_with_declared_api_versions_from_mapped_convention()
{
// arrange
var controllerBuilder = new ControllerApiVersionConventionBuilder <UndecoratedController>();
var actionBuilder = new ActionApiVersionConventionBuilder <UndecoratedController>(controllerBuilder);
var actionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
actionDescriptor.Setup(ad => ad.GetCustomAttributes <IApiVersionProvider>()).Returns(new Collection <IApiVersionProvider>());
actionBuilder.MapToApiVersion(new ApiVersion(2, 0));
// act
actionBuilder.ApplyTo(actionDescriptor.Object);
// assert
actionDescriptor.Object.GetApiVersionModel().ShouldBeEquivalentTo(
new
{
IsApiVersionNeutral = false,
DeclaredApiVersions = new[] { new ApiVersion(2, 0) },
SupportedApiVersions = new[] { new ApiVersion(2, 0) },
DeprecatedApiVersions = new ApiVersion[0],
ImplementedApiVersions = new[] { new ApiVersion(2, 0) }
});
}
public void apply_to_should_assign_model_with_declared_api_versions_from_mapped_convention()
{
// arrange
var controllerBuilder = new ControllerApiVersionConventionBuilder(typeof(UndecoratedController));
var actionBuilder = new ActionApiVersionConventionBuilder(controllerBuilder);
var actionDescriptor = new Mock <HttpActionDescriptor>()
{
CallBase = true
};
var empty = Enumerable.Empty <ApiVersion>();
var controllerVersionInfo = Tuple.Create(empty, empty, empty, empty);
actionDescriptor.Setup(ad => ad.GetCustomAttributes <IApiVersionProvider>()).Returns(new Collection <IApiVersionProvider>());
actionDescriptor.Object.Properties[controllerVersionInfo.GetType()] = controllerVersionInfo;
actionBuilder.MapToApiVersion(new ApiVersion(2, 0));
// act
actionBuilder.ApplyTo(actionDescriptor.Object);
// assert
actionDescriptor.Object.GetApiVersionModel().Should().BeEquivalentTo(
new
{
IsApiVersionNeutral = false,
DeclaredApiVersions = new[] { new ApiVersion(2, 0) },
SupportedApiVersions = new ApiVersion[0],
DeprecatedApiVersions = new ApiVersion[0],
ImplementedApiVersions = new ApiVersion[0],
});
}
public void apply_to_should_assign_model_with_declared_api_versions_from_mapped_convention_and_attributes()
{
// arrange
var controllerBuilder = new ControllerApiVersionConventionBuilder <UndecoratedController>();
var actionBuilder = new ActionApiVersionConventionBuilder <UndecoratedController>(controllerBuilder);
var controllerDescriptor = new HttpControllerDescriptor()
{
ControllerType = typeof(DecoratedController)
};
var method = typeof(DecoratedController).GetMethod(nameof(DecoratedController.Get));
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, method);
actionBuilder.MapToApiVersion(new ApiVersion(2, 0))
.MapToApiVersion(new ApiVersion(3, 0));
// act
actionBuilder.ApplyTo(actionDescriptor);
// assert
actionDescriptor.GetApiVersionModel().ShouldBeEquivalentTo(
new
{
IsApiVersionNeutral = false,
DeclaredApiVersions = new[] { new ApiVersion(2, 0), new ApiVersion(3, 0) },
SupportedApiVersions = new[] { new ApiVersion(2, 0), new ApiVersion(3, 0) },
DeprecatedApiVersions = new ApiVersion[0],
ImplementedApiVersions = new[] { new ApiVersion(2, 0), new ApiVersion(3, 0) }
});
}
public void action_should_throw_exception_when_func_delegate_expression_is_not_a_method()
{
// arrange
var controllerBuilder = new ControllerApiVersionConventionBuilder <StubController>();
var actionBuilder = new Mock <ActionApiVersionConventionBuilder <StubController> >(controllerBuilder).Object;
// act
Action action = () => actionBuilder.Action(c => c.Timeout);
// assert
action.Should().Throw <InvalidOperationException>().And
.Message.Should().Be("The expression 'c => c.Timeout' must refer to a controller action method.");
}
public void action_should_map_method_from_func_delegate_expression()
{
// arrange
var method = typeof(StubController).GetMethod(nameof(StubController.Get));
var controllerBuilder = new ControllerApiVersionConventionBuilder <StubController>();
var actionBuilder = new Mock <ActionApiVersionConventionBuilder <StubController> >(controllerBuilder);
// act
actionBuilder.Object.Action(c => c.Get());
// assert
actionBuilder.Verify(b => b.Action(method), Once());
}
/// <summary>
/// Gets or creates the convention builder for the specified controller.
/// </summary>
/// <typeparam name="TController">The <see cref="Type">type</see> of controller to build conventions for.</typeparam>
/// <returns>A new or existing <see cref="ControllerApiVersionConventionBuilder{T}"/>.</returns>
public virtual ControllerApiVersionConventionBuilder <TController> Controller <TController>() where TController : IHttpController
{
Contract.Ensures(Contract.Result <ControllerApiVersionConventionBuilder <TController> >() != null);
var key = typeof(TController);
if (!ControllerConventions.TryGetValue(key, out var convention))
{
var typedConvention = new ControllerApiVersionConventionBuilder <TController>();
ControllerConventions[key] = typedConvention;
return(typedConvention);
}
return((ControllerApiVersionConventionBuilder <TController>)convention);
}
void ApplyActionConventions(HttpControllerDescriptor controller)
{
Contract.Requires(controller != null);
var actionSelector = controller.Configuration.Services.GetActionSelector();
var actions = actionSelector.GetActionMapping(controller).SelectMany(g => g).ToArray();
if (VersionNeutral)
{
controller.SetApiVersionModel(ApiVersionModel.Neutral);
for (var i = 0; i < actions.Length; i++)
{
actions[i].SetProperty(ApiVersionModel.Neutral);
}
return;
}
controller.SetApiVersionModel(new ApiVersionModel(SupportedVersions, DeprecatedVersions, AdvertisedVersions, DeprecatedAdvertisedVersions));
var anyController = new ControllerApiVersionConventionBuilder(typeof(IHttpController));
for (var i = 0; i < actions.Length; i++)
{
if (!(actions[i] is ReflectedHttpActionDescriptor action))
{
continue;
}
var key = action.MethodInfo;
if (!TryGetConvention(key, out var actionConvention))
{
actionConvention = new ActionApiVersionConventionBuilder(anyController);
}
actionConvention.ApplyTo(action);
}
ApplyInheritedActionConventions(actions);
}
/// <summary>
/// Gets or creates the convention builder for the specified controller.
/// </summary>
/// <typeparam name="TController">The <see cref="Type">type</see> of controller to build conventions for.</typeparam>
/// <returns>A new or existing <see cref="ControllerApiVersionConventionBuilder{T}"/>.</returns>
public virtual ControllerApiVersionConventionBuilder <TController> Controller <TController>() where TController : IHttpController
{
Contract.Ensures(Contract.Result <ControllerApiVersionConventionBuilder <TController> >() != null);
var key = typeof(TController);
if (!ControllerConventions.TryGetValue(key, out var convention))
{
var typedConvention = new ControllerApiVersionConventionBuilder <TController>();
ControllerConventions[key] = typedConvention;
return(typedConvention);
}
if (convention is ControllerApiVersionConventionBuilder <TController> builder)
{
return(builder);
}
throw new InvalidOperationException(SR.ConventionStyleMismatch.FormatDefault(key.Name));
}
/// <summary>
/// Gets or creates the convention builder for the specified controller.
/// </summary>
/// <param name="controllerType">The <see cref="Type">type</see> of controller to build conventions for.</param>
/// <returns>A new or existing <see cref="ControllerApiVersionConventionBuilder"/>.</returns>
public virtual ControllerApiVersionConventionBuilder Controller(Type controllerType)
{
Arg.NotNull(controllerType, nameof(controllerType));
Contract.Ensures(Contract.Result <ControllerApiVersionConventionBuilder>() != null);
var key = controllerType;
if (!ControllerConventions.TryGetValue(key, out var convention))
{
var typedConvention = new ControllerApiVersionConventionBuilder(controllerType);
ControllerConventions[key] = typedConvention;
return(typedConvention);
}
if (convention is ControllerApiVersionConventionBuilder builder)
{
return(builder);
}
throw new InvalidOperationException(SR.ConventionStyleMismatch.FormatDefault(key.Name));
}
