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