public void GetMatchingTestScopedInteraction_WithNoMatchingTestScopedInteraction_ThrowsPactFailureException() { var interaction = new ProviderServiceInteraction { Description = "My description", Request = new ProviderServiceRequest { Method = HttpVerb.Head, Path = "/tester" }, Response = new ProviderServiceResponse { Status = (int)HttpStatusCode.NoContent } }; var nonMatchingRequest = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/tester" }; var repo = GetSubject(); repo.AddInteraction(interaction); Assert.Throws <PactFailureException>(() => repo.GetMatchingTestScopedInteraction(nonMatchingRequest)); }
public ProviderServiceRequest Convert(Request from) { if (from == null) { return(null); } var httpVerb = _httpVerbMapper.Convert(from.Method.ToUpper()); var to = new ProviderServiceRequest { Method = httpVerb, Path = from.Path, Query = !String.IsNullOrEmpty(from.Url.Query) ? from.Url.Query.TrimStart('?') : null }; if (from.Headers != null && from.Headers.Any()) { var fromHeaders = from.Headers.ToDictionary(x => x.Key, x => String.Join(", ", x.Value)); to.Headers = fromHeaders; } if (from.Body != null && from.Body.Length > 0) { var content = ConvertStreamToString(from.Body); var httpBodyContent = _httpBodyContentMapper.Convert(content, to.Headers); to.Body = httpBodyContent.Body; } return(to); }
public void With_WithRequest_SetsRequest() { var description = "My description"; var request = new ProviderServiceRequest { Method = HttpVerb.Head, Path = "/tester/testing/1" }; var response = new ProviderServiceResponse { Status = (int)HttpStatusCode.ProxyAuthenticationRequired }; var expectedInteraction = new ProviderServiceInteraction { Description = description, Request = request, Response = response }; var expectedInteractionJson = expectedInteraction.AsJsonString(); var mockService = GetSubject(); mockService.Start(); mockService.UponReceiving(description) .With(request) .WillRespondWith(response); var actualInteractionJson = _fakeHttpMessageHandler.RequestContentRecieved.Single(); Assert.Equal(expectedInteractionJson, actualInteractionJson); }
public void Convert_WithContentTypeSpecifiedAndAlsoBeingSetByStringContent_ContentTypeHeaderIsNotReAddedToHttpRequestMessageContentHeaders() { var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", "text/plain" } }, Body = "Some content" }; var httpBodyContent = new HttpBodyContent(contentType: new MediaTypeHeaderValue("text/plain") { CharSet = "utf-8" }); httpBodyContent.GenerateContent(request.Body); var stringContent = new StringContent(request.Body, Encoding.UTF8, "text/plain"); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <string>(), Arg.Any <IDictionary <string, string> >()).Returns(httpBodyContent); _mockHttpContentMapper.Convert(httpBodyContent).Returns(stringContent); var result = mapper.Convert(request); Assert.Equal(1, result.Content.Headers.Count()); Assert.Equal(request.Headers.First().Key, result.Content.Headers.First().Key); Assert.Equal("text/plain; charset=utf-8", result.Content.Headers.First().Value.First()); }
public void Handle_WithNancyContext_AddHandledRequestIsCalledOnTheMockProviderRepository() { var expectedRequest = new ProviderServiceRequest(); var expectedResponse = new ProviderServiceResponse(); var actualRequest = new ProviderServiceRequest(); var mockRequestMapper = Substitute.For <IProviderServiceRequestMapper>(); var mockResponseMapper = Substitute.For <INancyResponseMapper>(); var mockProviderRepository = Substitute.For <IMockProviderRepository>(); var nancyContext = new NancyContext { Request = new Request("GET", "/", "HTTP") }; var interactions = new List <ProviderServiceInteraction> { new ProviderServiceInteraction { Request = expectedRequest, Response = expectedResponse } }; nancyContext.SetMockInteraction(interactions); mockRequestMapper.Convert(nancyContext.Request).Returns(actualRequest); IMockProviderRequestHandler handler = new MockProviderRequestHandler(mockRequestMapper, mockResponseMapper, mockProviderRepository); handler.Handle(nancyContext); mockProviderRepository.Received(1).AddHandledRequest(Arg.Is <HandledRequest>(x => x.ActualRequest == actualRequest && x.MatchedInteraction == interactions.First())); }
public void Convert_WithPlainContentTypeHeader_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithContentType() { const string contentTypeString = "text/plain"; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString } }, Body = new {} }; var httpBodyContent = new HttpBodyContent(String.Empty, contentTypeString, null); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); var result = mapper.Convert(request); Assert.Empty(result.Headers); _mockHttpContentMapper.Received(1).Convert(httpBodyContent); }
public void Convert_WithJsonContentTypeAndUnicodeCharsetHeader_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithEncodingAndContentType() { const string contentTypeString = "application/json"; const string encodingString = "utf-16"; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString + "; charset=" + encodingString } }, Body = new { } }; var httpBodyContent = new HttpBodyContent(content: Encoding.UTF8.GetBytes(String.Empty), contentType: new MediaTypeHeaderValue(contentTypeString) { CharSet = encodingString }); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); var result = mapper.Convert(request); Assert.Empty(result.Headers); _mockHttpBodyContentMapper.Received(1).Convert(request.Body, request.Headers); _mockHttpContentMapper.Received(1).Convert(httpBodyContent); }
public void Convert_WithContentTypeSpecifiedButNotBeingSetByByteArrayContent_ContentTypeHeaderIsNotReAddedToHttpRequestMessageContentHeaders() { var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", "application/octet-stream" } }, Body = Encoding.UTF8.GetBytes("Some content") }; var httpBodyContent = new HttpBodyContent(new MediaTypeHeaderValue("text/plain") { CharSet = "utf-8" }); httpBodyContent.GenerateContent(request.Body); var byteArrayContent = new ByteArrayContent(request.Body as byte[]); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(body: Arg.Any <byte[]>(), headers: Arg.Any <IDictionary <string, string> >()).Returns(httpBodyContent); _mockHttpContentMapper.Convert(httpBodyContent).Returns(byteArrayContent); var result = mapper.Convert(request); Assert.Equal(1, result.Content.Headers.Count()); Assert.Equal(request.Headers.First().Key, result.Content.Headers.First().Key); Assert.Equal("application/octet-stream", result.Content.Headers.First().Value.First()); }
public void SerializeObject_WithCamelCaseApiSerializerSettings_ReturnsCorrectJson() { var request = new ProviderServiceRequest { Method = HttpVerb.Get, Headers = new Dictionary <string, object> { { "Content-Type", "application/json" } }, Body = new { Test1 = "hi", test2 = 2 } }; var requestJson = JsonConvert.SerializeObject(request, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore, Formatting = Formatting.None, ContractResolver = new CamelCasePropertyNamesContractResolver() }); var expectedJson = "{\"method\":\"get\",\"headers\":{\"Content-Type\":\"application/json\"},\"body\":{\"test1\":\"hi\",\"test2\":2}}"; Assert.Equal(expectedJson, requestJson); }
public void Handle_WhenGetMatchingMockInteractionThrows_PactFailureExceptionIsThrown() { const string exceptionMessage = "No matching mock interaction has been registered for the current request"; var request = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/Test" }; var nancyContext = new NancyContext { Request = new Request("GET", "/Test", "HTTP") }; var handler = GetSubject(); _mockRequestMapper .Convert(nancyContext.Request) .Returns(request); _mockResponseMapper.Convert(Arg.Any <ProviderServiceResponse>()) .Returns(new Response { StatusCode = HttpStatusCode.InternalServerError }); _mockProviderRepository .When(x => x.GetMatchingTestScopedInteraction(HttpVerb.Get, "/Test")) .Do(x => { throw new PactFailureException(exceptionMessage); }); Assert.Throws <PactFailureException>(() => handler.Handle(nancyContext)); }
public void Handle_WithNancyContext_AddHandledRequestIsCalledOnTheMockProviderRepository() { var expectedRequest = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/" }; var actualRequest = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/", Body = new {} }; var expectedResponse = new ProviderServiceResponse(); var handler = GetSubject(); var nancyContext = new NancyContext { Request = new Request("GET", "/", "HTTP") }; var interaction = new ProviderServiceInteraction { Request = expectedRequest, Response = expectedResponse }; _mockProviderRepository.GetMatchingTestScopedInteraction(HttpVerb.Get, "/") .Returns(interaction); _mockRequestMapper.Convert(nancyContext.Request).Returns(actualRequest); handler.Handle(nancyContext); _mockProviderRepository.Received(1).AddHandledRequest(Arg.Is <HandledRequest>(x => x.ActualRequest == actualRequest && x.MatchedInteraction == interaction)); }
public void Compare(ProviderServiceRequest expected, ProviderServiceRequest actual) { if (expected == null) { _reporter.ReportError("Expected request cannot be null"); return; } _httpMethodComparer.Compare(expected.Method, actual.Method); _httpPathComparer.Compare(expected.Path, actual.Path); _httpQueryStringComparer.Compare(expected.Query, actual.Query); if (expected.Headers != null && expected.Headers.Any()) { if (actual.Headers == null) { _reporter.ReportError("Headers are null"); } _httpHeaderComparer.Compare(expected.Headers, actual.Headers); } if (expected.Body != null) { _httpBodyComparer.Validate(expected.Body, actual.Body, true); } }
public void WhenRegisteringTheSameInteractionTwiceInATest_ThenPactFailureExceptionIsThrown() { var description = "A POST request to create a new thing"; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/things", Headers = new Dictionary <string, string> { { "Content-Type", "application/json; charset=utf-8" } }, Body = new { thingId = 1234, type = "Awesome" } }; var response = new ProviderServiceResponse { Status = 201 }; _mockProviderService .UponReceiving(description) .With(request) .WillRespondWith(response); _mockProviderService .UponReceiving(description) .With(request); Assert.Throws <PactFailureException>(() => _mockProviderService.WillRespondWith(response)); }
public void Compare(ProviderServiceRequest request1, ProviderServiceRequest request2) { if (request1 == null) { throw new CompareFailedException("Expected request cannot be null"); } _httpMethodComparer.Compare(request1.Method, request2.Method); _httpPathComparer.Compare(request1.Path, request2.Path); _httpQueryStringComparer.Compare(request1.Query, request2.Query); if (request1.Headers != null && request1.Headers.Any()) { if (request2.Headers == null) { throw new CompareFailedException("Headers are null"); } _httpHeaderComparer.Compare(request1.Headers, request2.Headers); } if (request1.Body != null) { _httpBodyComparer.Validate(request2.Body, request1.Body, true); } }
public bool Execute(ProviderServiceRequest expected, HttpRequestMessage actual) { string RemoveLeadingQuestionMark(string q) => string.IsNullOrEmpty(q) ? q : q.Substring(1); if (!CompareHttpVerb(expected.Method, actual.Method)) { return(false); } if (expected .Headers .Keys .Any(k => !actual.Headers.Contains(k) || !HeaderComparer.Execute(expected.Headers[k], actual.Headers.GetValues(k)))) { return(false); } if (actual.RequestUri.LocalPath.Replace("//", "/") != expected.Path) { return(false); } if (!string.IsNullOrEmpty(expected.Query) && RemoveLeadingQuestionMark(actual.RequestUri.Query) != expected.Query) { return(false); } return(CompareContent(expected, actual.Content)); }
public void Handle_WithNancyContext_ConvertIsCalledOnThProviderServiceRequestMapper() { var expectedRequest = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/" }; var expectedResponse = new ProviderServiceResponse(); var nancyContext = new NancyContext { Request = new Request("GET", "/", "HTTP") }; var mockRequestMapper = Substitute.For <IProviderServiceRequestMapper>(); var mockResponseMapper = Substitute.For <INancyResponseMapper>(); var mockProviderRepository = Substitute.For <IMockProviderRepository>(); mockRequestMapper.Convert(nancyContext.Request).Returns(expectedRequest); var interactions = new List <ProviderServiceInteraction> { new ProviderServiceInteraction { Request = expectedRequest, Response = expectedResponse } }; nancyContext.SetMockInteraction(interactions); IMockProviderRequestHandler handler = new MockProviderRequestHandler(mockRequestMapper, mockResponseMapper, mockProviderRepository); handler.Handle(nancyContext); mockRequestMapper.Received(1).Convert(nancyContext.Request); }
public void WillRespondWith_WithResponseThatContainsABodyAndNoContentType_ThrowsArgumentException() { var providerState = "My provider state"; var description = "My description"; var request = new ProviderServiceRequest { Method = HttpVerb.Get }; var response = new ProviderServiceResponse { Status = (int)HttpStatusCode.OK, Body = new { tester = 1 } }; var mockService = GetSubject(); mockService .Given(providerState) .UponReceiving(description) .With(request); Assert.Throws <ArgumentException>(() => mockService.WillRespondWith(response)); }
public void Handle_WithNancyContext_ConvertIsCalledOnTheNancyResponseMapper() { var expectedRequest = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/" }; var expectedResponse = new ProviderServiceResponse(); var nancyContext = new NancyContext { Request = new Request("GET", "/", "HTTP") }; var handler = GetSubject(); _mockRequestMapper.Convert(nancyContext.Request).Returns(expectedRequest); var interaction = new ProviderServiceInteraction { Request = expectedRequest, Response = expectedResponse }; _mockProviderRepository.GetMatchingTestScopedInteraction(HttpVerb.Get, "/") .Returns(interaction); handler.Handle(nancyContext); _mockResponseMapper.Received(1).Convert(expectedResponse); }
public void WillRespondWith_WithValidInteraction_PerformsAdminInteractionsPostRequestWithTestContext() { var providerState = "My provider state"; var description = "My description"; var request = new ProviderServiceRequest { Method = HttpVerb.Head, Path = "/tester/testing/1" }; var response = new ProviderServiceResponse { Status = (int)HttpStatusCode.ProxyAuthenticationRequired }; var mockService = GetSubject(); mockService.Start(); mockService .Given(providerState) .UponReceiving(description) .With(request) .WillRespondWith(response); var actualRequest = _fakeHttpMessageHandler.RequestsRecieved.Single(); Assert.Equal("MockProviderServiceTests.WillRespondWith_WithValidInteraction_PerformsAdminInteractionsPostRequestWithTestContext", actualRequest.Headers.Single(x => x.Key == Constants.AdministrativeRequestTestContextHeaderKey).Value.Single()); }
public void Convert_WithPlainTextBody_CallsHttpBodyContentMapperAndCorrectlySetsBody() { const string content = "Plain text body"; Request request = GetPreCannedRequest(content: content); var httpBodyContent = new HttpBodyContent(new MediaTypeHeaderValue("text/plain") { CharSet = "utf-8" }); httpBodyContent.GenerateContent(request.Body); var mockHttpVerbMapper = Substitute.For <IHttpVerbMapper>(); var mockHttpBodyContentMapper = Substitute.For <IHttpBodyContentMapper>(); mockHttpVerbMapper.Convert("GET").Returns(HttpVerb.Get); mockHttpBodyContentMapper.Convert(content: Arg.Any <byte[]>(), headers: null).Returns(httpBodyContent); var mapper = new ProviderServiceRequestMapper(mockHttpVerbMapper, mockHttpBodyContentMapper); ProviderServiceRequest result = mapper.Convert(request); Assert.Equal(content, result.Body); mockHttpBodyContentMapper.Received(1).Convert(content: Arg.Any <byte[]>(), headers: null); }
private void ClearTrasientState() { _request = null; _response = null; _providerState = null; _description = null; }
public void WillRespondWith_WhenExistingInteractionExistAndWeHaveAnotherValidInteraction_InteractionIsAdded() { var providerState = "My provider state"; var description = "My description"; var request = new ProviderServiceRequest(); var response = new ProviderServiceResponse(); var mockService = GetSubject(); mockService .UponReceiving("My previous description") .With(new ProviderServiceRequest()) .WillRespondWith(new ProviderServiceResponse()); mockService .Given(providerState) .UponReceiving(description) .With(request) .WillRespondWith(response); var interaction = mockService.Interactions.Last() as ProviderServiceInteraction; Assert.Equal(2, mockService.Interactions.Count()); Assert.Equal(providerState, interaction.ProviderState); Assert.Equal(description, interaction.Description); Assert.Equal(request, interaction.Request); Assert.Equal(response, interaction.Response); }
public void Convert_WithContentLengthHeader_ContentLengthHeaderIsAddedToHttpRequestMessageContentHeaders() { var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Length", "12" } }, Body = "Some content" }; var httpBodyContent = new HttpBodyContent(request.Body, "text/plain", Encoding.UTF8); var stringContent = new StringContent(request.Body, Encoding.UTF8, "text/plain"); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <string>(), Arg.Any <IDictionary <string, string> >()).Returns(httpBodyContent); _mockHttpContentMapper.Convert(httpBodyContent).Returns(stringContent); var result = mapper.Convert(request); Assert.Equal(request.Headers.Last().Key, result.Content.Headers.Last().Key); Assert.Equal(request.Headers.Last().Value, result.Content.Headers.Last().Value.First()); }
public void WillRespondWith_WhenAddingADuplicateInteractionAfterClearingInteractions_TheDuplicateInteractionIsNotAdded() { var providerState = "My provider state"; var description = "My description"; var request = new ProviderServiceRequest(); var response = new ProviderServiceResponse(); var mockService = GetSubject(); mockService .Given(providerState) .UponReceiving(description) .With(request) .WillRespondWith(response); var expectedInteractions = mockService.Interactions; mockService.ClearInteractions(); mockService .Given(providerState) .UponReceiving(description) .With(request) .WillRespondWith(response); var actualIneractions = mockService.Interactions; Assert.Equal(1, actualIneractions.Count()); Assert.Equal(expectedInteractions.First(), actualIneractions.First()); }
public void Convert_WithPlainContentTypeHeaderLowercased_HeaderIsNotAddedToHttpRequestMessageAndHttpContentMapperIsCalledWithContentType() { const string contentTypeString = "text/plain"; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "content-type", contentTypeString } }, Body = new { } }; var httpBodyContent = new HttpBodyContent(content: Encoding.UTF8.GetBytes(String.Empty), contentType: new MediaTypeHeaderValue(contentTypeString) { CharSet = "utf-8" }); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); var result = mapper.Convert(request); Assert.Empty(result.Headers); _mockHttpContentMapper.Received(1).Convert(httpBodyContent); }
public void Handle_WithNancyContext_CompareIsCalledOnTheProviderServiceRequestComparer() { var expectedRequest = new ProviderServiceRequest(); var expectedResponse = new ProviderServiceResponse(); var actualRequest = new ProviderServiceRequest(); var mockRequestComparer = Substitute.For <IProviderServiceRequestComparer>(); var mockRequestMapper = Substitute.For <IProviderServiceRequestMapper>(); var mockResponseMapper = Substitute.For <INancyResponseMapper>(); var nancyContext = new NancyContext { Request = new Request("GET", "/", "HTTP") }; var interactions = new List <ProviderServiceInteraction> { new ProviderServiceInteraction { Request = expectedRequest, Response = expectedResponse } }; nancyContext.SetMockInteraction(interactions); mockRequestMapper.Convert(nancyContext.Request).Returns(actualRequest); IMockProviderNancyRequestHandler handler = new MockProviderNancyRequestHandler(mockRequestComparer, mockRequestMapper, mockResponseMapper); handler.Handle(nancyContext); mockRequestComparer.Received(1).Compare(expectedRequest, actualRequest); }
public void Convert_WithContentTypeAndCustomHeader_OnlyCustomHeadersIsAddedToHttpRequestMessage() { const string contentTypeString = "text/plain"; var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString }, { "X-Custom", "My Custom header" } }, Body = new { } }; var httpBodyContent = new HttpBodyContent(content: Encoding.UTF8.GetBytes(String.Empty), contentType: new MediaTypeHeaderValue(contentTypeString) { CharSet = "utf-8" }); var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); var result = mapper.Convert(request); Assert.Equal(request.Headers.Last().Key, result.Headers.First().Key); Assert.Equal(request.Headers.Last().Value, result.Headers.First().Value.First()); }
public void GetMatchingTestScopedInteraction_WithNoMatchingTestScopedInteraction_ThrowsPactFailureException() { var interaction = new ProviderServiceInteraction { Description = "My description", Request = new ProviderServiceRequest { Method = HttpVerb.Head, Path = "/tester" }, Response = new ProviderServiceResponse { Status = (int)HttpStatusCode.NoContent } }; var nonMatchingRequest = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/tester" }; var repo = GetSubject(); _mockReporter.When(x => x.ThrowIfAnyErrors()) .Do(x => { throw new PactFailureException("[Failure] Expected: Head, Actual: Get"); }); repo.AddInteraction(interaction); Assert.Throws <PactFailureException>(() => repo.GetMatchingTestScopedInteraction(nonMatchingRequest)); }
public void Convert_WithTheWorks_CorrectlyMappedHttpRequestMessageIsReturned() { const string encodingString = "utf-8"; var encoding = Encoding.UTF8; const string contentTypeString = "application/json"; const string bodyJson = "{\"Test\":\"tester\",\"Testing\":1}"; var request = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/events", Headers = new Dictionary <string, string> { { "Content-Type", contentTypeString + "; charset=" + encodingString }, { "X-Custom", "My Custom header" }, { "Content-Length", "10000" }, //This header is removed and replace with the correct value of 29 }, Body = new { Test = "tester", Testing = 1 } }; var httpBodyContent = new HttpBodyContent(bodyJson, contentTypeString, encoding); var mockHttpMethodMapper = Substitute.For <IHttpMethodMapper>(); var mockHttpContentMapper = Substitute.For <IHttpContentMapper>(); var mockHttpBodyContentMapper = Substitute.For <IHttpBodyContentMapper>(); mockHttpMethodMapper.Convert(HttpVerb.Get).Returns(HttpMethod.Get); mockHttpContentMapper.Convert(httpBodyContent).Returns(new StringContent(bodyJson, encoding, contentTypeString)); mockHttpBodyContentMapper.Convert(Arg.Any <object>(), request.Headers).Returns(httpBodyContent); IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper( mockHttpMethodMapper, mockHttpContentMapper, mockHttpBodyContentMapper); var result = mapper.Convert(request); var requestContent = result.Content.ReadAsStringAsync().Result; var contentTypeHeader = result.Content.Headers.First(x => x.Key.Equals("Content-Type")); var customHeader = result.Headers.First(x => x.Key.Equals("X-Custom")); var contentLengthHeader = result.Content.Headers.First(x => x.Key.Equals("Content-Length")); Assert.Equal(bodyJson, requestContent); //Content-Type header Assert.Equal(request.Headers.First().Key, contentTypeHeader.Key); Assert.Equal(request.Headers.First().Value, contentTypeHeader.Value.First()); //X-Custom header Assert.Equal(request.Headers.Skip(1).First().Key, customHeader.Key); Assert.Equal(request.Headers.Skip(1).First().Value, customHeader.Value.First()); //Content-Length header Assert.Equal(request.Headers.Last().Key, contentLengthHeader.Key); Assert.Equal("29", contentLengthHeader.Value.First()); }
public void Handle_WithNancyContextRequestThatDoesNotMatchExpectedRequest_ResponseMapperIsCalledAndReturns500Response() { var expectedRequest = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/Test" }; var actualRequest = new ProviderServiceRequest { Method = HttpVerb.Put, Path = "/Test" }; var expectedResponse = new ProviderServiceResponse { Status = 200 }; var nancyResponse = new Response { StatusCode = HttpStatusCode.OK }; var compareException = new CompareFailedException("Something failed"); var mockRequestComparer = Substitute.For <IProviderServiceRequestComparer>(); var mockRequestMapper = Substitute.For <IProviderServiceRequestMapper>(); var mockResponseMapper = Substitute.For <INancyResponseMapper>(); var nancyContext = new NancyContext { Request = new Request("GET", "/Test", "HTTP") }; var interactions = new List <ProviderServiceInteraction> { new ProviderServiceInteraction { Request = expectedRequest, Response = expectedResponse } }; nancyContext.SetMockInteraction(interactions); mockRequestMapper.Convert(nancyContext.Request).Returns(actualRequest); mockRequestComparer .When(x => x.Compare(expectedRequest, actualRequest)) .Do(x => { throw compareException; }); mockResponseMapper.Convert(expectedResponse).Returns(nancyResponse); mockResponseMapper.Convert(Arg.Any <ProviderServiceResponse>()) .Returns(new Response { StatusCode = HttpStatusCode.InternalServerError }); IMockProviderNancyRequestHandler handler = new MockProviderNancyRequestHandler(mockRequestComparer, mockRequestMapper, mockResponseMapper); var response = handler.Handle(nancyContext); mockResponseMapper.Received(1).Convert(Arg.Is <ProviderServiceResponse>(x => x.Status == 500)); Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode); Assert.NotEmpty(response.ReasonPhrase); }
public HandledRequest(ProviderServiceRequest actualRequest, ProviderServiceInteraction matchedInteraction) { ActualRequest = actualRequest; MatchedInteraction = matchedInteraction; }