public void Constructor_InitializesRequestIdProperty()
{
using (var test = new InboundRequestContextTest())
{
Assert.Equal(test.RequestId, test.Context.RequestId);
}
}
public void Dispose_DoesNotDisposeLogger()
{
using (var test = new InboundRequestContextTest())
{
test.Context.Dispose();
test.Logger.Verify();
}
}
public void Dispose_DoesNotDisposeOfInboundRequestProcessingHandler()
{
using (var test = new InboundRequestContextTest())
{
test.Context.Dispose();
test.Handler.Verify();
}
}
public void Dispose_DoesNotDisposeConnection()
{
using (var test = new InboundRequestContextTest())
{
test.Context.Dispose();
test.Connection.Verify();
}
}
public void Cancel_IsIdempotent()
{
using (var test = new InboundRequestContextTest())
{
test.Context.Cancel();
test.Context.Cancel();
}
}
public void Dispose_IsIdempotent()
{
using (var test = new InboundRequestContextTest())
{
test.Context.Dispose();
test.Context.Dispose();
}
}
public void BeginResponseAsync_TranslatesRequestHandlerExceptionIntoFaultResponse()
{
using (var test = new InboundRequestContextTest())
using (var sentEvent = new ManualResetEventSlim(initialState: false))
{
var requestHandler = new Mock <IRequestHandler>(MockBehavior.Strict);
requestHandler.Setup(x => x.HandleResponseAsync(
It.IsNotNull <IConnection>(),
It.IsNotNull <Message>(),
It.IsNotNull <IResponseHandler>(),
It.IsAny <CancellationToken>()))
.Throws(new Exception("test"));
Message response = null;
test.Connection.Setup(x => x.SendAsync(It.IsNotNull <Message>(), It.IsAny <CancellationToken>()))
.Callback <Message, CancellationToken>(
(message, cancellationToken) =>
{
response = message;
sentEvent.Set();
})
.Returns(Task.FromResult(0));
test.Context.BeginResponseAsync(
new Message(
test.RequestId,
MessageType.Request,
MessageMethod.GetOperationClaims,
payload: null),
requestHandler.Object,
Mock.Of <IResponseHandler>());
sentEvent.Wait();
requestHandler.Verify(x => x.HandleResponseAsync(
It.IsNotNull <IConnection>(),
It.IsNotNull <Message>(),
It.IsNotNull <IResponseHandler>(),
It.IsAny <CancellationToken>()), Times.Once);
test.Connection.Verify(
x => x.SendAsync(It.IsNotNull <Message>(), It.IsAny <CancellationToken>()),
Times.Once);
Assert.NotNull(response);
Assert.Equal(test.RequestId, response.RequestId);
Assert.Equal(MessageType.Fault, response.Type);
Assert.Equal(MessageMethod.GetOperationClaims, response.Method);
var responsePayload = MessageUtilities.DeserializePayload <Fault>(response);
Assert.Equal("test", responsePayload.Message);
}
}
public void BeginFaultAsync_ThrowsForNullRequest()
{
using (var test = new InboundRequestContextTest())
{
var exception = Assert.Throws <ArgumentNullException>(
() => test.Context.BeginFaultAsync(request: null, exception: new Exception()));
Assert.Equal("request", exception.ParamName);
}
}
public void BeginResponseAsync_ThrowsForNullRequest()
{
using (var test = new InboundRequestContextTest())
{
var exception = Assert.Throws <ArgumentNullException>(
() => test.Context.BeginResponseAsync(
request: null,
requestHandler: Mock.Of <IRequestHandler>(),
responseHandler: Mock.Of <IResponseHandler>()));
Assert.Equal("request", exception.ParamName);
}
}
public void BeginFaultAsync_ThrowsForNullException()
{
using (var test = new InboundRequestContextTest())
{
var exception = Assert.Throws <ArgumentNullException>(
() => test.Context.BeginFaultAsync(
new Message(
test.RequestId,
MessageType.Request,
MessageMethod.GetOperationClaims,
payload: null),
exception: null));
Assert.Equal("exception", exception.ParamName);
}
}
public void Cancel_SendsCancelResponse()
{
using (var test = new InboundRequestContextTest())
using (var handledEvent = new ManualResetEventSlim(initialState: false))
{
test.Connection.Setup(
x => x.SendAsync(
It.Is <Message>(m => m.Type == MessageType.Cancel),
It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(0));
var requestHandler = new Mock <IRequestHandler>(MockBehavior.Strict);
requestHandler.Setup(x => x.HandleResponseAsync(
It.IsNotNull <IConnection>(),
It.IsNotNull <Message>(),
It.IsNotNull <IResponseHandler>(),
It.IsAny <CancellationToken>()))
.Callback <IConnection, Message, IResponseHandler, CancellationToken>(
(connection, requestMessage, responseHandler, cancellationToken) =>
{
handledEvent.Set();
})
.Returns(Task.FromResult(0));
var request = MessageUtilities.Create(
test.RequestId,
MessageType.Cancel,
MessageMethod.PrefetchPackage,
new PrefetchPackageRequest(
packageSourceRepository: "a",
packageId: "b",
packageVersion: "c"));
test.Context.BeginResponseAsync(request, requestHandler.Object, Mock.Of <IResponseHandler>());
handledEvent.Wait();
test.Context.Cancel();
requestHandler.Verify(x => x.HandleResponseAsync(
It.IsNotNull <IConnection>(),
It.IsNotNull <Message>(),
It.IsNotNull <IResponseHandler>(),
It.IsAny <CancellationToken>()), Times.Once);
}
}
public void BeginResponseAsync_ThrowsForNullResponseHandler()
{
using (var test = new InboundRequestContextTest())
{
var exception = Assert.Throws <ArgumentNullException>(
() => test.Context.BeginResponseAsync(
new Message(
test.RequestId,
type: MessageType.Progress,
method: MessageMethod.GetOperationClaims,
payload: null),
requestHandler: Mock.Of <IRequestHandler>(),
responseHandler: null));
Assert.Equal("responseHandler", exception.ParamName);
}
}
public void BeginFaultAsync_SendsReponse()
{
using (var test = new InboundRequestContextTest())
using (var sentEvent = new ManualResetEventSlim(initialState: false))
{
Message response = null;
test.Connection.Setup(x => x.SendAsync(It.IsNotNull <Message>(), It.IsAny <CancellationToken>()))
.Callback <Message, CancellationToken>(
(message, cancellationToken) =>
{
response = message;
sentEvent.Set();
})
.Returns(Task.FromResult(0));
test.Context.BeginFaultAsync(
new Message(
test.RequestId,
MessageType.Request,
MessageMethod.GetOperationClaims,
payload: null),
new Exception("test"));
sentEvent.Wait();
test.Connection.Verify(
x => x.SendAsync(It.IsNotNull <Message>(), It.IsAny <CancellationToken>()),
Times.Once);
Assert.NotNull(response);
Assert.Equal(test.RequestId, response.RequestId);
Assert.Equal(MessageType.Fault, response.Type);
Assert.Equal(MessageMethod.GetOperationClaims, response.Method);
var responsePayload = MessageUtilities.DeserializePayload <Fault>(response);
Assert.Equal("test", responsePayload.Message);
}
}
public void BeginResponseAsync_CallsRequestHandler()
{
using (var test = new InboundRequestContextTest())
using (var handledEvent = new ManualResetEventSlim(initialState: false))
{
var requestHandler = new Mock <IRequestHandler>(MockBehavior.Strict);
requestHandler.Setup(x => x.HandleResponseAsync(
It.IsNotNull <IConnection>(),
It.IsNotNull <Message>(),
It.IsNotNull <IResponseHandler>(),
It.IsAny <CancellationToken>()))
.Callback <IConnection, Message, IResponseHandler, CancellationToken>(
(connection, message, responseHandler, cancellationToken) =>
{
handledEvent.Set();
})
.Returns(Task.FromResult(0));
test.Context.BeginResponseAsync(
new Message(
test.RequestId,
MessageType.Request,
MessageMethod.GetOperationClaims,
payload: null),
requestHandler.Object,
Mock.Of <IResponseHandler>());
handledEvent.Wait();
requestHandler.Verify(x => x.HandleResponseAsync(
It.IsNotNull <IConnection>(),
It.IsNotNull <Message>(),
It.IsNotNull <IResponseHandler>(),
It.IsAny <CancellationToken>()), Times.Once);
}
}
