public async Task PublishingFailedTests()
{
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler();
fakeHttpMessageHandler.Configure(HttpMethod.Post, "http://publish/").RespondsWith(HttpStatusCode.Created);
await PactVerifier.PublishVerificationResultsAsync(
_pact,
new List <Test> {
new Test {
Description = "test1"
},
new Test {
Description = "test2", Issues = new List <string> {
"Something failed"
}
}
},
"1.0",
new HttpClient(fakeHttpMessageHandler) { BaseAddress = new Uri("http://local-pact-broker") },
"http://publish");
var sentVerificationResults = JsonConvert.DeserializeObject <VerificationResults>(fakeHttpMessageHandler.GetStatus(HttpMethod.Post, "http://publish/").SentRequestContents.First().Value);
Assert.IsFalse(sentVerificationResults.Success);
Assert.AreEqual("1.0", sentVerificationResults.ProviderApplicationVersion);
Assert.AreEqual(_pact.Provider.Name, sentVerificationResults.ProviderName);
Assert.AreEqual(2, sentVerificationResults.TestResults.Summary.TestCount);
Assert.AreEqual(1, sentVerificationResults.TestResults.Summary.FailureCount);
Assert.AreEqual("passed", sentVerificationResults.TestResults.Tests.First(t => t.Description == "test1").Status);
Assert.AreEqual("failed", sentVerificationResults.TestResults.Tests.First(t => t.Description == "test2").Status);
Assert.AreEqual("Something failed", sentVerificationResults.TestResults.Tests.First(t => t.Description == "test2").Issues.First());
}
public async Task ShouldCreateMessagePactAfterVerifyingConsumer()
{
var handler = new RecipeAddedHandler();
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler();
fakePactBrokerMessageHandler.Configure(HttpMethod.Put, "http://localhost:9292").RespondsWith(HttpStatusCode.Created);
var publisher = new PactPublisher(new HttpClient(fakePactBrokerMessageHandler) { BaseAddress = new Uri("http://localhost:9292") }, "1.0", "local");
var builder = new MessagePactBuilder("messageConsumer", "messageProvider", publisher);
await builder.SetUp(_messageBuilder
.VerifyConsumer<RecipeAdded>(m => handler.Handle(m)))
.BuildAsync();
// Check if handler has been called
Assert.IsNotNull(handler.ReceivedRecipes.FirstOrDefault());
Assert.AreEqual("A Recipe", handler.ReceivedRecipes.First().Name);
// Check if pact has been published and tagged
Assert.AreEqual("messageConsumer",
JsonConvert.DeserializeObject<Contract>(fakePactBrokerMessageHandler
.GetStatus(HttpMethod.Put, "http://localhost:9292").SentRequestContents.First().Value).Consumer
.Name);
Assert.IsTrue(fakePactBrokerMessageHandler.GetStatus(HttpMethod.Put, "http://localhost:9292").SentRequestContents.Last().Key.Contains("local"));
// Check if pact has been written to project directory.
var buildDirectory = AppContext.BaseDirectory;
var pactDir =
Path.GetFullPath(
$"{buildDirectory}{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}pacts{Path.DirectorySeparatorChar}");
var pactFile = File.ReadAllText(pactDir + "messageConsumer-messageProvider.json");
Assert.AreEqual("messageConsumer", JsonConvert.DeserializeObject<Contract>(pactFile).Consumer.Name);
File.Delete(pactDir + "messageConsumer-messageProvider.json");
}
public async Task ShouldThrowWhenResponseIsNotSuccessful()
{
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler
{
ObjectToReturn = new Contract(),
StatusCodeToReturn = System.Net.HttpStatusCode.BadRequest
};
var config = new PactVerifierConfig
{
PactBrokerClient = new HttpClient(fakePactBrokerMessageHandler)
{
BaseAddress = new Uri("http://localhost:9292")
}
};
var mockConsumer = new PactVerifier(config);
try
{
await mockConsumer.GetPactFromBroker("some/path");
}
catch (PactException e)
{
Assert.AreEqual("Getting pact from Pact Broker failed. Pact Broker returned BadRequest", e.Message);
throw;
}
}
public async Task ShouldThrowWhenClientThrowsForAnyOtherReason()
{
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler
{
ObjectToReturn = new Contract(),
ExceptionToThrow = new HttpRequestException("Something went wrong.")
};
var config = new PactVerifierConfig
{
PactBrokerClient = new HttpClient(fakePactBrokerMessageHandler)
{
BaseAddress = new Uri("http://localhost:9292")
}
};
var mockConsumer = new PactVerifier(config);
try
{
await mockConsumer.GetPactFromBroker("some/path");
}
catch (PactException e)
{
Assert.AreEqual("Pact cannot be retrieved using the provided Pact Broker Client: Something went wrong.", e.Message);
throw;
}
}
public async Task PublishTags_PactNotFound()
{
try
{
const string baseAddress = "http://local-pact-broker";
const string providerName = "test-provider";
const string providerVersion = "1.0.0";
var tags = new List <string> {
"test", "tag"
};
var path = $"{baseAddress}/pacticipants/{providerName}/versions/{providerVersion}/tags/";
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler();
fakeHttpMessageHandler.Configure(HttpMethod.Put, path).RespondsWith(HttpStatusCode.NotFound);
await PactVerifier.PublishTags(new HttpClient(fakeHttpMessageHandler) { BaseAddress = new Uri(baseAddress) }, providerName, providerVersion, tags);
Assert.Fail("Expected exception was not thrown.");
}
catch (PactException e)
{
e.Message.ShouldBe("Publishing tag 'test' failed. Pact Broker returned NotFound");
}
}
public async Task ShouldPublishVerificationResults()
{
var buildDirectory = AppContext.BaseDirectory;
var pactDir = Path.GetFullPath($"{buildDirectory}{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}pacts{Path.DirectorySeparatorChar}");
var pactFileToReturn = File.ReadAllText(pactDir + "messageConsumer-messageProvider.json");
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler
{
ObjectToReturn = JsonConvert.DeserializeObject(pactFileToReturn)
};
var messageSender = new MessageSender();
var config = new PactVerifierConfig
{
MessageProducer = messageSender.Send,
ProviderVersion = "1.0",
PublishVerificationResults = true,
PactBrokerClient = new HttpClient(fakePactBrokerMessageHandler)
{
BaseAddress = new Uri("http://localhost:9292")
}
};
var pactVerifier = new PactVerifier(config);
await pactVerifier.VerifyPactAsync("pacts/provider/messageProvider/consumer/messageConsumer/latest");
var sentVerificationResults = JsonConvert.DeserializeObject <VerificationResults>(fakePactBrokerMessageHandler.SentRequestContents.First().Value);
Assert.IsTrue(sentVerificationResults.Success);
}
public async Task PactBrokerReturnsNonSuccessStatusCode()
{
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler {
StatusCodeToReturn = System.Net.HttpStatusCode.NotFound
};
var config = new PactVerifierConfig
{
ProviderVersion = "1.0",
PactBrokerClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://local-pact-broker")
}
};
var mockConsumer = new PactVerifier(config);
try
{
await mockConsumer.PublishVerificationResultsAsync(_pact, new List <FailedInteraction>());
}
catch (PactException e)
{
Assert.AreEqual("Publishing verification results failed. Pact Broker returned NotFound", e.Message);
throw;
}
}
public async Task ShouldMatchRequest()
{
var url = "http://localhost:9393";
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler();
var publisher = new PactPublisher(new HttpClient(fakePactBrokerMessageHandler)
{
BaseAddress = new Uri("http://localhost:9292")
}, "1.0", "local");
var builder = new PactBuilder("V2-consumer", "V2-provider", url, publisher);
var recipeId = Guid.Parse("2860dedb-a193-425f-b73e-ef02db0aa8cf");
var ingredient = Some.Object.With(
Some.Element.Named("name").Like("Salt"),
Some.Element.Named("amount").Like(5.5),
Some.Element.Named("unit").Like("gram"));
builder.SetUp(Pact.Interaction
.Given($"There is a recipe with id `{recipeId}`")
.UponReceiving("a request")
.With(Pact.Request
.WithHeader("Accept", "application/json")
.WithMethod(Method.GET)
.WithPath($"/api/recipes/{recipeId}"))
.WillRespondWith(Pact.Response
.WithStatus(200)
.WithHeader("Content-Type", "application/json")
.WithBody(Pact.JsonContent.With(
Some.Element.Named("name").Like("A Recipe"),
Some.Element.Named("instructions").Like("Mix it up"),
Some.Array.Named("ingredients").Of(ingredient)
))));
using (var client = new HttpClient {
BaseAddress = new Uri(url)
})
{
client.DefaultRequestHeaders.Add("Accept", "application/json");
var response = await client.GetAsync($"api/recipes/{recipeId}");
Assert.IsTrue(response.IsSuccessStatusCode);
}
await builder.BuildAsync();
// Check if pact has been published and tagged
Assert.AreEqual("V2-consumer", JsonConvert.DeserializeObject <Contract>(fakePactBrokerMessageHandler.SentRequestContents.First().Value).Consumer.Name);
Assert.IsTrue(fakePactBrokerMessageHandler.SentRequestContents.Last().Key.Contains("local"));
// Check if pact has been written to project directory.
var buildDirectory = AppContext.BaseDirectory;
var pactDir = Path.GetFullPath($"{buildDirectory}{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}pacts{Path.DirectorySeparatorChar}");
var pactFile = File.ReadAllText(pactDir + "V2-consumer-V2-provider.json");
Assert.AreEqual("V2-consumer", JsonConvert.DeserializeObject <Contract>(pactFile).Consumer.Name);
File.Delete(pactDir + "V2-consumer-V2-provider.json");
}
public async Task ShouldGetPactFromPactBroker()
{
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler();
fakePactBrokerMessageHandler.Configure(HttpMethod.Get, "http://localhost:9292/some/path")
.RespondsWith(HttpStatusCode.OK).Returns(new Contract());
var pactBrokerResults = await PactVerifier.GetPactFromBroker(new HttpClient(fakePactBrokerMessageHandler) { BaseAddress = new Uri("http://localhost:9292") }, "some/path");
Assert.IsNotNull(pactBrokerResults);
Assert.IsNotNull(JsonConvert.DeserializeObject <Contract>(pactBrokerResults.PactContent));
Assert.IsNotNull(pactBrokerResults.PublishVerificationResultsUrl);
}
public async Task TaggingIsOptional()
{
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler();
var pactPublisher = new PactPublisher(new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://local-pact-broker")
}, "1.0");
await pactPublisher.PublishAsync(_pact);
Assert.AreEqual("http://local-pact-broker/pacts/provider/provider/consumer/consumer/version/1.0", fakeHttpMessageHandler.SentRequestContents.First().Key);
var sentContract = JsonConvert.DeserializeObject <Contract>(fakeHttpMessageHandler.SentRequestContents.First().Value);
Assert.IsNotNull(sentContract);
Assert.AreEqual(_pact.Consumer.Name, sentContract.Consumer.Name);
}
public async Task ShouldThrowWhenResponseIsNotSuccessful()
{
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler();
fakePactBrokerMessageHandler.Configure(HttpMethod.Get, "http://localhost:9292/some/path")
.RespondsWith(HttpStatusCode.BadRequest).Returns(new Contract());
try
{
await PactVerifier.GetPactFromBroker(new HttpClient(fakePactBrokerMessageHandler) { BaseAddress = new Uri("http://localhost:9292") }, "some/path");
}
catch (PactException e)
{
Assert.AreEqual("Getting pact from Pact Broker failed. Pact Broker returned BadRequest", e.Message);
throw;
}
}
public async Task ShouldThrowWhenClientHasNoBaseAddress()
{
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler();
fakePactBrokerMessageHandler.Configure(HttpMethod.Put, "http://localhost:9292")
.RespondsWith(HttpStatusCode.Created).Returns(new Contract());
try
{
await PactVerifier.GetPactFromBroker(new HttpClient(fakePactBrokerMessageHandler), "some/path");
}
catch (PactException e)
{
Assert.AreEqual("A PactBrokerClient with at least a BaseAddress should be configured to be able to retrieve contracts.", e.Message);
throw;
}
}
public async Task ShouldThrowWhenClientThrowsForAnyOtherReason()
{
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler();
fakePactBrokerMessageHandler.Configure(HttpMethod.Get, "http://localhost:9292")
.RespondsWith(HttpStatusCode.Created).Returns(new Contract())
.ThowsException(new HttpRequestException("Something went wrong."));
try
{
await PactVerifier.GetPactFromBroker(new HttpClient(fakePactBrokerMessageHandler) { BaseAddress = new Uri("http://localhost:9292") }, "some/path");
}
catch (PactException e)
{
Assert.AreEqual("Pact cannot be retrieved using the provided Pact Broker Client: Something went wrong.", e.Message);
throw;
}
}
public async Task ShouldPublishVerificationResults()
{
var buildDirectory = AppContext.BaseDirectory;
var pactDir = Path.GetFullPath($"{buildDirectory}{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}pacts{Path.DirectorySeparatorChar}");
var pactFileToReturn = File.ReadAllText(pactDir + "messageConsumer-messageProvider.json");
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler();
fakePactBrokerMessageHandler
.Configure(HttpMethod.Get,
"http://localhost:9292/pacts/provider/messageProvider/consumer/messageConsumer/latest")
.RespondsWith(HttpStatusCode.Created).Returns(JsonConvert.DeserializeObject(pactFileToReturn));
fakePactBrokerMessageHandler
.Configure(HttpMethod.Post, "http://localhost:9292/publish/verification/results/path")
.RespondsWith(HttpStatusCode.Created);
var recipeRepository = new FakeRecipeRepository();
var providerStateHandler = new ProviderStateHandler(recipeRepository);
var messageSender = new MessageSender(recipeRepository);
var config = new PactVerifierConfig
{
ProviderStateHandler = providerStateHandler.Handle,
MessageProducer = messageSender.Send,
ProviderVersion = "1.0",
PublishVerificationResults = true,
PactBrokerClient = new HttpClient(fakePactBrokerMessageHandler)
{
BaseAddress = new Uri("http://localhost:9292")
}
};
var pactVerifier = new PactVerifier(config);
await pactVerifier.VerifyPactAsync("pacts/provider/messageProvider/consumer/messageConsumer/latest");
var sentVerificationResults = JsonConvert.DeserializeObject <VerificationResults>(
fakePactBrokerMessageHandler.GetStatus(HttpMethod.Post,
"http://localhost:9292/publish/verification/results/path")
.SentRequestContents.First().Value);
Assert.IsTrue(sentVerificationResults.Success);
Assert.AreEqual(1, sentVerificationResults.TestResults.Summary.TestCount);
Assert.AreEqual(0, sentVerificationResults.TestResults.Summary.FailureCount);
}
public async Task ShouldCreateMessagePactAfterVerifyingConsumerAsynchronously()
{
var handler = new RecipeAddedHandler();
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler();
fakePactBrokerMessageHandler.Configure(HttpMethod.Put, "http://localhost:9292").RespondsWith(HttpStatusCode.Created);
var publisher = new PactPublisher(new HttpClient(fakePactBrokerMessageHandler) { BaseAddress = new Uri("http://localhost:9292") }, "1.0", "local");
var builder = new MessagePactBuilder("messageConsumer", "messageProvider", publisher);
var messsageBuilder = await _messageBuilder
.VerifyConsumerAsync<RecipeAdded>(m => handler.HandleAsync(m));
await builder.SetUp(messsageBuilder)
.BuildAsync();
// Check if handler has been called
Assert.IsNotNull(handler.ReceivedRecipes.FirstOrDefault());
Assert.AreEqual("A Recipe", handler.ReceivedRecipes.First().Name);
}
public async Task PactBrokerReturnsNonSuccessStatusCode()
{
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler();
fakeHttpMessageHandler.Configure(HttpMethod.Post, "http://publish/").RespondsWith(HttpStatusCode.NotFound);
try
{
await PactVerifier.PublishVerificationResultsAsync(
_pact,
new List <Test>(),
"1.0",
new HttpClient(fakeHttpMessageHandler) { BaseAddress = new Uri("http://local-pact-broker") },
"http://publish");
}
catch (PactException e)
{
Assert.AreEqual("Publishing verification results failed. Pact Broker returned NotFound", e.Message);
throw;
}
}
public async Task ShouldThrowWhenClientThrowsForAnyOtherReason()
{
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler()
{
ExceptionToThrow = new HttpRequestException("Something went wrong.")
};
var pactPublisher = new PactPublisher(new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://local-pact-broker")
}, "1.0");
try
{
await pactPublisher.PublishAsync(_pact);
}
catch (PactException e)
{
Assert.AreEqual("Pact cannot be published using the provided Pact Broker Client: Something went wrong.", e.Message);
throw;
}
}
public async Task ShouldThrowWhenCallNotSuccessful()
{
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler()
{
StatusCodeToReturn = System.Net.HttpStatusCode.BadRequest
};
var pactPublisher = new PactPublisher(new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://local-pact-broker")
}, "1.0");
try
{
await pactPublisher.PublishAsync(_pact);
}
catch (PactException e)
{
Assert.AreEqual("Publishing contract failed. Pact Broker returned BadRequest", e.Message);
throw;
}
}
public async Task PublishTags()
{
const string baseAddress = "http://local-pact-broker";
const string providerName = "test-provider";
const string providerVersion = "1.0.0";
var tags = new List <string> {
"test", "tag"
};
var path = $"{baseAddress}/pacticipants/{providerName}/versions/{providerVersion}/tags/";
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler();
fakeHttpMessageHandler.Configure(HttpMethod.Put, path).RespondsWith(HttpStatusCode.Created);
await PactVerifier.PublishTags(new HttpClient(fakeHttpMessageHandler) { BaseAddress = new Uri(baseAddress) }, providerName, providerVersion, tags);
foreach (var tag in tags)
{
fakeHttpMessageHandler.GetStatus(HttpMethod.Put, path).CalledUrls.ShouldContain($"{path}{tag}");
}
}
public async Task SuccessfulPublicationAndTagging()
{
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler();
fakeHttpMessageHandler.Configure(HttpMethod.Put, "http://local-pact-broker")
.RespondsWith(HttpStatusCode.Created);
var pactPublisher = new PactPublisher(new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://local-pact-broker")
}, "1.0", "local");
await pactPublisher.PublishAsync(_pact);
Assert.AreEqual("http://local-pact-broker/pacts/provider/provider/consumer/consumer/version/1.0", fakeHttpMessageHandler.GetStatus(HttpMethod.Put, "http://local-pact-broker").SentRequestContents.First().Key);
var sentContract = JsonConvert.DeserializeObject <Contract>(fakeHttpMessageHandler.GetStatus(HttpMethod.Put, "http://local-pact-broker").SentRequestContents.First().Value);
Assert.IsNotNull(sentContract);
Assert.AreEqual(_pact.Consumer.Name, sentContract.Consumer.Name);
Assert.AreEqual("http://local-pact-broker/pacticipants/consumer/versions/1.0/tags/local", fakeHttpMessageHandler.GetStatus(HttpMethod.Put, "http://local-pact-broker").SentRequestContents.Last().Key);
}
public async Task ShouldGetPactFromPactBroker()
{
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler
{
ObjectToReturn = new Contract()
};
var config = new PactVerifierConfig
{
PactBrokerClient = new HttpClient(fakePactBrokerMessageHandler)
{
BaseAddress = new Uri("http://localhost:9292")
}
};
var mockConsumer = new PactVerifier(config);
var stringContent = await mockConsumer.GetPactFromBroker("some/path");
Assert.IsNotNull(stringContent);
Assert.IsNotNull(JsonConvert.DeserializeObject <Contract>(stringContent));
}
public async Task ShouldThrowWhenClientThrowsForAnyOtherReason()
{
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler();
fakeHttpMessageHandler.Configure(HttpMethod.Put, "http://local-pact-broker")
.RespondsWith(HttpStatusCode.Created)
.ThowsException(new HttpRequestException("Something went wrong."));
var pactPublisher = new PactPublisher(new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://local-pact-broker")
}, "1.0");
try
{
await pactPublisher.PublishAsync(_pact);
}
catch (PactException e)
{
Assert.AreEqual("Pact cannot be published using the provided Pact Broker Client: Something went wrong.", e.Message);
throw;
}
}
public async Task SuccessfulPublication()
{
var fakeHttpMessageHandler = new FakePactBrokerMessageHandler();
var config = new PactVerifierConfig
{
ProviderVersion = "1.0",
PactBrokerClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://local-pact-broker")
}
};
var mockConsumer = new PactVerifier(config);
await mockConsumer.PublishVerificationResultsAsync(_pact, new List <FailedInteraction>());
var sentVerificationResults = JsonConvert.DeserializeObject <VerificationResults>(fakeHttpMessageHandler.SentRequestContents.First().Value);
Assert.IsTrue(sentVerificationResults.Success);
Assert.AreEqual(config.ProviderVersion, sentVerificationResults.ProviderApplicationVersion);
Assert.AreEqual(_pact.Provider.Name, sentVerificationResults.ProviderName);
Assert.IsFalse(sentVerificationResults.FailedInteractions.Any());
}
public async Task ShouldThrowWhenClientHasNoBaseAddress()
{
var fakePactBrokerMessageHandler = new FakePactBrokerMessageHandler
{
ObjectToReturn = new Contract(),
};
var config = new PactVerifierConfig
{
PactBrokerClient = new HttpClient(fakePactBrokerMessageHandler)
};
var mockConsumer = new PactVerifier(config);
try
{
await mockConsumer.GetPactFromBroker("some/path");
}
catch (PactException e)
{
Assert.AreEqual("A PactBrokerClient with at least a BaseAddress should be configured to be able to retrieve contracts.", e.Message);
throw;
}
}
