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 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 SendAsync_DelegatesToInnerHandler()
{
// Arrange
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(innerHandler);
CancellationToken expectedCancellationToken = new CancellationToken(true);
using (HttpRequestMessage expectedRequest = CreateRequestWithOwinContextAndRequestContext(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_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_SetsCurrentPrincipalToAnonymous_BeforeCallingInnerHandler()
{
// Arrange
IPrincipal requestContextPrincipal = null;
Mock <HttpRequestContext> requestContextMock = new Mock <HttpRequestContext>();
requestContextMock
.SetupSet(c => c.Principal = It.IsAny <IPrincipal>())
.Callback <IPrincipal>((value) => requestContextPrincipal = value);
IPrincipal principalBeforeInnerHandler = null;
HttpMessageHandler inner = new LambdaHttpMessageHandler((ignore1, ignore2) =>
{
principalBeforeInnerHandler = requestContextPrincipal;
return(Task.FromResult <HttpResponseMessage>(null));
});
HttpMessageHandler handler = CreateProductUnderTest(inner);
using (HttpRequestMessage request = new HttpRequestMessage())
{
request.SetRequestContext(requestContextMock.Object);
// 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 async Task SendAsync_DelegatesToInnerHandler()
{
// Arrange
HttpRequestMessage request = null;
var cancellationToken = default(CancellationToken);
HttpMessageHandler innerHandler = new LambdaHttpMessageHandler(
(r, c) =>
{
request = r;
cancellationToken = c;
return(Task.FromResult <HttpResponseMessage>(null));
}
);
HttpMessageHandler handler = CreateProductUnderTest(innerHandler);
var expectedCancellationToken = new CancellationToken(true);
using (var expectedRequest = CreateRequestWithContext())
{
// Act
var result = await handler.SendAsync(expectedRequest, expectedCancellationToken);
// Assert
Assert.Same(expectedRequest, request);
Assert.Equal(expectedCancellationToken, cancellationToken);
Assert.Null(result);
}
}
public void SendAsync_SetsCurrentPrincipalToAnonymous_BeforeCallingInnerHandler()
{
// Arrange
IPrincipal requestContextPrincipal = null;
Mock<HttpRequestContext> requestContextMock = new Mock<HttpRequestContext>();
requestContextMock
.SetupSet(c => c.Principal = It.IsAny<IPrincipal>())
.Callback<IPrincipal>((value) => requestContextPrincipal = value);
IPrincipal principalBeforeInnerHandler = null;
HttpMessageHandler inner = new LambdaHttpMessageHandler((ignore1, ignore2) =>
{
principalBeforeInnerHandler = requestContextPrincipal;
return Task.FromResult<HttpResponseMessage>(null);
});
HttpMessageHandler handler = CreateProductUnderTest(inner);
using (HttpRequestMessage request = new HttpRequestMessage())
{
request.SetRequestContext(requestContextMock.Object);
// 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 SendAsync_DelegatesToInnerHandler()
{
// Arrange
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(innerHandler);
CancellationToken expectedCancellationToken = new CancellationToken(true);
using (HttpRequestMessage expectedRequest = CreateRequestWithContext())
{
// Act
Task<HttpResponseMessage> result = handler.SendAsync(expectedRequest, expectedCancellationToken);
// Assert
Assert.Same(expectedRequest, request);
Assert.Equal(expectedCancellationToken, cancellationToken);
Assert.Same(expectedResult, result);
}
}
public async Task SendAsync_SetsRequestContextPrincipalToAnonymous_BeforeCallingInnerHandler()
{
// Arrange
var requestContextMock = new Mock <HttpRequestContext>(MockBehavior.Strict);
var sequence = new MockSequence();
var initialPrincipal = new GenericPrincipal(
new GenericIdentity("generic user"),
new[] { "generic role" }
);
IPrincipal requestContextPrincipal = null;
requestContextMock
.InSequence(sequence)
.SetupGet(c => c.Principal)
.Returns(initialPrincipal);
requestContextMock
.InSequence(sequence)
.SetupSet(c => c.Principal = It.IsAny <IPrincipal>())
.Callback <IPrincipal>(value => requestContextPrincipal = value);
// SendAsync also restores the old principal.
requestContextMock
.InSequence(sequence)
.SetupGet(c => c.Principal)
.Returns(requestContextPrincipal);
requestContextMock.InSequence(sequence).SetupSet(c => c.Principal = initialPrincipal);
IPrincipal principalBeforeInnerHandler = null;
HttpMessageHandler inner = new LambdaHttpMessageHandler(
(ignore1, ignore2) =>
{
principalBeforeInnerHandler = requestContextPrincipal;
return(Task.FromResult <HttpResponseMessage>(null));
}
);
HttpMessageHandler handler = CreateProductUnderTest(inner);
var context = CreateOwinContext();
using (var request = new HttpRequestMessage())
{
request.SetOwinContext(context);
request.SetRequestContext(requestContextMock.Object);
// Act
await handler.SendAsync(request, CancellationToken.None);
}
// Assert
Assert.Equal(requestContextPrincipal, principalBeforeInnerHandler);
Assert.NotNull(principalBeforeInnerHandler);
var identity = principalBeforeInnerHandler.Identity;
Assert.NotNull(identity);
Assert.False(identity.IsAuthenticated);
Assert.Null(identity.Name);
Assert.Null(identity.AuthenticationType);
}
public async Task SendAsync_ServiceModel_AddsSelfHostHttpRequestContext()
{
// Arrange
using (PortReserver port = new PortReserver())
{
string baseUri = port.BaseUri;
HttpRequestContext context = null;
Uri via = null;
Func <HttpRequestMessage, CancellationToken, Task <HttpResponseMessage> > sendAsync = (r, c) =>
{
if (r != null)
{
context = r.GetRequestContext();
}
SelfHostHttpRequestContext typedContext = context as SelfHostHttpRequestContext;
if (typedContext != null)
{
via = typedContext.RequestContext.RequestMessage.Properties.Via;
}
return(Task.FromResult(new HttpResponseMessage()));
};
using (HttpSelfHostConfiguration expectedConfiguration = new HttpSelfHostConfiguration(baseUri))
{
expectedConfiguration.HostNameComparisonMode = HostNameComparisonMode.Exact;
using (HttpMessageHandler dispatcher = new LambdaHttpMessageHandler(sendAsync))
using (HttpSelfHostServer server = new HttpSelfHostServer(expectedConfiguration, dispatcher))
using (HttpClient client = new HttpClient())
using (HttpRequestMessage expectedRequest = new HttpRequestMessage(HttpMethod.Get, baseUri))
{
await server.OpenAsync();
// Act
using (HttpResponseMessage ignore = await client.SendAsync(expectedRequest))
{
// Assert
SelfHostHttpRequestContext typedContext = (SelfHostHttpRequestContext)context;
Assert.Equal(expectedRequest.RequestUri, via);
Assert.Same(expectedConfiguration, context.Configuration);
Assert.Equal(expectedRequest.RequestUri, typedContext.Request.RequestUri);
await server.CloseAsync();
}
}
}
}
}
public void SendAsync_ServiceModel_AddsSelfHostHttpRequestContext()
{
// Arrange
// Use a different port from 50231 to prevent conflicts with concurrent tests.
string baseUri = "http://localhost:50232/";
HttpRequestContext context = null;
Uri via = null;
Func <HttpRequestMessage, CancellationToken, Task <HttpResponseMessage> > sendAsync = (r, c) =>
{
if (r != null)
{
context = r.GetRequestContext();
}
SelfHostHttpRequestContext typedContext = context as SelfHostHttpRequestContext;
if (typedContext != null)
{
via = typedContext.RequestContext.RequestMessage.Properties.Via;
}
return(Task.FromResult(new HttpResponseMessage()));
};
using (HttpSelfHostConfiguration expectedConfiguration = new HttpSelfHostConfiguration(baseUri))
{
expectedConfiguration.HostNameComparisonMode = HostNameComparisonMode.Exact;
using (HttpMessageHandler dispatcher = new LambdaHttpMessageHandler(sendAsync))
using (HttpSelfHostServer server = new HttpSelfHostServer(expectedConfiguration, dispatcher))
using (HttpClient client = new HttpClient())
using (HttpRequestMessage expectedRequest = new HttpRequestMessage(HttpMethod.Get, baseUri))
{
server.OpenAsync().Wait();
// Act
using (HttpResponseMessage ignore = client.SendAsync(expectedRequest).Result)
{
// Assert
SelfHostHttpRequestContext typedContext = (SelfHostHttpRequestContext)context;
Assert.Equal(expectedRequest.RequestUri, via);
Assert.Same(expectedConfiguration, context.Configuration);
Assert.Equal(expectedRequest.RequestUri, typedContext.Request.RequestUri);
server.CloseAsync().Wait();
}
}
}
}
public void SendAsync_ServiceModel_AddsSelfHostHttpRequestContext()
{
// Arrange
// Use a different port from 50231 to prevent conflicts with concurrent tests.
string baseUri = "http://localhost:50232/";
HttpRequestContext context = null;
Uri via = null;
Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync = (r, c) =>
{
if (r != null)
{
context = r.GetRequestContext();
}
SelfHostHttpRequestContext typedContext = context as SelfHostHttpRequestContext;
if (typedContext != null)
{
via = typedContext.RequestContext.RequestMessage.Properties.Via;
}
return Task.FromResult(new HttpResponseMessage());
};
using (HttpSelfHostConfiguration expectedConfiguration = new HttpSelfHostConfiguration(baseUri))
{
expectedConfiguration.HostNameComparisonMode = HostNameComparisonMode.Exact;
using (HttpMessageHandler dispatcher = new LambdaHttpMessageHandler(sendAsync))
using (HttpSelfHostServer server = new HttpSelfHostServer(expectedConfiguration, dispatcher))
using (HttpClient client = new HttpClient())
using (HttpRequestMessage expectedRequest = new HttpRequestMessage(HttpMethod.Get, baseUri))
{
server.OpenAsync().Wait();
// Act
using (HttpResponseMessage ignore = client.SendAsync(expectedRequest).Result)
{
// Assert
SelfHostHttpRequestContext typedContext = (SelfHostHttpRequestContext)context;
Assert.Equal(expectedRequest.RequestUri, via);
Assert.Same(expectedConfiguration, context.Configuration);
Assert.Equal(expectedRequest.RequestUri, typedContext.Request.RequestUri);
server.CloseAsync().Wait();
}
}
}
}
public void SendAsync_DelegatesToInnerHandler()
{
// Arrange
IHostPrincipalService principalService = CreateStubPrincipalService();
HttpRequestMessage request = null;
CancellationToken cancellationToken = default(CancellationToken);
IDictionary<string, object> environment = CreateOwinEnvironment();
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 = CreateRequestWithOwinEnvironment(environment))
{
// Act
HttpResponseMessage response = handler.SendAsync(expectedRequest,
expectedCancellationToken).Result;
// Assert
Assert.Same(expectedRequest, request);
Assert.Equal(expectedCancellationToken, cancellationToken);
Assert.Same(expectedResponse, response);
}
}
}
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 Invoke_SetsOwinRequestContext()
{
// Arrange
IHostBufferPolicySelector bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false,
bufferOutput: false);
using (HttpResponseMessage response = new HttpResponseMessage())
{
HttpRequestMessage request = null;
Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync = (r, c) =>
{
request = r;
return Task.FromResult(response);
};
using (HttpMessageHandler messageHandler = new LambdaHttpMessageHandler(sendAsync))
using (HttpMessageHandlerAdapter adapter = new HttpMessageHandlerAdapter(next: null,
messageHandler: messageHandler, bufferPolicySelector: bufferPolicySelector))
{
Mock<IHeaderDictionary> requestHeadersMock = new Mock<IHeaderDictionary>(MockBehavior.Strict);
requestHeadersMock.Setup(h => h.GetEnumerator()).Returns(
new Mock<IEnumerator<KeyValuePair<string, string[]>>>().Object);
Mock<IOwinRequest> requestMock = new Mock<IOwinRequest>(MockBehavior.Strict);
requestMock.Setup(r => r.Method).Returns("GET");
requestMock.Setup(r => r.Uri).Returns(new Uri("http://ignore"));
requestMock.Setup(r => r.Body).Returns(Stream.Null);
requestMock.Setup(r => r.Headers).Returns(requestHeadersMock.Object);
requestMock.Setup(r => r.User).Returns((IPrincipal)null);
requestMock.Setup(r => r.CallCancelled).Returns(CancellationToken.None);
Mock<IHeaderDictionary> responseHeadersMock = new Mock<IHeaderDictionary>();
Mock<IOwinResponse> responseMock = new Mock<IOwinResponse>();
responseMock.Setup(r => r.Headers).Returns(responseHeadersMock.Object);
Mock<IOwinContext> contextMock = new Mock<IOwinContext>(MockBehavior.Strict);
contextMock.Setup(c => c.Request).Returns(requestMock.Object);
contextMock.Setup(c => c.Response).Returns(responseMock.Object);
IOwinContext expectedContext = contextMock.Object;
// Act
adapter.Invoke(expectedContext).Wait();
// Assert
HttpRequestContext requestContext = request.GetRequestContext();
Assert.IsType<OwinHttpRequestContext>(requestContext);
OwinHttpRequestContext typedContext = (OwinHttpRequestContext)requestContext;
Assert.Same(expectedContext, typedContext.Context);
Assert.Same(request, typedContext.Request);
}
}
}
