public void OnAuthorization_NotAuthenticated_RedirectsToLogin()
{
AuthorizationContext action = new AuthorizationContext();
action.ActionDescriptor = Substitute.For <ActionDescriptor>();
HttpContextBase context = HttpContextFactory.CreateHttpContextBase();
AuthorizationFilterAttribute attribute = new AuthorizationFilterAttribute {
Users = "None"
};
action.RouteData = context.Request.RequestContext.RouteData;
action.RouteData.Values["test"] = "Test";
action.HttpContext = context;
attribute.OnAuthorization(action);
RouteValueDictionary actual = (action.Result as RedirectToRouteResult).RouteValues;
Assert.Equal(action.RouteData.Values["language"], actual["language"]);
Assert.Equal(action.HttpContext.Request.RawUrl, actual["returnUrl"]);
Assert.Equal("Auth", actual["controller"]);
Assert.Equal("Login", actual["action"]);
Assert.Equal("", actual["area"]);
Assert.Equal(5, actual.Count);
}
public void BeforeEach()
{
fixture = new Fixture().Customize(new AutoMoqCustomization());
fixture.Inject(new UriScheme("http"));
authorizationHdeaderKey = "Authorization";
token = TokenSchema + "SomeRandomToken";
expectedSession = fixture.Create <Session>();
tracerId = fixture.Create <string>();
url = "//autofixture.com";
moqSessionsService = new Mock <ISessionsService>(MockBehavior.Strict);
moqConfiguration = new Mock <IConfigurationManager>(MockBehavior.Strict);
moqConfiguration.SetupGet(x => x.AuthenticationSchema).Returns(TokenSchema);
moqSessionsService.Setup(x => x.GetSessionByTokenAsync(It.IsAny <string>())).Returns(Task.FromResult(expectedSession));
moqServiceProvider = new Mock <IServiceProvider>(MockBehavior.Strict);
moqServiceProvider.Setup(x => x.GetService(typeof(ISessionsService))).Returns(moqSessionsService.Object);
moqServiceProvider.Setup(x => x.GetService(typeof(IConfigurationManager))).Returns(moqConfiguration.Object);
moqHttpContext = new Mock <HttpContext>(MockBehavior.Default);
moqHttpContext.Setup(x => x.Request.Headers[authorizationHdeaderKey]).Returns(token);
moqHttpContext.Setup(x => x.Request.Path).Returns(url);
moqHttpContext.Setup(x => x.Request.HttpContext.TraceIdentifier).Returns(tracerId);
moqHttpContext.Setup(x => x.RequestServices).Returns(moqServiceProvider.Object);
moqActionDescriptor = new Mock <ActionDescriptor>();
actionContext = new ActionContext(moqHttpContext.Object, new RouteData(), moqActionDescriptor.Object);
filtersMetadata = new List <IFilterMetadata>();
authorizationContext = new AuthorizationFilterContext(actionContext, filtersMetadata);
authorizationFilter = new AuthorizationFilterAttribute();
}
public AuthorizationFilterAttributeTracer(AuthorizationFilterAttribute innerFilter, ITraceWriter traceWriter)
{
Contract.Assert(innerFilter != null);
Contract.Assert(traceWriter != null);
_innerFilter = innerFilter;
_traceStore = traceWriter;
}
public void Decorator_GetInner_On_AuthorizationFilterAttributeTracer_Returns_AuthorizationFilterAttribute()
{
// Arrange
AuthorizationFilterAttribute expectedInner = new Mock <AuthorizationFilterAttribute>().Object;
AuthorizationFilterAttributeTracer productUnderTest = new AuthorizationFilterAttributeTracer(expectedInner, new TestTraceWriter());
// Act
AuthorizationFilterAttribute actualInner = Decorator.GetInner(productUnderTest as AuthorizationFilterAttribute);
// Assert
Assert.Same(expectedInner, actualInner);
}
public void Inner_Property_On_AuthorizationFilterAttributeTracer_Returns_AuthorizationFilterAttribute()
{
// Arrange
AuthorizationFilterAttribute expectedInner = new Mock <AuthorizationFilterAttribute>().Object;
AuthorizationFilterAttributeTracer productUnderTest = new AuthorizationFilterAttributeTracer(expectedInner, new TestTraceWriter());
// Act
AuthorizationFilterAttribute actualInner = productUnderTest.Inner;
// Assert
Assert.Same(expectedInner, actualInner);
}
public static IEnumerable <IFilter> CreateFilterTracers(IFilter filter, ITraceWriter traceWriter)
{
List <IFilter> filters = new List <IFilter>();
bool addedActionAttributeTracer = false;
bool addedAuthorizationAttributeTracer = false;
bool addedExceptionAttributeTracer = false;
ActionFilterAttribute actionFilterAttribute = filter as ActionFilterAttribute;
if (actionFilterAttribute != null)
{
filters.Add(new ActionFilterAttributeTracer(actionFilterAttribute, traceWriter));
addedActionAttributeTracer = true;
}
AuthorizationFilterAttribute authorizationFilterAttribute = filter as AuthorizationFilterAttribute;
if (authorizationFilterAttribute != null)
{
filters.Add(new AuthorizationFilterAttributeTracer(authorizationFilterAttribute, traceWriter));
addedAuthorizationAttributeTracer = true;
}
ExceptionFilterAttribute exceptionFilterAttribute = filter as ExceptionFilterAttribute;
if (exceptionFilterAttribute != null)
{
filters.Add(new ExceptionFilterAttributeTracer(exceptionFilterAttribute, traceWriter));
addedExceptionAttributeTracer = true;
}
// Do not add an IActionFilter tracer if we already added an ActionFilterAttribute tracer
IActionFilter actionFilter = filter as IActionFilter;
if (actionFilter != null && !addedActionAttributeTracer)
{
filters.Add(new ActionFilterTracer(actionFilter, traceWriter));
}
// Do not add an IAuthorizationFilter tracer if we already added an AuthorizationFilterAttribute tracer
IAuthorizationFilter authorizationFilter = filter as IAuthorizationFilter;
if (authorizationFilter != null && !addedAuthorizationAttributeTracer)
{
filters.Add(new AuthorizationFilterTracer(authorizationFilter, traceWriter));
}
// Do not add an IExceptionFilter tracer if we already added an ExceptoinFilterAttribute tracer
IExceptionFilter exceptionFilter = filter as IExceptionFilter;
if (exceptionFilter != null && !addedExceptionAttributeTracer)
{
filters.Add(new ExceptionFilterTracer(exceptionFilter, traceWriter));
}
if (filters.Count == 0)
{
filters.Add(new FilterTracer(filter, traceWriter));
}
return(filters);
}
public AuthorizationFilterAttributeTracer(AuthorizationFilterAttribute innerFilter, ITraceWriter traceStore)
{
_innerFilter = innerFilter;
_traceStore = traceStore;
}
