testing post message handler

gistfile1.cs

    public class PostStatusCodeMessageHandler: DelegatingChannel
    {
        public PostStatusCodeMessageHandler(HttpMessageChannel innerChannel) 
            : base(innerChannel)
        {
        }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var task = base.SendAsync(request, cancellationToken);
            return task.ContinueWith(
                contingentTask =>
                {
                    var response = contingentTask.Result;
                    if (request.Method == HttpMethod.Post && response.StatusCode == HttpStatusCode.OK)
                        response.StatusCode = HttpStatusCode.Created;
                    return response;
                });
        }
    }

    public class HttpMessageHandlerStubHelper : HttpMessageChannel
    {
        protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return MockSend(request, cancellationToken);
        }

        public virtual HttpResponseMessage MockSend(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return null;
        }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return MockSendAsync(request, cancellationToken);
        }

        public virtual Task<HttpResponseMessage> MockSendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return null;
        }

        public static HttpResponseMessage InvokeSend(HttpMessageChannel channel, HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var @this = new HttpMessageHandlerStubHelper();
            Func<HttpRequestMessage, CancellationToken, HttpResponseMessage> del = @this.Send;
            var baseMethod = del.Method.GetBaseDefinition();
            var result = baseMethod.Invoke(channel, new object[] { request, cancellationToken });
            return (HttpResponseMessage)result;
        }

        public static Task<HttpResponseMessage> InvokeSendAsync(HttpMessageChannel channel, HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var @this = new HttpMessageHandlerStubHelper();
            Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> del = @this.SendAsync;
            var baseMethod = del.Method.GetBaseDefinition();
            var result = baseMethod.Invoke(channel, new object[] { request, cancellationToken });
            return (Task<HttpResponseMessage>)result;
        }
    }

    [TestFixture]
    public class PostStatusCodeMessageHandlerTests
    {
        [SetUp]
        public void SetUp()
        {
            var request = new HttpRequestMessage
            {
                Method = HttpMethod.Post,
            };
            var cancellationToken = new CancellationToken();
            var httpResponseMessage = new HttpResponseMessage
            {
                StatusCode = HttpStatusCode.OK,
            };

            var innerChannel = MockRepository.GeneratePartialMock<HttpMessageHandlerStubHelper>();
            var task = new Task<HttpResponseMessage>(() => httpResponseMessage);
            innerChannel.Stub(x => x.MockSendAsync(request, cancellationToken)).Return(task);

            var handler = new PostStatusCodeMessageHandler(innerChannel);

            var result = HttpMessageHandlerStubHelper.InvokeSendAsync(handler, request, cancellationToken);
            task.RunSynchronously();

            Assert.That(result.Result.StatusCode, Is.EqualTo(HttpStatusCode.Created));
            Assert.That(task.IsCompleted, Is.True);
        }
    }