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;
}
/// <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;
}
/// <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;
}
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();
}
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));
}
public ThreadPrincipalServiceTest()
{
_service = new ThreadPrincipalService();
}
private static AuthenticationFilterResult CreateProductUnderTest(HttpActionContext context,
IAuthenticationFilter[] filters, IHostPrincipalService principalService, HttpRequestMessage request,
IHttpActionResult innerResult)
{
return new AuthenticationFilterResult(context, filters, principalService, request, innerResult);
}
