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(String.Empty, contentTypeString, null); var mockHttpMethodMapper = Substitute.For<IHttpMethodMapper>(); var mockHttpContentMapper = Substitute.For<IHttpContentMapper>(); var mockHttpBodyContentMapper = Substitute.For<IHttpBodyContentMapper>(); mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); mockHttpBodyContentMapper.Convert(Arg.Any<object>(), request.Headers).Returns(httpBodyContent); IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper( mockHttpMethodMapper, mockHttpContentMapper, mockHttpBodyContentMapper); 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 ComparisonResult Compare(ProviderServiceRequest expected, ProviderServiceRequest actual) { var result = new ComparisonResult("sends a request which"); if (expected == null) { result.RecordFailure(new ErrorMessageComparisonFailure("Expected request cannot be null")); return result; } var methodResult = _httpMethodComparer.Compare(expected.Method, actual.Method); result.AddChildResult(methodResult); var pathResult = _httpPathComparer.Compare(expected.Path, actual.Path); result.AddChildResult(pathResult); var queryResult = _httpQueryStringComparer.Compare(expected.Query, actual.Query); result.AddChildResult(queryResult); if (expected.Headers != null && expected.Headers.Any()) { var headerResult = _httpHeaderComparer.Compare(expected.Headers, actual.Headers); result.AddChildResult(headerResult); } if (expected.Body != null) { var bodyResult = _httpBodyComparer.Compare(expected.Body, actual.Body, expected.MatchingRules); result.AddChildResult(bodyResult); } return result; }
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 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 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 Convert_WithBody_HttpContentMapperIsCalled() { var request = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/events", Body = new { Test = "tester" } }; var mockHttpMethodMapper = Substitute.For<IHttpMethodMapper>(); var mockHttpContentMapper = Substitute.For<IHttpContentMapper>(); var mockHttpBodyContentMapper = Substitute.For<IHttpBodyContentMapper>(); mockHttpMethodMapper.Convert(HttpVerb.Get).Returns(HttpMethod.Get); IHttpRequestMessageMapper mapper = new HttpRequestMessageMapper( mockHttpMethodMapper, mockHttpContentMapper, mockHttpBodyContentMapper); mapper.Convert(request); mockHttpBodyContentMapper.Received(1).Convert(request.Body, request.Headers); }
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 void PathWithQuery_WithNullPathAndQuery_ReturnsNull() { var request = new ProviderServiceRequest(); var uri = request.PathWithQuery(); Assert.Null(uri); }
public void PathWithQuery_WithJustQuery_ThrowsInvalidOperationException() { var request = new ProviderServiceRequest { Query = "test1=1&test2=2" }; Assert.Throws<InvalidOperationException>(() => request.PathWithQuery()); }
public void Send_WhenCalled_CallsConvertOnHttpRequestMessageMapper() { var request = new ProviderServiceRequest(); var requestSender = GetSubject(); requestSender.Send(request); _mockHttpRequestMessageMapper.Received(1).Convert(request); }
public ComparisonResult Compare(ProviderServiceRequest expected, ProviderServiceRequest actual) { var result = new ComparisonResult("sends a request which"); if (expected == null) { result.RecordFailure(new ErrorMessageComparisonFailure("Expected request cannot be null")); return result; } var methodResult = _httpMethodComparer.Compare(expected.Method, actual.Method); result.AddChildResult(methodResult); var pathResult = _httpPathComparer.Compare(expected.Path, actual.Path); result.AddChildResult(pathResult); var queryResult = _httpQueryStringComparer.Compare(expected.Query, actual.Query); result.AddChildResult(queryResult); if (expected.Headers != null && expected.Headers.Any()) { var headerResult = _httpHeaderComparer.Compare(expected.Headers, actual.Headers); result.AddChildResult(headerResult); } if (expected.Body != null || actual.Body != null) { if (expected.Body == null) { result.RecordFailure(new ErrorMessageComparisonFailure( "Expected request does not match actual request")); return result; } if (actual.Body == null) { result.RecordFailure(new ErrorMessageComparisonFailure( "Expected request does not match actual request")); return result; } var expectedToken2 = JToken.FromObject(expected.Body); var actualToken2 = JToken.FromObject(actual.Body); if (!TestUtils.CheckAllPropertiesAreEqual(expectedToken2, actualToken2, expected.IgnoreList)) { result.RecordFailure( new ErrorMessageComparisonFailure("Expected request does not match actual request")); } } return result; }
public UnexpectedRequestComparisonFailure(ProviderServiceRequest request) { var requestMethod = request != null ? request.Method.ToString().ToUpperInvariant() : "No Method"; var requestPath = request != null ? request.Path : "No Path"; RequestDescription = String.Format("{0} {1}", requestMethod, requestPath); Result = String.Format( "An unexpected request {0} was seen by the mock provider service.", RequestDescription); }
public void Send_WhenCalled_InvokesTheFuncWithRequest() { var request = new ProviderServiceRequest(); var requestSender = GetSubject(); requestSender.Send(request); Assert.True(_httpRequestSenderFuncCallInfo.Item1, "httpRequestSenderFunc was called"); Assert.Equal(request, _httpRequestSenderFuncCallInfo.Item2); }
public IMockProviderService With(ProviderServiceRequest request) { if (request == null) { throw new ArgumentException("Please supply a non null request"); } _request = request; return this; }
public void PathWithQuery_WithJustPath_ReturnsPath() { var request = new ProviderServiceRequest { Path = "/events" }; var uri = request.PathWithQuery(); Assert.Equal(request.Path, uri); }
public HttpRequestMessage Convert(ProviderServiceRequest from) { if (from == null) { return null; } var requestHttpMethod = _httpMethodMapper.Convert(from.Method); var requestPath = from.PathWithQuery(); var to = new HttpRequestMessage(requestHttpMethod, requestPath); var contentRelatedHeaders = new Dictionary<string, string>(); if (from.Headers != null && from.Headers.Any()) { foreach (var requestHeader in from.Headers) { //Strip any Content- headers as they need to be attached to Request content when using a HttpRequestMessage if (requestHeader.Key.IndexOf("Content-", StringComparison.InvariantCultureIgnoreCase) == 0) { contentRelatedHeaders.Add(requestHeader.Key, requestHeader.Value); continue; } to.Headers.Add(requestHeader.Key, requestHeader.Value); } } if (from.Body != null) { HttpBodyContent bodyContent = _httpBodyContentMapper.Convert(body: from.Body, headers: from.Headers); var httpContent = _httpContentMapper.Convert(bodyContent); //Set the content related headers if (httpContent != null && contentRelatedHeaders.Any()) { foreach (var contentHeader in contentRelatedHeaders) { if (contentHeader.Key.Equals("Content-Type", StringComparison.InvariantCultureIgnoreCase) && httpContent.Headers.Any(x => x.Key.Equals("Content-Type", StringComparison.InvariantCultureIgnoreCase))) { continue; } httpContent.Headers.Add(contentHeader.Key, contentHeader.Value); } } to.Content = httpContent; } return to; }
public void PathWithQuery_WithPathAndQuery_ReturnsPathWithQuery() { var request = new ProviderServiceRequest { Path = "/events", Query = "test1=1&test2=2" }; var uri = request.PathWithQuery(); Assert.Equal(request.Path + "?" + request.Query, uri); }
public void Send_WhenCalled_CallsSendAsyncOnHttpClient() { var request = new ProviderServiceRequest(); var requestSender = GetSubject(); var convertedRequest = new HttpRequestMessage(); _mockHttpRequestMessageMapper.Convert(request) .Returns(convertedRequest); requestSender.Send(request); Assert.Equal(1, _fakeHttpClient.RequestsRecieved.Count()); Assert.Equal(convertedRequest, _fakeHttpClient.RequestsRecieved.First()); }
public void Send_WhenBaseAddressHasATrailingSlash_TheLeadingSlashOnTheRequestPathIsRemoved() { var request = new ProviderServiceRequest { Path = "/testing/hi" }; var requestSender = GetSubject(new FakeHttpClient(baseAddress: "http://localhost/api/v2/")); requestSender.Send(request); _mockHttpRequestMessageMapper.Received(1).Convert(Arg.Is<ProviderServiceRequest>(x => x.Path == "testing/hi")); Assert.Equal("testing/hi", request.Path); }
public void Convert_WithRequest_CallsHttpMethodMapper() { var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events" }; var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); mapper.Convert(request); _mockHttpMethodMapper.Received(1).Convert(request.Method); }
public void Send_WhenBaseAddressDoesNotHaveATrailingSlash_ThePathIsNotAltered() { const string path = "/testing/hi"; var request = new ProviderServiceRequest { Path = path }; var requestSender = GetSubject("http://my-hostname:1234"); _mockHttpRequestMessageMapper.Convert(Arg.Any<ProviderServiceRequest>()).Returns(new HttpRequestMessage()); requestSender.Send(request); _mockHttpRequestMessageMapper.Received(1).Convert(Arg.Is<ProviderServiceRequest>(x => x.Path == path)); Assert.Equal(path, request.Path); }
public void Send_WhenBaseAddressIsNull_ThePathIsNotAltered() { const string path = "/testing/hi"; var request = new ProviderServiceRequest { Path = path }; var requestSender = GetSubject(null); _mockHttpRequestMessageMapper.Convert(Arg.Any<ProviderServiceRequest>()).Returns(new HttpRequestMessage(HttpMethod.Get, "http://tester/")); requestSender.Send(request); _mockHttpRequestMessageMapper.Received(1).Convert(Arg.Is<ProviderServiceRequest>(x => x.Path == path)); Assert.Equal(path, request.Path); }
public ProviderServiceResponse Send(ProviderServiceRequest request) { //Added because of this http://stackoverflow.com/questions/23438416/why-is-httpclient-baseaddress-not-working if (_httpClient.BaseAddress != null && _httpClient.BaseAddress.OriginalString.EndsWith("/")) { request.Path = request.Path.TrimStart('/'); } var httpRequest = _httpRequestMessageMapper.Convert(request); var httpResponse = _httpClient.SendAsync(httpRequest, CancellationToken.None).Result; var response = _providerServiceResponseMapper.Convert(httpResponse); Dispose(httpRequest); Dispose(httpResponse); return response; }
public void Convert_WithBody_HttpContentMapperIsCalled() { var request = new ProviderServiceRequest { Method = HttpVerb.Get, Path = "/events", Body = new { Test = "tester" } }; var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Get).Returns(HttpMethod.Get); mapper.Convert(request); _mockHttpBodyContentMapper.Received(1).Convert(request.Body, request.Headers); }
public void Convert_WithHeader_HeaderIsAddedToHttpRequestMessage() { var request = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/events", Headers = new Dictionary<string, string> { { "X-Custom", "Tester" } } }; var mapper = GetSubject(); _mockHttpMethodMapper.Convert(HttpVerb.Post).Returns(HttpMethod.Post); _mockHttpBodyContentMapper.Convert(Arg.Any<object>(), request.Headers).Returns(new HttpBodyContent(String.Empty, null, null)); var result = mapper.Convert(request); Assert.Equal(request.Headers.First().Key, result.Headers.First().Key); Assert.Equal(request.Headers.First().Value, result.Headers.First().Value.First()); }
public void SerializeObject_WithCamelCaseApiSerializerSettings_ReturnsCorrectJson() { var request = new ProviderServiceRequest { Method = HttpVerb.Get, Headers = new Dictionary<string, string> { { "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_WhenNoMatchingInteractionsAreFound_ErrorIsLogged() { const string exceptionMessage = "No matching mock interaction has been registered for the current request"; var expectedRequest = 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(expectedRequest); _mockResponseMapper.Convert(Arg.Any<ProviderServiceResponse>()) .Returns(new Response { StatusCode = HttpStatusCode.InternalServerError }); _mockProviderRepository .When(x => x.GetMatchingTestScopedInteraction(expectedRequest)) .Do(x => { throw new PactFailureException(exceptionMessage); }); try { handler.Handle(nancyContext); } catch (Exception) { } _mockLog.Received().Log(LogLevel.Error, Arg.Any<Func<string>>(), null, Arg.Any<object[]>()); }
public HttpRequestMessage Convert(ProviderServiceRequest from) { if (from == null) { return null; } var requestHttpMethod = _httpMethodMapper.Convert(from.Method); var requestPath = from.PathWithQuery(); var to = new HttpRequestMessage(requestHttpMethod, requestPath); if (from.Headers != null && from.Headers.Any()) { foreach (var requestHeader in from.Headers) { //TODO: Check if there are any other headers which need special treatment //Handle the content-type header as little differently, as they need to be attached to the content when using a HttpRequestMessage //Strip the Content-Length header as is automatically attached to the request if (requestHeader.Key.Equals("Content-Type", StringComparison.InvariantCultureIgnoreCase) || requestHeader.Key.Equals("Content-Length", StringComparison.InvariantCultureIgnoreCase)) { continue; } to.Headers.Add(requestHeader.Key, requestHeader.Value); } } if (from.Body != null) { HttpBodyContent bodyContent = _httpBodyContentMapper.Convert(from.Body, from.Headers); to.Content = _httpContentMapper.Convert(bodyContent); } return to; }
public void Handle_WithAGetRequestToInteractionsVerificationAndAnInteractionWasSentButNotRegisteredByTheTest_ThrowsPactFailureExceptionWithTheCorrectMessageAndLogsTheUnexpectedRequest() { const string failure = "An unexpected request POST /tester was seen by the mock provider service."; var context = new NancyContext { Request = new Request("GET", "/interactions/verification", "http") }; var handler = GetSubject(); var handledRequest = new ProviderServiceRequest(); var handledInteraction = new ProviderServiceInteraction { Request = handledRequest }; var unExpectedRequest = new ProviderServiceRequest { Method = HttpVerb.Post, Path = "/tester" }; _mockProviderRepository.TestScopedInteractions .Returns(new List<ProviderServiceInteraction> { handledInteraction }); _mockProviderRepository.HandledRequests .Returns(new List<HandledRequest> { new HandledRequest(handledRequest, handledInteraction), new HandledRequest(unExpectedRequest, null) }); var exception = Assert.Throws<PactFailureException>(() => handler.Handle(context)); _mockLog.Received().Log(LogLevel.Error, Arg.Any<Func<string>>(), null, Arg.Any<object[]>()); Assert.Equal(failure, exception.Message); }
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()); }