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());
}
