public void SendAsync_SuppressesAuthenticationChallenges_WhenNoChallengeIsSet() { // Arrange IHostPrincipalService principalService = CreateStubPrincipalService(); HttpMessageHandler inner = CreateStubHandler(); HttpMessageHandler handler = CreateProductUnderTest(principalService, inner); IOwinContext context = CreateOwinContext(); using (HttpRequestMessage request = CreateRequestWithOwinContext(context)) { // Act HttpResponseMessage ignore = handler.SendAsync(request, CancellationToken.None).Result; } // Assert IAuthenticationManager authenticationManager = context.Authentication; AuthenticationResponseChallenge challenge = authenticationManager.AuthenticationResponseChallenge; Assert.NotNull(challenge); string[] authenticationTypes = challenge.AuthenticationTypes; Assert.NotNull(authenticationTypes); Assert.Equal(1, authenticationTypes.Length); string authenticationType = authenticationTypes[0]; Assert.Null(authenticationType); }
public void SendAsync_DelegatesToInnerHandler() { // Arrange IHostPrincipalService principalService = CreateStubPrincipalService(); HttpRequestMessage request = null; CancellationToken cancellationToken = default(CancellationToken); Task <HttpResponseMessage> expectedResult = new Task <HttpResponseMessage>(() => null); HttpMessageHandler innerHandler = new LambdaHttpMessageHandler((r, c) => { request = r; cancellationToken = c; return(expectedResult); }); HttpMessageHandler handler = CreateProductUnderTest(principalService, innerHandler); CancellationToken expectedCancellationToken = new CancellationToken(true); using (HttpRequestMessage expectedRequest = new HttpRequestMessage()) { // Act Task <HttpResponseMessage> result = handler.SendAsync(expectedRequest, expectedCancellationToken); // Assert Assert.Same(expectedRequest, request); Assert.Equal(expectedCancellationToken, cancellationToken); Assert.Same(expectedResult, result); } }
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_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); } }
public void ExecuteAsync_DelegatesToInnerResult_WhenFiltersIsEmpty() { // Arrange using (HttpRequestMessage request = CreateRequest()) using (HttpResponseMessage expectedResponse = CreateResponse()) { HttpActionContext context = CreateContext(); IAuthenticationFilter[] filters = new IAuthenticationFilter[0]; IHostPrincipalService principalService = CreateStubPrincipalService(); int calls = 0; CancellationToken cancellationToken; IHttpActionResult innerResult = CreateActionResult((t) => { calls++; cancellationToken = t; return(Task.FromResult(expectedResponse)); }); 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_DoesNotCallSecondFilterAuthenticateOrInnerResult_WhenFirstFilterReturnsFailure() { // Arrange using (HttpRequestMessage request = CreateRequest()) using (HttpResponseMessage expectedResponse = CreateResponse()) { HttpActionContext context = CreateContext(); 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 }; 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(0, calls); } }
public void SendAsync_DelegatesToInnerHandler() { // Arrange IHostPrincipalService principalService = CreateStubPrincipalService(); HttpRequestMessage request = null; CancellationToken cancellationToken = default(CancellationToken); IOwinContext context = CreateOwinContext(); using (HttpResponseMessage expectedResponse = new HttpResponseMessage()) { HttpMessageHandler innerHandler = new LambdaHttpMessageHandler((r, c) => { request = r; cancellationToken = c; return(Task.FromResult(expectedResponse)); }); HttpMessageHandler handler = CreateProductUnderTest(principalService, innerHandler); CancellationToken expectedCancellationToken = new CancellationToken(true); using (HttpRequestMessage expectedRequest = CreateRequestWithOwinContext(context)) { // Act HttpResponseMessage response = handler.SendAsync(expectedRequest, expectedCancellationToken).Result; // Assert Assert.Same(expectedRequest, request); Assert.Equal(expectedCancellationToken, cancellationToken); Assert.Same(expectedResponse, response); } } }
public void SendAsync_LeavesAuthenticationChallenges_WhenExistingAuthenticationTypesIsNonEmpty() { // Arrange IHostPrincipalService principalService = CreateStubPrincipalService(); HttpMessageHandler inner = CreateStubHandler(); HttpMessageHandler handler = CreateProductUnderTest(principalService, inner); IOwinContext context = CreateOwinContext(); IAuthenticationManager authenticationManager = context.Authentication; AuthenticationProperties extraWrapper = new AuthenticationProperties(); string[] expectedAuthenticationTypes = new string[] { "Existing" }; IDictionary <string, string> expectedExtra = extraWrapper.Dictionary; authenticationManager.AuthenticationResponseChallenge = new AuthenticationResponseChallenge( expectedAuthenticationTypes, extraWrapper); using (HttpRequestMessage request = CreateRequestWithOwinContext(context)) { // Act HttpResponseMessage ignore = handler.SendAsync(request, CancellationToken.None).Result; } // Assert AuthenticationResponseChallenge challenge = authenticationManager.AuthenticationResponseChallenge; Assert.NotNull(challenge); Assert.Same(expectedAuthenticationTypes, challenge.AuthenticationTypes); AuthenticationProperties actualExtraWrapper = challenge.Properties; Assert.NotNull(actualExtraWrapper); Assert.Same(expectedExtra, actualExtraWrapper.Dictionary); }
public void SendAsync_SetsCurrentPrincipalToAnonymous_BeforeCallingInnerHandler() { // Arrange IPrincipal principalServiceCurrentPrincipal = null; IHostPrincipalService principalService = CreateSpyPrincipalService((p) => { principalServiceCurrentPrincipal = p; }); IPrincipal principalBeforeInnerHandler = null; HttpMessageHandler inner = new LambdaHttpMessageHandler((ignore1, ignore2) => { principalBeforeInnerHandler = principalServiceCurrentPrincipal; return(Task.FromResult <HttpResponseMessage>(null)); }); HttpMessageHandler handler = CreateProductUnderTest(principalService, inner); using (HttpRequestMessage request = new HttpRequestMessage()) { // Act handler.SendAsync(request, CancellationToken.None); } // Assert Assert.NotNull(principalBeforeInnerHandler); IIdentity identity = principalBeforeInnerHandler.Identity; Assert.NotNull(identity); Assert.False(identity.IsAuthenticated); Assert.Null(identity.Name); Assert.Null(identity.AuthenticationType); }
public void SuppressHostPrincipal_InsertsSuppressHostPrincipalMessageHandler() { // Arrange IHostPrincipalService expectedPrincipalService = new Mock <IHostPrincipalService>( MockBehavior.Strict).Object; DelegatingHandler existingHandler = new Mock <DelegatingHandler>(MockBehavior.Strict).Object; using (HttpConfiguration configuration = new HttpConfiguration()) { configuration.Services.Replace(typeof(IHostPrincipalService), expectedPrincipalService); configuration.MessageHandlers.Add(existingHandler); // Act configuration.SuppressHostPrincipal(); // Assert Assert.Equal(2, configuration.MessageHandlers.Count); DelegatingHandler firstHandler = configuration.MessageHandlers[0]; Assert.IsType <SuppressHostPrincipalMessageHandler>(firstHandler); SuppressHostPrincipalMessageHandler suppressPrincipalHandler = (SuppressHostPrincipalMessageHandler)firstHandler; IHostPrincipalService principalService = suppressPrincipalHandler.HostPrincipalService; Assert.Same(expectedPrincipalService, principalService); } }
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { HttpConfiguration config = request.GetConfiguration(); IHostPrincipalService principalService = config.Services.GetHostPrincipalService(); IPrincipal principal = principalService.GetCurrentPrincipal(request); if (!principal.Identity.IsAuthenticated || !SuppressIfAlreadyAuthenticated) { if (request.Headers.Authorization != null && request.Headers.Authorization.Scheme == _httpBasicSchemeName) { string username, password; if (TryExtractBasicAuthCredentialsFromHeader(request.Headers.Authorization.Parameter, out username, out password)) { IPrincipal returnedPrincipal = await AuthenticateUserAsync(request, username, password, cancellationToken); // Check if the user has been authenticated successfully if (returnedPrincipal != null) { principalService.SetCurrentPrincipal(returnedPrincipal, request); return(await base.SendAsync(request, cancellationToken)); } } } } // Request is not authanticated. Handle unauthenticated request. return(await HandleUnauthenticatedRequestImpl(request, cancellationToken)); }
private static PassiveAuthenticationMessageHandler CreateProductUnderTest( IHostPrincipalService principalService, HttpMessageHandler innerHandler) { PassiveAuthenticationMessageHandler handler = new PassiveAuthenticationMessageHandler(principalService); handler.InnerHandler = innerHandler; return(handler); }
private static SuppressHostPrincipalMessageHandler CreateProductUnderTest( IHostPrincipalService principalService, HttpMessageHandler innerHandler) { SuppressHostPrincipalMessageHandler handler = new SuppressHostPrincipalMessageHandler(principalService); handler.InnerHandler = innerHandler; return(handler); }
/// <summary> /// Initializes a new instance of the <see cref="PassiveAuthenticationMessageHandler"/> class. /// </summary> /// <param name="principalService">The host principal service to use to access the current principal.</param> public PassiveAuthenticationMessageHandler(IHostPrincipalService principalService) { if (principalService == null) { throw new ArgumentNullException("principalService"); } _principalService = principalService; }
public void ConstructorWithPrincipalService_Throws_WhenPrincipalServiceIsNull() { // Arrange IHostPrincipalService principalService = null; // Act & Assert Assert.ThrowsArgumentNull(() => { new SuppressHostPrincipalMessageHandler(principalService); }, "principalService"); }
/// <summary> /// Initializes a new instance of the <see cref="SuppressHostPrincipalMessageHandler"/> class. /// </summary> /// <param name="principalService">The host principal service to use to access the current principal.</param> public SuppressHostPrincipalMessageHandler(IHostPrincipalService principalService) { if (principalService == null) { throw new ArgumentNullException("principalService"); } _principalService = principalService; }
public void ConstructorWithPrincipalService_SetsPrincipalService() { // Arrange IHostPrincipalService expectedPrincipalService = CreateDummyPrincipalService(); PassiveAuthenticationMessageHandler handler = new PassiveAuthenticationMessageHandler( expectedPrincipalService); // Act IHostPrincipalService principalService = handler.HostPrincipalService; // Assert Assert.Same(expectedPrincipalService, principalService); }
public void ConstructorWithPrincipalService_SetsPrincipalService() { // Arrange IHostPrincipalService expectedPrincipalService = CreateDummyPrincipalService(); SuppressHostPrincipalMessageHandler handler = new SuppressHostPrincipalMessageHandler( expectedPrincipalService); // Act IHostPrincipalService principalService = handler.HostPrincipalService; // Assert Assert.Same(expectedPrincipalService, principalService); }
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; }
protected virtual void Initialize(HttpControllerContext controllerContext) { if (controllerContext == null) { throw Error.ArgumentNull("controllerContext"); } _initialized = true; _controllerContext = controllerContext; _principalService = Configuration.Services.GetHostPrincipalService(); if (_principalService == null) { throw new InvalidOperationException(SRResources.ServicesContainerIHostPrincipalServiceRequired); } }
public void ExecuteAsync_CallsFilterChallengeAsync_WithErrorResult_WhenFilterReturnsFailure() { // Arrange HttpActionContext expectedContext = CreateContext(); ApiController controller = CreateController(); 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, controller, 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); } }
/// <summary> /// Initializes a new instance of the <see cref="SuppressHostPrincipalMessageHandler"/> class. /// </summary> /// <param name="configuration">The configuration from which to use services.</param> public SuppressHostPrincipalMessageHandler(HttpConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException("configuration"); } Contract.Assert(configuration.Services != null); IHostPrincipalService principalService = configuration.Services.GetHostPrincipalService(); if (principalService == null) { throw new InvalidOperationException(SRResources.ServicesContainerIHostPrincipalServiceRequired); } _principalService = principalService; }
/// <summary> /// Initializes a new instance of the <see cref="PassiveAuthenticationMessageHandler"/> class. /// </summary> /// <param name="configuration">The configuration from which to use services.</param> public PassiveAuthenticationMessageHandler(HttpConfiguration configuration) { if (configuration == null) { throw new ArgumentNullException("configuration"); } Contract.Assert(configuration.Services != null); IHostPrincipalService principalService = configuration.Services.GetHostPrincipalService(); if (principalService == null) { throw new InvalidOperationException(OwinResources.ServicesContainerIHostPrincipalServiceRequired); } _principalService = principalService; }
public void SendAsync_Throws_WhenOwinContextIsNull() { // Arrange IHostPrincipalService principalService = CreateStubPrincipalService(); HttpMessageHandler innerHandler = CreateStubHandler(); HttpMessageHandler handler = CreateProductUnderTest(principalService, innerHandler); using (HttpRequestMessage request = new HttpRequestMessage()) { // Act & Assert InvalidOperationException exception = Assert.Throws <InvalidOperationException>(() => { HttpResponseMessage ignore = handler.SendAsync(request, CancellationToken.None).Result; }); Assert.Equal("No OWIN authentication manager is associated with the request.", exception.Message); } }
public void ConstructorWithConfiguration_SetsPrincipalService() { // Arrange IHostPrincipalService expectedPrincipalService = CreateDummyPrincipalService(); IHostPrincipalService principalService; using (HttpConfiguration configuration = new HttpConfiguration()) { configuration.Services.Replace(typeof(IHostPrincipalService), expectedPrincipalService); SuppressHostPrincipalMessageHandler handler = new SuppressHostPrincipalMessageHandler(configuration); // Act principalService = handler.HostPrincipalService; } // Assert Assert.Same(expectedPrincipalService, principalService); }
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(); IHostPrincipalService principalService = CreateStubPrincipalService(expectedPrincipal); IHttpActionResult innerResult = CreateStubActionResult(); CancellationToken expectedCancellationToken = CreateCancellationToken(); using (HttpRequestMessage request = CreateRequest()) { IHttpActionResult product = CreateProductUnderTest(expectedActionContext, controller, 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); }
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 WebHostPrincipalServiceTest() { _service = new WebHostPrincipalService(); }
private static SuppressHostPrincipalMessageHandler CreateProductUnderTest( IHostPrincipalService principalService, HttpMessageHandler innerHandler) { SuppressHostPrincipalMessageHandler handler = new SuppressHostPrincipalMessageHandler(principalService); handler.InnerHandler = innerHandler; return handler; }
public ThreadPrincipalServiceTest() { _service = new ThreadPrincipalService(); }
private static PassiveAuthenticationMessageHandler CreateProductUnderTest( IHostPrincipalService principalService, HttpMessageHandler innerHandler) { PassiveAuthenticationMessageHandler handler = new PassiveAuthenticationMessageHandler(principalService); handler.InnerHandler = innerHandler; return handler; }
private static AuthenticationFilterResult CreateProductUnderTest(HttpActionContext context, IAuthenticationFilter[] filters, IHostPrincipalService principalService, HttpRequestMessage request, IHttpActionResult innerResult) { return(new AuthenticationFilterResult(context, filters, principalService, request, innerResult)); }
private static AuthenticationFilterResult CreateProductUnderTest(HttpActionContext context, IAuthenticationFilter[] filters, IHostPrincipalService principalService, HttpRequestMessage request, IHttpActionResult innerResult) { return new AuthenticationFilterResult(context, filters, principalService, request, innerResult); }