public void ExecuteAsync_CallsRequestContextPrincipalGet()
{
// Arrange
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IAuthenticationFilter filter = CreateStubFilter();
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
int calls = 0;
Mock<HttpRequestContext> requestContextMock = new Mock<HttpRequestContext>();
requestContextMock.Setup(c => c.Principal).Callback(() =>
{
calls++;
});
controller.RequestContext = requestContextMock.Object;
IHttpActionResult innerResult = CreateStubActionResult();
IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(1, calls);
}
public void ExecuteAsync_DelegatesToInnerResult_WhenFiltersIsEmpty()
{
// Arrange
using (HttpResponseMessage expectedResponse = CreateResponse())
{
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IAuthenticationFilter[] filters = new IAuthenticationFilter[0];
int calls = 0;
CancellationToken cancellationToken;
IHttpActionResult innerResult = CreateActionResult((t) =>
{
calls++;
cancellationToken = t;
return Task.FromResult(expectedResponse);
});
IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);
CancellationToken expectedCancellationToken = CreateCancellationToken();
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(expectedCancellationToken);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(1, calls);
Assert.Equal(expectedCancellationToken, cancellationToken);
Assert.Same(expectedResponse, response);
}
}
public void ExecuteAsync_CallsPrincipalServiceGetCurrentPrincipal()
{
// Arrange
HttpActionContext context = CreateContext();
IAuthenticationFilter filter = CreateStubFilter();
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
int calls = 0;
HttpRequestMessage request = null;
IHostPrincipalService principalService = CreatePrincipalService((r) =>
{
calls++;
request = r;
return CreateDummyPrincipal();
});
IHttpActionResult innerResult = CreateStubActionResult();
using (HttpRequestMessage expectedRequest = CreateRequest())
{
IHttpActionResult product = CreateProductUnderTest(context, filters, principalService, expectedRequest,
innerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(1, calls);
Assert.Same(expectedRequest, request);
}
}
internal HostAuthenticationAttribute(IAuthenticationFilter innerFilter)
{
if (innerFilter == null)
{
throw new ArgumentNullException("innerFilter");
}
_innerFilter = innerFilter;
}
public AuthenticationFilterResult(HttpActionContext context, ApiController controller,
IAuthenticationFilter[] filters, IHttpActionResult innerResult)
{
Contract.Assert(context != null);
Contract.Assert(controller != null);
Contract.Assert(filters != null);
Contract.Assert(innerResult != null);
_context = context;
_controller = controller;
_filters = filters;
_innerResult = innerResult;
}
public AuthenticationFilterResult(HttpActionContext context, IAuthenticationFilter[] filters,
IHostPrincipalService principalService, HttpRequestMessage request, IHttpActionResult innerResult)
{
Contract.Assert(context != null);
Contract.Assert(filters != null);
Contract.Assert(principalService != null);
Contract.Assert(innerResult != null);
_context = context;
_filters = filters;
_principalService = principalService;
_request = request;
_innerResult = innerResult;
}
public void AuthenticateAsync_DelegatesToInnerFilter()
{
// Arrange
Task expectedTask = CreateTask();
HttpAuthenticationContext context = CreateAuthenticationContext();
CancellationToken cancellationToken = CreateCancellationToken();
Mock <IAuthenticationFilter> spyMock = new Mock <IAuthenticationFilter>(
MockBehavior.Strict
);
spyMock
.Setup(f => f.AuthenticateAsync(context, cancellationToken))
.Returns(expectedTask);
IAuthenticationFilter spy = spyMock.Object;
IAuthenticationFilter product = CreateProductUnderTest(spy);
// Act
Task task = product.AuthenticateAsync(context, cancellationToken);
// Assert
Assert.Same(expectedTask, task);
}
public void AuthenticationFilters_ReturnsActionScopeAuthenticationFilters_WhenOverrideScopeIsAction()
{
// Arrange
IAuthenticationFilter expectedGlobalFilter = CreateDummyAuthenticationFilter();
FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global);
IAuthenticationFilter expectedControllerFilter = CreateDummyAuthenticationFilter();
FilterInfo controllerFilter = new FilterInfo(expectedControllerFilter, FilterScope.Controller);
IAuthenticationFilter expectedActionFilter = CreateDummyAuthenticationFilter();
FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action);
FilterInfo overrideFilter = new FilterInfo(CreateOverride(typeof(IAuthenticationFilter)),
FilterScope.Action);
IEnumerable <FilterInfo> filters = new FilterInfo[] { globalFilter, controllerFilter, actionFilter, overrideFilter };
FilterGrouping product = CreateProductUnderTest(filters);
// Act
IAuthenticationFilter[] authenticationFilters = product.AuthenticationFilters;
// Assert
Assert.NotNull(authenticationFilters);
Assert.Equal(1, authenticationFilters.Length);
Assert.Same(expectedActionFilter, authenticationFilters[0]);
}
public void AuthenticateAsync_DelegatesToInnerFilter()
{
// Arrange
HttpAuthenticationContext expectedAuthenticationContext = CreateAuthenticationContext();
CancellationToken expectedCancellationToken = CreateCancellationToken();
Mock <IAuthenticationFilter> mock = new Mock <IAuthenticationFilter>();
int calls = 0;
mock.Setup(f => f.AuthenticateAsync(expectedAuthenticationContext, expectedCancellationToken)).Callback(
() => { calls++; }).Returns(() => Task.FromResult <object>(null));
IAuthenticationFilter filter = mock.Object;
ITraceWriter tracer = CreateStubTracer();
IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);
// Act
Task task = product.AuthenticateAsync(expectedAuthenticationContext, expectedCancellationToken);
// Assert
Assert.NotNull(task);
task.Wait();
Assert.Equal(1, calls);
}
public async Task ExecuteAsync_CallsFilterChallengeAsync_WithInnerResult_WhenNoFilterReturnsFailure()
{
// Arrange
HttpActionContext expectedContext = CreateContext();
ApiController controller = CreateController();
int calls = 0;
HttpActionContext context = null;
IHttpActionResult innerResult = null;
CancellationToken cancellationToken = default(CancellationToken);
IAuthenticationFilter filter = CreateAuthenticationFilterChallenge(
(c, t) =>
{
calls++;
context = c.ActionContext;
innerResult = c.Result;
cancellationToken = t;
}
);
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
IHttpActionResult expectedInnerResult = CreateStubActionResult();
CancellationToken expectedCancellationToken = CreateCancellationToken();
IHttpActionResult product = CreateProductUnderTest(
expectedContext,
controller,
filters,
expectedInnerResult
);
// Act
await product.ExecuteAsync(expectedCancellationToken);
// Assert
Assert.Equal(1, calls);
Assert.Same(expectedContext, context);
Assert.Same(expectedInnerResult, innerResult);
Assert.Equal(expectedCancellationToken, cancellationToken);
}
public void AuthenticateAsync_Traces_ErrorResult()
{
// Arrange
IHttpActionResult result = new AuthenticationFailureResult();
CancellationToken cancellationToken = CreateCancellationToken();
Mock <IAuthenticationFilter> filterMock = new Mock <IAuthenticationFilter>();
filterMock.Setup(f => f.AuthenticateAsync(It.IsAny <HttpAuthenticationContext>(),
It.IsAny <CancellationToken>()))
.Callback((HttpAuthenticationContext context,
CancellationToken token) => context.ErrorResult = result)
.Returns(Task.FromResult <object>(null));
TraceRecord record = null;
ITraceWriter tracer = CreateTracer((r) => { record = r; });
IAuthenticationFilter product = CreateProductUnderTest(filterMock.Object, tracer);
const string expectedMessage = "The authentication filter encountered an error. ErrorResult="
+ "'System.Web.Http.Tracing.Tracers.AuthenticationFilterTracerTests+AuthenticationFailureResult'.";
using (HttpRequestMessage expectedRequest = CreateRequest())
{
HttpAuthenticationContext authenticationContext = CreateAuthenticationContext(expectedRequest);
// Act
Task task = product.AuthenticateAsync(authenticationContext, cancellationToken);
// Assert
Assert.NotNull(task);
task.Wait();
Assert.NotNull(record);
Assert.Same(expectedRequest, record.Request);
Assert.Same(TraceCategories.FiltersCategory, record.Category);
Assert.Equal(TraceLevel.Info, record.Level);
Assert.Equal(TraceKind.End, record.Kind);
Assert.Equal(filterMock.Object.GetType().Name, record.Operator);
Assert.Equal("AuthenticateAsync", record.Operation);
Assert.Null(record.Exception);
Assert.Equal(expectedMessage, record.Message);
}
}
public async Task ChallengeAsync_Traces_WhenContextIsNull()
{
// Arrange
CancellationToken cancellationToken = CreateCancellationToken();
IAuthenticationFilter filter = CreateStubFilter();
TraceRecord record = null;
ITraceWriter tracer = CreateTracer(
(r) =>
{
record = r;
}
);
IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);
HttpAuthenticationChallengeContext context = null;
// Act
await product.ChallengeAsync(context, cancellationToken);
// Assert
Assert.NotNull(record);
Assert.Null(record.Request);
}
public void ExecuteAsync_CallsFilterChallengeAsync_WithInnerResult_WhenNoFilterReturnsFailure()
{
// Arrange
HttpActionContext expectedContext = CreateContext();
ApiController controller = CreateController();
int calls = 0;
HttpActionContext context = null;
IHttpActionResult innerResult = null;
CancellationToken cancellationToken = default(CancellationToken);
IAuthenticationFilter filter = CreateAuthenticationFilterChallenge((c, t) =>
{
calls++;
context = c.ActionContext;
innerResult = c.Result;
cancellationToken = t;
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
IHostPrincipalService principalService = CreateStubPrincipalService();
IHttpActionResult expectedInnerResult = CreateStubActionResult();
CancellationToken expectedCancellationToken = CreateCancellationToken();
using (HttpRequestMessage request = CreateRequest())
{
IHttpActionResult product = CreateProductUnderTest(expectedContext, controller, filters,
principalService, request, expectedInnerResult);
// Act
Task <HttpResponseMessage> task = product.ExecuteAsync(expectedCancellationToken);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(1, calls);
Assert.Same(expectedContext, context);
Assert.Same(expectedInnerResult, innerResult);
Assert.Equal(expectedCancellationToken, cancellationToken);
}
}
public void ExecuteAsync_CallsPrincipalServiceSetCurrentPrincipal_WhenFilterReturnsSuccess()
{
// Arrange
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IPrincipal expectedPrincipal = CreateDummyPrincipal();
IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) =>
{
c.Principal = expectedPrincipal;
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
int calls = 0;
HttpRequestMessage request = null;
IPrincipal principal = null;
IHostPrincipalService principalService = CreatePrincipalService((p, r) =>
{
calls++;
request = r;
principal = p;
});
IHttpActionResult innerResult = CreateStubActionResult();
using (HttpRequestMessage expectedRequest = CreateRequest())
{
IHttpActionResult product = CreateProductUnderTest(context, controller, filters, principalService,
expectedRequest, innerResult);
// Act
Task <HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(1, calls);
Assert.Same(expectedPrincipal, principal);
Assert.Same(expectedRequest, request);
}
}
public void AuthenticateAsync_Traces(bool withIdentity, string expectedMessage)
{
// Arrange
CancellationToken cancellationToken = CreateCancellationToken();
Mock <IAuthenticationFilter> filterMock = new Mock <IAuthenticationFilter>();
filterMock.Setup(f => f.AuthenticateAsync(It.IsAny <HttpAuthenticationContext>(),
It.IsAny <CancellationToken>()))
.Callback((HttpAuthenticationContext context,
CancellationToken token) => context.Principal = CreateDummyPrincipal(withIdentity))
.Returns(Task.FromResult <object>(null));
IAuthenticationFilter filter = filterMock.Object;
TraceRecord record = null;
ITraceWriter tracer = CreateTracer((r) => { record = r; });
IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);
using (HttpRequestMessage expectedRequest = CreateRequest())
{
HttpAuthenticationContext authenticationContext = CreateAuthenticationContext(expectedRequest,
isPrincipalSet: false);
// Act
Task task = product.AuthenticateAsync(authenticationContext, cancellationToken);
// Assert
Assert.NotNull(task);
task.Wait();
Assert.NotNull(record);
Assert.Same(expectedRequest, record.Request);
Assert.Same(TraceCategories.FiltersCategory, record.Category);
Assert.Equal(TraceLevel.Info, record.Level);
Assert.Equal(TraceKind.End, record.Kind);
Assert.Equal(filter.GetType().Name, record.Operator);
Assert.Equal("AuthenticateAsync", record.Operation);
Assert.Null(record.Exception);
Assert.Equal(expectedMessage, record.Message);
}
}
public void ExecuteAsync_DelegatesToErrorResult_WhenFilterReturnsFailure()
{
// Arrange
using (HttpRequestMessage request = CreateRequest())
using (HttpResponseMessage expectedResponse = CreateResponse())
{
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
int calls = 0;
CancellationToken cancellationToken;
IHttpActionResult errorResult = CreateActionResult((t) =>
{
calls++;
cancellationToken = t;
return(Task.FromResult(expectedResponse));
});
IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) =>
{
c.ErrorResult = errorResult;
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
IHostPrincipalService principalService = CreateStubPrincipalService();
IHttpActionResult innerResult = CreateDummyActionResult();
IHttpActionResult product = CreateProductUnderTest(context, controller, filters, principalService,
request, innerResult);
CancellationToken expectedCancellationToken = CreateCancellationToken();
// Act
Task <HttpResponseMessage> task = product.ExecuteAsync(expectedCancellationToken);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(1, calls);
Assert.Equal(expectedCancellationToken, cancellationToken);
Assert.Same(expectedResponse, response);
}
}
public async Task ExecuteAsync_DoesNotSetPrincipal_WhenNoFilterReturnsSuccess()
{
// Arrange
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IPrincipal principal = CreateDummyPrincipal();
IAuthenticationFilter filter = CreateAuthenticationFilter(
(c, t) => Task.FromResult <object>(null)
);
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter, filter };
int calls = 0;
Mock <HttpRequestContext> requestContextMock = new Mock <HttpRequestContext>();
requestContextMock
.SetupSet(c => c.Principal = It.IsAny <IPrincipal>())
.Callback <IPrincipal>(
(i) =>
{
calls++;
}
);
controller.RequestContext = requestContextMock.Object;
IHttpActionResult innerResult = CreateStubActionResult();
IHttpActionResult product = CreateProductUnderTest(
context,
controller,
filters,
innerResult
);
// Act
await product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.Equal(0, calls);
}
public async Task ChallengeAsync_DelegatesToInnerFilter()
{
// Arrange
HttpAuthenticationChallengeContext expectedChallengeContext = CreateChallengeContext();
CancellationToken expectedCancellationToken = CreateCancellationToken();
IHttpActionResult expectedInnerResult = CreateDummyActionResult();
IHttpActionResult expectedResult = CreateDummyActionResult();
Mock <IAuthenticationFilter> mock = new Mock <IAuthenticationFilter>();
int calls = 0;
mock.Setup(f => f.ChallengeAsync(expectedChallengeContext, expectedCancellationToken))
.Callback(() => { calls++; })
.Returns(() => Task.FromResult(expectedResult));
IAuthenticationFilter filter = mock.Object;
ITraceWriter tracer = CreateStubTracer();
IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);
// Act
await product.ChallengeAsync(expectedChallengeContext, expectedCancellationToken);
// Assert
Assert.Equal(1, calls);
}
public async Task AuthenticateAsync_Traces_DidNothing()
{
// Arrange
CancellationToken cancellationToken = CreateCancellationToken();
IAuthenticationFilter filter = CreateStubFilter();
TraceRecord record = null;
ITraceWriter tracer = CreateTracer(
(r) =>
{
record = r;
}
);
IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);
const string expectedMessage =
"The authentication filter did not encounter an error or set a principal.";
using (HttpRequestMessage expectedRequest = CreateRequest())
{
HttpAuthenticationContext authenticationContext = CreateAuthenticationContext(
expectedRequest
);
// Act
await product.AuthenticateAsync(authenticationContext, cancellationToken);
// Assert
Assert.NotNull(record);
Assert.Same(expectedRequest, record.Request);
Assert.Same(TraceCategories.FiltersCategory, record.Category);
Assert.Equal(TraceLevel.Info, record.Level);
Assert.Equal(TraceKind.End, record.Kind);
Assert.Equal(filter.GetType().Name, record.Operator);
Assert.Equal("AuthenticateAsync", record.Operation);
Assert.Null(record.Exception);
Assert.Equal(expectedMessage, record.Message);
}
}
public async Task ExecuteAsync_DelegatesToInnerResult_WhenFiltersIsEmpty()
{
// Arrange
using (HttpResponseMessage expectedResponse = CreateResponse())
{
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IAuthenticationFilter[] filters = new IAuthenticationFilter[0];
int calls = 0;
CancellationToken cancellationToken;
IHttpActionResult innerResult = CreateActionResult(
(t) =>
{
calls++;
cancellationToken = t;
return(Task.FromResult(expectedResponse));
}
);
IHttpActionResult product = CreateProductUnderTest(
context,
controller,
filters,
innerResult
);
CancellationToken expectedCancellationToken = CreateCancellationToken();
// Act
HttpResponseMessage response = await product.ExecuteAsync(
expectedCancellationToken
);
// Assert
Assert.Equal(1, calls);
Assert.Equal(expectedCancellationToken, cancellationToken);
Assert.Same(expectedResponse, response);
}
}
public void ExecuteAsync_PassesPrincipalFromFirstFilterSuccessToSecondFilter()
{
// Arrange
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IPrincipal expectedPrincipal = CreateDummyPrincipal();
IAuthenticationFilter firstFilter = CreateAuthenticationFilter((c, t) =>
{
c.Principal = expectedPrincipal;
});
IPrincipal principal = null;
IAuthenticationFilter secondFilter = CreateAuthenticationFilter((c, t) =>
{
if (c != null)
{
principal = c.Principal;
}
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { firstFilter, secondFilter };
IHostPrincipalService principalService = CreateStubPrincipalService();
IHttpActionResult innerResult = CreateStubActionResult();
using (HttpRequestMessage request = CreateRequest())
{
IHttpActionResult product = CreateProductUnderTest(context, controller, filters, principalService,
request, innerResult);
// Act
Task <HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Same(expectedPrincipal, principal);
}
}
public async Task ChallengeAsync_Traces()
{
// Arrange
CancellationToken cancellationToken = CreateCancellationToken();
IAuthenticationFilter filter = CreateStubFilter();
TraceRecord record = null;
ITraceWriter tracer = CreateTracer(
(r) =>
{
record = r;
}
);
IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);
IHttpActionResult innerResult = CreateDummyActionResult();
using (HttpRequestMessage expectedRequest = CreateRequest())
{
HttpAuthenticationChallengeContext context = CreateChallengeContext(
expectedRequest,
innerResult
);
// Act
await product.ChallengeAsync(context, cancellationToken);
// Assert
Assert.NotNull(record);
Assert.Same(expectedRequest, record.Request);
Assert.Same(TraceCategories.FiltersCategory, record.Category);
Assert.Equal(TraceLevel.Info, record.Level);
Assert.Equal(TraceKind.End, record.Kind);
Assert.Equal(filter.GetType().Name, record.Operator);
Assert.Equal("ChallengeAsync", record.Operation);
Assert.Null(record.Exception);
Assert.Null(record.Message);
}
}
public async Task ChallengeAsync_CreatesOwinChallengeWithAuthenticationType_WhenNoChallengeExists()
{
// Arrange
string expectedAuthenticationType = "AuthenticationType";
IAuthenticationFilter filter = CreateProductUnderTest(expectedAuthenticationType);
IHttpActionResult result = CreateDummyActionResult();
IAuthenticationManager authenticationManager = CreateAuthenticationManager(
(AuthenticationResponseChallenge)null
);
IOwinContext owinContext = CreateOwinContext(authenticationManager);
using (HttpRequestMessage request = CreateRequest(owinContext))
{
HttpAuthenticationChallengeContext context = CreateChallengeContext(
request,
result
);
// Act
await filter.ChallengeAsync(context, CancellationToken.None);
}
// Assert
AuthenticationResponseChallenge challenge =
authenticationManager.AuthenticationResponseChallenge;
Assert.NotNull(challenge);
string[] authenticationTypes = challenge.AuthenticationTypes;
Assert.NotNull(authenticationTypes);
string authenticationType = Assert.Single(authenticationTypes);
Assert.Same(expectedAuthenticationType, authenticationType);
AuthenticationProperties extra = challenge.Properties;
Assert.NotNull(extra);
}
public async Task ExecuteAsync_UpdatesRequestContextPrincipal_WhenFilterReturnsSuccess()
{
// Arrange
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IPrincipal expectedPrincipal = CreateDummyPrincipal();
IAuthenticationFilter filter = CreateAuthenticationFilter(
(c, t) =>
{
c.Principal = expectedPrincipal;
}
);
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
IPrincipal principal = null;
IHttpActionResult innerResult = CreateActionResult(
(c) =>
{
principal = controller.User;
return(Task.FromResult <HttpResponseMessage>(null));
}
);
IHttpActionResult product = CreateProductUnderTest(
context,
controller,
filters,
innerResult
);
// Act
await product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.Same(expectedPrincipal, principal);
}
public void SetUp() {
m_principalRegistry = new Mock<ID2LPrincipalDependencyRegistry>( MockBehavior.Strict );
m_requestAuthenticator = new Mock<IRequestAuthenticator>( MockBehavior.Strict );
m_log = new Mock<ILog>( MockBehavior.Loose );
var logProvider = new Mock<ILogProvider>( MockBehavior.Strict );
logProvider
.Setup( lp => lp.Get( typeof( OAuth2AuthenticationFilter ).FullName ) )
.Returns( m_log.Object );
m_authenticationFilter = new OAuth2AuthenticationFilter(
logProvider.Object,
m_requestAuthenticator.Object,
m_principalRegistry.Object
);
var request = new HttpRequestMessage();
var controllerContext = new HttpControllerContext();
controllerContext.Request = request;
var actionContext = new HttpActionContext();
actionContext.ControllerContext = controllerContext;
m_authenticationContext = new HttpAuthenticationContext( actionContext, null );
}
public WebApiConfig(IAuthenticationFilter authenticationFilter, ILogger logger)
{
AuthenticationFilter = authenticationFilter;
Logger = logger;
}
private static AuthenticationFilterResult CreateProductUnderTest(HttpActionContext context,
ApiController controller, IAuthenticationFilter[] filters, IHttpActionResult innerResult)
{
return new AuthenticationFilterResult(context, controller, filters, innerResult);
}
public void ExecuteAsync_DoesNotSetPrincipal_WhenNoFilterReturnsSuccess()
{
// Arrange
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IPrincipal principal = CreateDummyPrincipal();
IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) => Task.FromResult<object>(null));
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter, filter };
int calls = 0;
Mock<HttpRequestContext> requestContextMock = new Mock<HttpRequestContext>();
requestContextMock
.SetupSet(c => c.Principal = It.IsAny<IPrincipal>())
.Callback<IPrincipal>((i) => { calls++; });
controller.RequestContext = requestContextMock.Object;
IHttpActionResult innerResult = CreateStubActionResult();
IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(0, calls);
}
public void ExecuteAsync_CallsSecondFilterChallengeAsync_WithFirstChallengeResult()
{
// Arrange
HttpActionContext expectedContext = CreateContext();
ApiController controller = CreateController();
IHttpActionResult expectedInnerResult = CreateDummyActionResult();
int calls = 0;
HttpActionContext context = null;
IHttpActionResult result = null;
CancellationToken cancellationToken = default(CancellationToken);
IAuthenticationFilter firstFilter = CreateAuthenticationFilterChallenge((c, t) =>
{
c.Result = expectedInnerResult;
});
IAuthenticationFilter secondFilter = CreateAuthenticationFilterChallenge((c, t) =>
{
calls++;
context = c.ActionContext;
result = c.Result;
cancellationToken = t;
c.Result = CreateStubActionResult();
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { firstFilter, secondFilter };
IHttpActionResult originalInnerResult = CreateDummyActionResult();
CancellationToken expectedCancellationToken = CreateCancellationToken();
IHttpActionResult product = CreateProductUnderTest(expectedContext, controller, filters,
originalInnerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(expectedCancellationToken);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(1, calls);
Assert.Same(expectedContext, context);
Assert.Same(expectedInnerResult, result);
Assert.Equal(expectedCancellationToken, cancellationToken);
}
public void ExecuteAsync_DelegatesToErrorResult_WhenFilterReturnsFailure()
{
// Arrange
using (HttpRequestMessage request = CreateRequest())
using (HttpResponseMessage expectedResponse = CreateResponse())
{
HttpActionContext context = CreateContext();
int calls = 0;
CancellationToken cancellationToken;
IHttpActionResult errorResult = CreateActionResult((t) =>
{
calls++;
cancellationToken = t;
return Task.FromResult(expectedResponse);
});
IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) =>
{
c.ErrorResult = errorResult;
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
IHostPrincipalService principalService = CreateStubPrincipalService();
IHttpActionResult innerResult = CreateDummyActionResult();
IHttpActionResult product = CreateProductUnderTest(context, filters, principalService, request,
innerResult);
CancellationToken expectedCancellationToken = CreateCancellationToken();
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(expectedCancellationToken);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(1, calls);
Assert.Equal(expectedCancellationToken, cancellationToken);
Assert.Same(expectedResponse, response);
}
}
public void ExecuteAsync_PassesPrincipalFromFirstFilterSuccessToSecondFilter()
{
// Arrange
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IPrincipal expectedPrincipal = CreateDummyPrincipal();
IAuthenticationFilter firstFilter = CreateAuthenticationFilter((c, t) =>
{
c.Principal = expectedPrincipal;
});
IPrincipal principal = null;
IAuthenticationFilter secondFilter = CreateAuthenticationFilter((c, t) =>
{
if (c != null)
{
principal = c.Principal;
}
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { firstFilter, secondFilter };
IHttpActionResult innerResult = CreateStubActionResult();
IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Same(expectedPrincipal, principal);
}
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));
}
IAuthenticationFilter authenticationFilter = filter as IAuthenticationFilter;
if (authenticationFilter != null)
{
filters.Add(new AuthenticationFilterTracer(authenticationFilter, 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));
}
IOverrideFilter overrideFilter = filter as IOverrideFilter;
if (overrideFilter != null)
{
filters.Add(new OverrideFilterTracer(overrideFilter, traceWriter));
}
if (filters.Count == 0)
{
filters.Add(new FilterTracer(filter, traceWriter));
}
return(filters);
}
public void Add(IAuthenticationFilter filter, int?order = null)
{
Add(filter, order);
}
private static AuthenticationFilterResult CreateProductUnderTest(HttpActionContext context,
IAuthenticationFilter[] filters, IHostPrincipalService principalService, HttpRequestMessage request,
IHttpActionResult innerResult)
{
return new AuthenticationFilterResult(context, filters, principalService, request, innerResult);
}
public void ExecuteAsync_CallsFilterAuthenticateAsync()
{
// Arrange
HttpActionContext expectedActionContext = CreateContext();
int calls = 0;
HttpAuthenticationContext authenticationContext = null;
CancellationToken cancellationToken = default(CancellationToken);
IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) =>
{
calls++;
authenticationContext = c;
cancellationToken = t;
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
IPrincipal expectedPrincipal = CreateDummyPrincipal();
IHostPrincipalService principalService = CreateStubPrincipalService(expectedPrincipal);
IHttpActionResult innerResult = CreateStubActionResult();
CancellationToken expectedCancellationToken = CreateCancellationToken();
using (HttpRequestMessage request = CreateRequest())
{
IHttpActionResult product = CreateProductUnderTest(expectedActionContext, filters, principalService,
request, innerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(expectedCancellationToken);
// Assert
HttpResponseMessage ignore = task.Result;
}
Assert.Equal(1, calls);
Assert.NotNull(authenticationContext);
HttpActionContext actionContext = authenticationContext.ActionContext;
Assert.Same(expectedActionContext, actionContext);
IPrincipal principal = authenticationContext.Principal;
Assert.Same(expectedPrincipal, principal);
Assert.Equal(expectedCancellationToken, cancellationToken);
}
private static HostAuthenticationAttribute CreateProductUnderTest(IAuthenticationFilter innerFilter)
{
return(new HostAuthenticationAttribute(innerFilter));
}
public void ExecuteAsync_CallsFilterChallengeAsync_WithErrorResult_WhenFilterReturnsFailure()
{
// Arrange
HttpActionContext expectedContext = CreateContext();
IHttpActionResult expectedErrorResult = CreateDummyActionResult();
int calls = 0;
HttpActionContext context = null;
IHttpActionResult innerResult = null;
CancellationToken cancellationToken = default(CancellationToken);
IAuthenticationFilter filter = CreateAuthenticationFilter(
(c, t) =>
{
c.ErrorResult = expectedErrorResult;
},
(c, t) =>
{
calls++;
context = c.ActionContext;
innerResult = c.Result;
cancellationToken = t;
c.Result = CreateStubActionResult();
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
IHostPrincipalService principalService = CreateStubPrincipalService();
IHttpActionResult originalInnerResult = CreateDummyActionResult();
CancellationToken expectedCancellationToken = CreateCancellationToken();
using (HttpRequestMessage request = CreateRequest())
{
IHttpActionResult product = CreateProductUnderTest(expectedContext, filters, principalService, request,
originalInnerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(expectedCancellationToken);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(1, calls);
Assert.Same(expectedContext, context);
Assert.Same(expectedErrorResult, innerResult);
Assert.Equal(expectedCancellationToken, cancellationToken);
}
}
public void ExecuteAsync_DoesNotSetPrincipal_WhenNoFilterReturnsSuccess()
{
// Arrange
HttpActionContext context = CreateContext();
IPrincipal principal = CreateDummyPrincipal();
IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) => Task.FromResult<object>(null));
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter, filter };
int calls = 0;
IHostPrincipalService principalService = CreatePrincipalService((p, r) =>
{
calls++;
});
IHttpActionResult innerResult = CreateStubActionResult();
using (HttpRequestMessage expectedRequest = CreateRequest())
{
IHttpActionResult product = CreateProductUnderTest(context, filters, principalService, expectedRequest,
innerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(0, calls);
}
}
public void ExecuteAsync_CallsFilterAuthenticateAsync()
{
// Arrange
HttpActionContext expectedActionContext = CreateContext();
ApiController controller = CreateController();
int calls = 0;
HttpAuthenticationContext authenticationContext = null;
CancellationToken cancellationToken = default(CancellationToken);
IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) =>
{
calls++;
authenticationContext = c;
cancellationToken = t;
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
IPrincipal expectedPrincipal = CreateDummyPrincipal();
Mock<HttpRequestContext> requestContextMock = new Mock<HttpRequestContext>(MockBehavior.Strict);
requestContextMock.Setup(c => c.Principal).Returns(expectedPrincipal);
controller.RequestContext = requestContextMock.Object;
IHttpActionResult innerResult = CreateStubActionResult();
CancellationToken expectedCancellationToken = CreateCancellationToken();
IHttpActionResult product = CreateProductUnderTest(expectedActionContext, controller, filters,
innerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(expectedCancellationToken);
// Assert
HttpResponseMessage ignore = task.Result;
Assert.Equal(1, calls);
Assert.NotNull(authenticationContext);
HttpActionContext actionContext = authenticationContext.ActionContext;
Assert.Same(expectedActionContext, actionContext);
IPrincipal principal = authenticationContext.Principal;
Assert.Same(expectedPrincipal, principal);
Assert.Equal(expectedCancellationToken, cancellationToken);
}
public void ExecuteAsync_DoesNotCallSecondFilterAuthenticateOrInnerResult_WhenFirstFilterReturnsFailure()
{
// Arrange
using (HttpResponseMessage expectedResponse = CreateResponse())
{
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IHttpActionResult errorResult = CreateActionResult((t) => Task.FromResult(expectedResponse));
IAuthenticationFilter firstFilter = CreateAuthenticationFilter((c, t) =>
{
c.ErrorResult = errorResult;
});
int calls = 0;
IAuthenticationFilter secondFilter = CreateAuthenticationFilter((c, t) =>
{
calls++;
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { firstFilter, secondFilter };
IHttpActionResult innerResult = CreateDummyActionResult();
IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);
CancellationToken expectedCancellationToken = CreateCancellationToken();
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(expectedCancellationToken);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Equal(0, calls);
}
}
private static HostAuthenticationAttribute CreateProductUnderTest(IAuthenticationFilter innerFilter)
{
return new HostAuthenticationAttribute(innerFilter);
}
public void ExecuteAsync_UpdatesRequestContextPrincipal_WhenFilterReturnsSuccess()
{
// Arrange
HttpActionContext context = CreateContext();
ApiController controller = CreateController();
IPrincipal expectedPrincipal = CreateDummyPrincipal();
IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) =>
{
c.Principal = expectedPrincipal;
});
IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
IPrincipal principal = null;
IHttpActionResult innerResult = CreateActionResult((c) =>
{
principal = controller.User;
return Task.FromResult<HttpResponseMessage>(null);
});
IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);
// Act
Task<HttpResponseMessage> task = product.ExecuteAsync(CancellationToken.None);
// Assert
Assert.NotNull(task);
HttpResponseMessage response = task.Result;
Assert.Same(expectedPrincipal, principal);
}
private static AuthenticationFilterTracer CreateProductUnderTest(IAuthenticationFilter innerFilter,
ITraceWriter traceWriter)
{
return(new AuthenticationFilterTracer(innerFilter, traceWriter));
}
private static AuthenticationFilterTracer CreateProductUnderTest(IAuthenticationFilter innerFilter,
ITraceWriter traceWriter)
{
return new AuthenticationFilterTracer(innerFilter, traceWriter);
}
public AuthenticationFilterOverride(IAuthenticationFilter wrappedFilter)
{
this._wrappedFilter = wrappedFilter;
}
public AuthenticationFilterOverride(IAuthenticationFilter wrappedFilter)
{
_wrappedFilter = wrappedFilter;
}
