public void Verify_WithProviderStateSet_CallsProviderServiceValidatorWithProviderState()
{
var httpClient = new HttpClient();
var mockFileSystem = Substitute.For<IFileSystem>();
var mockPactProviderServiceValidator = Substitute.For<IProviderServiceValidator>();
mockFileSystem.File.ReadAllText(Arg.Any<string>()).Returns("{}");
var pactVerifier = new PactVerifier(mockFileSystem, client => mockPactProviderServiceValidator);
pactVerifier.ProviderStatesFor("My client")
.ProviderState("My Provider State")
.ProviderState("My Provider State 2");
pactVerifier.ServiceProvider("Event API", httpClient)
.HonoursPactWith("My client")
.PactUri("/test.json");
pactVerifier.Verify();
mockPactProviderServiceValidator.Received(1).Validate(
Arg.Any<ProviderServicePactFile>(),
pactVerifier.ProviderStates);
}
public void EnsureProviderApiHonoursPactWithConsumer()
{
var config = new PactVerifierConfig
{
Outputters = new List <PactNet.Infrastructure.Outputters.IOutput> {
new XUnitOutput(_outputHelper)
},
Verbose = true
};
var pactVerifier = new PactVerifier(config);
pactVerifier.ProviderState($"{PactServiceUri}/provider-states")
.ServiceProvider("Provider", ProviderUri)
.HonoursPactWith("Consumer")
.PactUri(@"..\..\..\..\pacts\consumer-api.json")
.Verify();
}
public async Task ShouldVerifyMessagePactWhenSerializedJsonIsReturned()
{
var recipeRepository = new FakeRecipeRepository();
var providerStateHandler = new ProviderStateHandler(recipeRepository);
var messageSender = new MessageSender(recipeRepository);
var config = new PactVerifierConfig
{
ProviderStateHandler = providerStateHandler.Handle,
MessageProducer = (d) => JsonConvert.SerializeObject(messageSender.Send(d))
};
var pactVerifier = new PactVerifier(config);
var buildDirectory = AppContext.BaseDirectory;
var pactDir = Path.GetFullPath($"{buildDirectory}{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}pacts{Path.DirectorySeparatorChar}");
await pactVerifier.VerifyPactAsync(pactDir + "messageConsumer-messageProvider.json");
}
public void EnsureApiHonorsPact()
{
var config = new PactVerifierConfig
{
Outputters = new List <IOutput> {
new XUnitOutput(_output)
},
Verbose = true
};
IPactVerifier verifier = new PactVerifier(config);
verifier.ProviderState($"{_serviceUrl}/provider-states")
.ServiceProvider("PactNet Provider", _providerUrl)
.HonoursPactWith("PactNet Consumer")
.PactUri(@"..\..\..\pacts\pactnet_consumer-pactnet_provider.json");
verifier.Verify();
}
private void VerifyContractWithConsumer(string consumerName)
{
using (var host = WebHost.CreateDefaultBuilder()
.UseUrls(MiddlewareUri)
.UseStartup <TestStartup>()
.Build())
{
host.Start();
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier
.ProviderState($"{MiddlewareUri}/provider-states")
.ServiceProvider(ServiceName, ServerUri)
.HonoursPactWith(consumerName)
.PactUri($"http://localhost/pacts/provider/{ ServiceName }/consumer/{ consumerName }/latest")
.Verify();
}
}
public void EnsureProviderApiHonoursPactWithConsumer()
{
// Arrange
var config = new PactVerifierConfig
{
// NOTE: We default to using a ConsoleOutput,
// however xUnit 2 does not capture the console output,
// so a custom outputter is required.
Outputters = new List <IOutput>
{
new ConsoleOutput()
},
// Output verbose verification logs to the test output
Verbose = true,
PublishVerificationResults = true,
ProviderVersion = System.Environment.GetEnvironmentVariable("TRAVIS_COMMIT")
};
IPactVerifier pactVerifier = new PactVerifier(config);
string pactUrl = System.Environment.GetEnvironmentVariable("PACT_URL");
pactVerifier
.ProviderState($"{_pactServiceUri}/provider-states")
.ServiceProvider("pactflow-example-provider-dotnet", _providerUri);
if (pactUrl != "" && pactUrl != null)
{
// Webhook path - verify the specific pact
pactVerifier.PactUri(pactUrl, new PactUriOptions(System.Environment.GetEnvironmentVariable("PACT_BROKER_TOKEN")));
}
else
{
// Standard verification path - run the
pactVerifier.PactBroker(System.Environment.GetEnvironmentVariable("PACT_BROKER_BASE_URL"),
uriOptions: new PactUriOptions(System.Environment.GetEnvironmentVariable("PACT_BROKER_TOKEN")),
consumerVersionTags: new List <string> {
"master", "prod"
});
}
// Act / Assert
pactVerifier.Verify();
}
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 void Verify_WhenFileDoesNotExistOnFileSystem_ThrowsPactAssertException()
{
var serviceProvider = "Event API";
var serviceConsumer = "My client";
var pactUri = "../../../Consumer.Tests/pacts/my_client-event_api.json";
var mockFileSystem = Substitute.For <IFileSystem>();
mockFileSystem.File.ReadAllText(pactUri).Returns(x => { throw new FileNotFoundException(); });
var pactVerifier = new PactVerifier(mockFileSystem, null)
.ServiceProvider(serviceProvider, new HttpClient())
.HonoursPactWith(serviceConsumer)
.PactUri(pactUri);
Assert.Throws <CompareFailedException>(() => pactVerifier.Verify());
mockFileSystem.File.Received(1).ReadAllText(pactUri);
}
public void EnsureSomethingApiHonoursPactWithConsumer()
{
//Arrange
IPactVerifier pactVerifier = new PactVerifier(() => { }, () => { });
pactVerifier
.ProviderState("There is a something with id 'tester'",
setUp: AddTesterIfItDoesntExist); //NOTE: We also have tearDown
//Act / Assert
using (var testServer = TestServer.Create <Startup>())
{
pactVerifier
.ServiceProvider("TeamB Producer / Something API", testServer.HttpClient)
.HonoursPactWith("Consumer")
.PactUri("../../../TeamA.Consumer.Tests/pacts/teama.consumer-teamb.producer.json")
.Verify();
}
}
public void Verify_Wep_Pacts()
{
using (var fakeApp = new FakeWebHostStarter())
{
var config = new PactVerifierConfig();
IPactVerifier pactVerifier = new PactVerifier(config);
var pactUri = "./../../../../../Web/Piast.Web.Tests/pacts/web-api.json";
pactVerifier
.ProviderState("http://localhost:5000/Ping")
.ServiceProvider("Api", "http://localhost:5000")
.HonoursPactWith("Web")
.PactUri(pactUri)
.Verify();
}
}
public void EnsureProviderApiHonoursPactWithConsumer()
{
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new XUnitOutput(_outputHelper)
},
Verbose = true
};
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier.ProviderState($"{_pactServiceUri}/pact-states")
.ServiceProvider("Provider", _providerUri)
.HonoursPactWith("Consumer")
.PactUri("../../../../../pacts/consumer-provider.json")
.Verify();
}
public async Task EnsureWordCountServiceApiHonoursPactWithConsumer()
{
//Arrange
var outputter = new CustomOutputter();
var config = new PactVerifierConfig();
config.ReportOutputters.Add(outputter);
IPactVerifier pactVerifier = new PactVerifier(() => { }, () => { }, config);
pactVerifier
.ProviderState(
"there is a count of 1 for words beginning with 'A'",
setUp: IncrementWordCountForLetterA);
var configuration = new HttpConfiguration();
_server = TestServer.Create(app =>
{
var apiStartup = new Startup();
apiStartup.Configuration(app, configuration);
});
//var result = await _server.HttpClient.PutAsync("AddWord/AardVark", null);
using (var client = new HttpClient(_server.Handler))
{
// requires routing setup in Startup
//var response = await client.PutAsync("http://localhost/api/default/AddWord/Ardvark", null);
var response = await client.GetAsync("http://localhost/api/default/Count");
var result = await response.Content.ReadAsAsync <string>();
}
//Act / Assert
pactVerifier
.ServiceProvider("WordCountServiceApi", _server.HttpClient)
.HonoursPactWith("WordCountWebService")
.PactUri("../../../../WordCount.WebService.Tests/bin/pacts/wordcountwebservice-wordcountserviceapi.json")
.Verify();
// Verify that verifaction log is also sent to additional reporters defined in the config
Assert.Contains("Verifying a Pact between WordCountWebService and WordCountService API", outputter.Output);
}
public void VerifyPact(
string providerName,
string consumerName,
Action <ProviderState> providerState,
Action <IServiceCollection> configureDi = null,
IConfiguration configuration = null,
string pactDirectory = "../../../../pacts"
)
{
var baseUrl = $"http://localhost:{_servicePort}";
var serviceBuilder = new HostBuilder()
.ConfigureWebHostDefaults(c =>
{
c.UseStartup <TStartup>();
c.UseEnvironment("Development");
if (configureDi != null)
{
c.ConfigureTestServices(configureDi);
}
c.UseUrls(baseUrl);
if (configuration != null)
{
c.UseConfiguration(configuration);
}
c.ConfigureLogging(l => l.AddXUnit(_testOutput));
});
using (serviceBuilder.StartAsync().GetAwaiter().GetResult())
{
var pactFilePath = $"{pactDirectory}/{consumerName}-{providerName}.json";
var pactVerifier = new PactVerifier(new PactVerifierConfig {
ProviderBaseUrl = baseUrl, ProviderStateHandler = providerState
});
pactVerifier.VerifyPactAsync(pactFilePath).GetAwaiter().GetResult();
}
}
public void TestProvider()
{
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new XUnitOutput(_output)
},
Verbose = true
};
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier
.ServiceProvider("ToDoList", "http://*****:*****@"\Users\sukanyar\RiderProjects\ToDoWebapi\ToDoWebApi.ContractTests\bin\Debug\netcoreapp3.1\~\dotnet\pacts\service_consumer-todolist.json")
.Verify();
}
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 void EnsureProviderApiHonoursPactWithConsumer()
{
// Arrange
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new ConsoleOutput()
},
Verbose = true
};
// Act / Assert
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier.ServiceProvider("ExampleApi", _providerUri)
.HonoursPactWith("ExampleSite")
.PactUri(@"pathtopactfile\examplesite-exampleapi.json")
.Verify();
}
public void EnsureProductPactTest()
{
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new XUnitOutput(_outputHelper)
},
Verbose = true
};
//Act & Assert
var pactVerifier = new PactVerifier(config);
pactVerifier
.ProviderState($"{_serviceUrl}/provider-states")
.ServiceProvider("Provider", _serviceUrl)
.HonoursPactWith("Consumer")
.PactUri("..\\..\\..\\pacts\\consumer-provider.json")
.Verify();
}
public void EnsureAmortizationApiHonorsPactWithConsumer()
{
// Arrange
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new XUnitOutput(_output)
},
Verbose = true
};
// Act, Assert
var pactVerifier = new PactVerifier(config);
pactVerifier
.ServiceProvider("Mortgage API", "http://*****:*****@"C:\repos\mortgage-amortization\src\Mortgage.UI\pacts\mortgage_ui-mortgage_api.json")
.Verify();
}
public void EnsureProviderApiHonoursPactWithConsumer()
{
// Arrange
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new XUnitOutput(_outputHelper)
},
Verbose = true
};
//Act / Assert
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier.ProviderState($"{_pactServiceUri}/provider-states")
.ServiceProvider("Provider", _providerUri)
.HonoursPactWith("Consumer")
.PactUri($"/Users/ralzate/Develop/arquetipos/lambda_webapi_serverless/pacts/consumer-provider.json")
.Verify();
}
public void EnsureProviderApiHonoursPactWithConsumer()
{
//Arrange
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new XUnitOuput(_outputhelper)
},
Verbose = true
};
//Act/Assert
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier.ProviderState($"{_pactServiceUri}/provider-states")
.ServiceProvider("Provider", _providerUri)
.HonoursPactWith("Consumer")
.PactUri(@"..\..\..\..\..\pacts\consumer-provider.json")
.Verify();
}
//[Ignore("PACT BROKER")]
public void EnsurePactDemoProviderHobnoursPactWithPactDemoConsumerUsingPactBroker()
{
var wipSinceDate = "2020-01-01";
var token = Environment.GetEnvironmentVariable("PACT_BROKER_TOKEN");
var pactBrokerBaseUrl = "https://expandtesting.pact.dius.com.au";
var pactUriOptions = new PactUriOptions(token);
// fake Git HashCode (only for demo)
var version = "11bb818";
var config = new PactVerifierConfig
{
ProviderVersion = version,
PublishVerificationResults = true,
Verbose = true
};
var consumerVersionSelectors = new List <VersionTagSelector>
{
new VersionTagSelector("master", null, null, false, true),
};
var pactVerifier = new PactVerifier(config);
pactVerifier.ProviderState($"{pactServiceUri}/provider-states");
pactVerifier.ServiceProvider(providerName, $"{providerServiceUri}");
var providerVersionTags = new List <string> {
"master"
};
// Verify
pactVerifier.PactBroker(pactBrokerBaseUrl,
uriOptions: pactUriOptions,
enablePending: false,
includeWipPactsSince: wipSinceDate,
providerVersionTags: providerVersionTags,
consumerVersionSelectors: consumerVersionSelectors)
.Verify();
}
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 VerificationForMessagePactShouldFailWhenWrongMessageIsReturned()
{
var config = new PactVerifierConfig
{
MessageProducer = (p, d) => null
};
var pactVerifier = new PactVerifier(config);
var buildDirectory = AppContext.BaseDirectory;
var pactDir = Path.GetFullPath($"{buildDirectory}{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}pacts{Path.DirectorySeparatorChar}");
try
{
await pactVerifier.VerifyPactAsync(pactDir + "messageConsumer-messageProvider.json");
}
catch (PactException e)
{
Assert.IsTrue(e.Message.Contains("Expected body or contents to be present, but was not"));
throw;
}
}
public void EnsureEventApiHonoursPactWithConsumer()
{
//Arrange
const string serviceUri = "http://localhost:9222";
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new XUnitOutput(_output)
}
};
using (WebApp.Start <Startup>(serviceUri))
{
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier
.ServiceProvider("Provider", serviceUri)
.HonoursPactWith("Consumer")
.PactUri($"..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}Consumer.Tests{Path.DirectorySeparatorChar}pacts{Path.DirectorySeparatorChar}consumer-provider.json")
.Verify();
}
}
public void EnsureProviderApiHonoursPactWithConsumer()
{
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new XUnitOutput(_outputHelper)
},
PublishVerificationResults = true,
Verbose = true,
ProviderVersion = "2.0.0"
};
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier
.ProviderState($"{_pactServiceUri}/provider-states")
.ServiceProvider("Weather Forecast API", _pactServiceUri)
.HonoursPactWith("Consumer")
.PactUri(@"..\..\..\..\PactSandbox.ClientTests\pacts\consumer-weather_forecast_api.json")
.Verify();
}
public void EnsureSomethingApiHonoursPactWithConsumer()
{
//Arrange
const string serviceUri = "http://localhost:5000";
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new XUnitOutput(_output)
},
ProviderVersion = "2.0.0",
Verbose = true
};
var builder = new WebHostBuilder()
.UseKestrel()
.ConfigureLogging(logging =>
{
logging.SetMinimumLevel(LogLevel.Warning);
logging.AddConsole();
})
.UseStartup <Startup>();
var brokerUri = Environment.GetEnvironmentVariable("BROKER_URI") ??
"http://Richards-MacBook-Pro-98861.local:32792";
using (var service = builder.Start())
{
//Act / Assert
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier
.ProviderState($"{serviceUri}/provider-states")
.ServiceProvider("Consumer API", serviceUri)
.HonoursPactWith("Consumer")
.PactUri(
$"{brokerUri}/pacts/provider/Consumer%20API/consumer/Consumer/latest") //You can specify a http or https uri
.Verify();
}
}
public void EnsureSomethingApiHonoursPactWithConsumer()
{
//Arrange
var config = new PactVerifierConfig();
_providerStateManager.AddState(
"A utc date '2017-03-20T12:00:01.00Z' and language 'en-GB'",
() => DateTime.Parse("2017-03-20T12:00:01.00Z"));
using (StartServer(_providerStateManager))
{
//Act //Assert
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier
.ProviderState($"{ServiceUri}/provider-states")
.ServiceProvider("DateFormatter.WebApi", ServiceUri)
.HonoursPactWith("SampleApp.ConsoleApp")
.PactUri($"{ConfigurationManager.AppSettings["DateFormatter.WebApiPact.Dir"]}/sampleapp.consoleapp-dateformatter.webapi.json")
.Verify();
}
}
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 void EnsureEventApiHonoursPactWithConsumer()
{
ContextInfo.SetTestContextName(GetType().Name);
//Arrange
var outputter = new CustomOutputter();
var config = new PactVerifierConfig();
config.ReportOutputters.Add(outputter);
IPactVerifier pactVerifier = new PactVerifier(() => {}, () => {}, config);
pactVerifier
.ProviderState(
"there are events with ids '45D80D13-D5A2-48D7-8353-CBB4C0EAABF5', '83F9262F-28F1-4703-AB1A-8CFD9E8249C9' and '3E83A96B-2A0C-49B1-9959-26DF23F83AEB'",
setUp: InsertEventsIntoDatabase)
.ProviderState("there is an event with id '83f9262f-28f1-4703-ab1a-8cfd9e8249c9'",
setUp: InsertEventIntoDatabase)
.ProviderState("there is one event with type 'DetailsView'",
setUp: EnsureOneDetailsViewEventExists);
// todo (HACK): Find a better way to inject pact config into MockProviderNancyBootstrapper
MockProviderNancyBootstrapper.PactConfig = new PactConfig();
var builder = new WebHostBuilder();
builder.UseStartup <Startup4ProviderRun>();
_server = new TestServer(builder);
//Act / Assert
pactVerifier
.ServiceProvider("Event API", _server.CreateClient())
.HonoursPactWith("Consumer")
.PactUri("../../../Consumer.Tests/pacts/consumer-event_api.json")
.Verify();
// Verify that verifaction log is also sent to additional reporters defined in the config
Assert.Contains("Verifying a Pact between Consumer and Event API", outputter.Output);
}
public async Task ShouldVerifyPact_ProviderHttpClient()
{
var baseUrl = "http://localhost:9494";
var recipeRepository = new FakeRecipeRepository();
var providerStateHandler = new ProviderStateHandler(recipeRepository);
var cts = new CancellationTokenSource();
Task hostTask;
using (var client = new HttpClient {
BaseAddress = new Uri(baseUrl)
})
{
var pactVerifier = new PactVerifier(new PactVerifierConfig
{
ProviderHttpClient = client, ProviderStateHandler = providerStateHandler.Handle
});
hostTask = WebHost.CreateDefaultBuilder()
.UseKestrel()
.UseUrls(baseUrl)
.ConfigureServices(services =>
{
services.Add(new ServiceDescriptor(typeof(IRecipeRepository), recipeRepository));
})
.UseStartup <TestStartup>()
.Build().RunAsync(cts.Token);
var buildDirectory = AppContext.BaseDirectory;
var pactDir =
Path.GetFullPath(
$"{buildDirectory}{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}pacts{Path.DirectorySeparatorChar}");
await pactVerifier.VerifyPactAsync(pactDir + "recipe-consumer-recipe-service.json");
}
cts.Cancel();
await hostTask;
}
public void EnsureDinkumCoinApiHonoursPactWithConsumer()
{
//Arrange
const string serviceUri = "https://8lyhztzwh3.execute-api.ap-southeast-2.amazonaws.com/Dev";
var config = new PactVerifierConfig
{
Outputters = new List <IOutput>
{
new XUnitOutput(_output)
}
};
IPactVerifier pactVerifier = new PactVerifier(config);
pactVerifier
// .ProviderState($"{serviceUri}/provider-states")
.ServiceProvider("dinkum-coin-api", serviceUri)
.HonoursPactWith("dinkum-coin-web")
.PactUri($"pacts/dinkum-coin-web-dinkum-coin-api.json")
.Verify();
}
public void Verify_WhenFileDoesNotExistOnFileSystem_ThrowsPactAssertException()
{
var serviceProvider = "Event API";
var serviceConsumer = "My client";
var pactUri = "../../../Consumer.Tests/pacts/my_client-event_api.json";
var mockFileSystem = Substitute.For<IFileSystem>();
mockFileSystem.File.ReadAllText(pactUri).Returns(x => { throw new FileNotFoundException(); });
var pactVerifier = new PactVerifier(mockFileSystem, null)
.ServiceProvider(serviceProvider, new HttpClient())
.HonoursPactWith(serviceConsumer)
.PactUri(pactUri);
Assert.Throws<CompareFailedException>(() => pactVerifier.Verify());
mockFileSystem.File.Received(1).ReadAllText(pactUri);
}
public void Verify_WhenPactFileWithNoInteractionsExistOnFileSystem_CallsPactProviderValidator()
{
var serviceProvider = "Event API";
var serviceConsumer = "My client";
var pactUri = "../../../Consumer.Tests/pacts/my_client-event_api.json";
var pactFileJson = "{ \"provider\": { \"name\": \"" + serviceProvider + "\" }, \"consumer\": { \"name\": \"" + serviceConsumer + "\" }, \"metadata\": { \"pactSpecificationVersion\": \"1.0.0\" } }";
var httpClient = new HttpClient();
var mockFileSystem = Substitute.For<IFileSystem>();
var mockPactProviderServiceValidator = Substitute.For<IProviderServiceValidator>();
mockFileSystem.File.ReadAllText(pactUri).Returns(pactFileJson);
var pactVerifier = new PactVerifier(mockFileSystem, client => mockPactProviderServiceValidator)
.ServiceProvider(serviceProvider, httpClient)
.HonoursPactWith(serviceConsumer)
.PactUri(pactUri);
pactVerifier.Verify();
mockFileSystem.File.Received(1).ReadAllText(pactUri);
mockPactProviderServiceValidator.Received(1).Validate(Arg.Any<ProviderServicePactFile>(), Arg.Any<ProviderStates>());
}
public void Verify_WithProviderState_CallsProviderServiceValidatorWith2FilteredInteractions()
{
var providerState = "My Provider State";
var pactUri = "../../../Consumer.Tests/pacts/my_client-event_api.json";
var pactFileJson = "{ \"provider\": { \"name\": \"Event API\" }, \"consumer\": { \"name\": \"My client\" }, \"interactions\": [{ \"description\": \"My Description\", \"provider_state\": \"My Provider State\" }, { \"description\": \"My Description 2\", \"provider_state\": \"My Provider State\" }, { \"description\": \"My Description\", \"provider_state\": \"My Provider State 2\" }], \"metadata\": { \"pactSpecificationVersion\": \"1.0.0\" } }";
var httpClient = new HttpClient();
var mockFileSystem = Substitute.For<IFileSystem>();
var mockPactProviderServiceValidator = Substitute.For<IProviderServiceValidator>();
mockFileSystem.File.ReadAllText(pactUri).Returns(pactFileJson);
var pactVerifier = new PactVerifier(mockFileSystem, client => mockPactProviderServiceValidator);
pactVerifier.ProviderStatesFor("My client")
.ProviderState("My Provider State")
.ProviderState("My Provider State 2");
pactVerifier.ServiceProvider("Event API", httpClient)
.HonoursPactWith("My client")
.PactUri(pactUri);
pactVerifier.Verify(providerState: providerState);
mockPactProviderServiceValidator.Received(1).Validate(
Arg.Is<ProviderServicePactFile>(x => x.Interactions.Count() == 2 && x.Interactions.All(i => i.ProviderState.Equals(providerState))),
Arg.Any<ProviderStates>());
}
