Pact Net Pact Verification Failed with 404 response

Question

I am testing a GET endpoint which is supposed to return 200 but it is returning 404, and the response header is also incorrect.

Here is the log:

    Failures:

1) Verifying a pact between API Consumer and Weather API Given There is data - A GET request to retrieve the weather
    1.1) has a matching body
           / -> Expected body Present(496 bytes) but was empty
    1.2) has status code 200
           expected 200 but was 404
    1.3) includes header 'Content-Type' with value '"application/json; charset=utf-8"'
           Expected header 'Content-Type' to have value '"application/json; charset=utf-8"' but was ''

There were 1 pact failures

Verifier Logs
-------------
2023-07-24T11:13:08.962868Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier: Executing provider states
2023-07-24T11:13:08.962901Z  INFO ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier: Running setup provider state change handler 'There is data' for 'A GET request to retrieve the weather forecasts'
2023-07-24T11:13:08.968810Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier::provider_client: Sending HTTP Request ( method: POST, path: /, query: None, headers: Some({"Content-Type": ["application/json"]}), body: Present(54 bytes, application/json) ) to state change handler
2023-07-24T11:13:08.969055Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: reqwest::connect: starting new connection: http://localhost:7058/    
2023-07-24T11:13:08.978147Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: hyper::client::connect::http: connecting to [::1]:7058
2023-07-24T11:13:08.978582Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: hyper::client::connect::http: connected to [::1]:7058
2023-07-24T11:13:09.107613Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: hyper::client::pool: pooling idle connection for ("http", localhost:7058)
2023-07-24T11:13:09.107649Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier::provider_client: State change request: Response { url: Url { scheme: "http", cannot_be_a_base: false, username: "", password: None, host: Some(Domain("localhost")), port: Some(7058), path: "/provider-states", query: None, fragment: None }, status: 200, headers: {"content-length": "0", "date": "Mon, 24 Jul 2023 11:13:08 GMT", "server": "Kestrel"} }
2023-07-24T11:13:09.107736Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier: State Change: "ProviderState { name: "There is data", params: {} }" -> Ok({})
2023-07-24T11:13:09.107750Z  INFO ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier: Running provider verification for 'A GET request to retrieve the weather'
2023-07-24T11:13:09.107789Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier: Verifying a HTTP interaction
2023-07-24T11:13:09.107817Z  INFO ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier::provider_client: Sending request to provider at http://localhost:7058/
2023-07-24T11:13:09.107818Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier::provider_client: Provider details = ProviderInfo { name: "Weather API", protocol: "http", host: "localhost", port: Some(7058), path: "/", transports: [ProviderTransport { transport: "http", port: Some(7058), path: Some("/"), scheme: None }] }
2023-07-24T11:13:09.107829Z  INFO ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier::provider_client: Sending request HTTP Request ( method: GET, path: /weather-forecast, query: None, headers: None, body: Missing )
2023-07-24T11:13:09.107831Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier::provider_client: body:

2023-07-24T11:13:09.107853Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: hyper::client::pool: reuse idle connection for ("http", localhost:7058)
2023-07-24T11:13:09.118997Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: hyper::client::pool: pooling idle connection for ("http", localhost:7058)
2023-07-24T11:13:09.119024Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier::provider_client: Received native response: Response { url: Url { scheme: "http", cannot_be_a_base: false, username: "", password: None, host: Some(Domain("localhost")), port: Some(7058), path: "/weather-forecast", query: None, fragment: None }, status: 404, headers: {"content-length": "0", "date": "Mon, 24 Jul 2023 11:13:08 GMT", "server": "Kestrel"} }
2023-07-24T11:13:09.119062Z  INFO ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier::provider_client: Received response: HTTP Response ( status: 404, headers: Some({"content-length": ["0"], "date": ["Mon", "24 Jul 2023 11:13:08 GMT"], "server": ["Kestrel"]}), body: Empty )
2023-07-24T11:13:09.119067Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_verifier::provider_client: body:

2023-07-24T11:13:09.119088Z  INFO ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather"}: pact_matching: comparing to expected response: HTTP Response ( status: 200, headers: Some({"Content-Type": ["application/json; charset=utf-8"]}), body: Present(496 bytes) )
2023-07-24T11:13:09.119130Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather forecasts"}: pact_matching: expected content type = 'application/json;charset=utf-8', actual content type = '*/*'
2023-07-24T11:13:09.119352Z DEBUG ThreadId(01) verify_interaction{interaction="A GET request to retrieve the weather forecasts"}: pact_matching: content type header matcher = 'RuleList { rules: [], rule_logic: And, cascaded: false }'

And here is my code that I got from the sample in the docs (the Provider state is indeed set up, nor is it required for me, since we are returning hardcoded data).

public class ProviderTests : IDisposable
{
    private readonly IHost server;
    public Uri ServerUri { get; }
    private readonly PactVerifier verifier;

    public ProviderTests(ITestOutputHelper output)
    {
        ServerUri = new Uri("http://localhost:7058");
        server = Host.CreateDefaultBuilder()
                     .ConfigureWebHostDefaults(webBuilder =>
                     {
                         webBuilder.UseUrls(ServerUri.ToString());
                         webBuilder.UseStartup<TestStartup>();
                     })
                     .Build();
        server.Start();

        this.verifier = new PactVerifier(new PactVerifierConfig
        {
            LogLevel = PactLogLevel.Debug,
            Outputters = new List<IOutput>
                {
                    new XunitOutput(output)
                }
        });
    }

    public void Dispose()
    {
        server.Dispose();
    }

    [Fact]
    public void EnsureSomethingApiHonoursPactWithConsumer()
    {
        // Arrange

        string pactPath = Path.Combine("..",
                                       "..",
                                       "..",
                                       "..",
                                       "ConsumerTests",
                                       "pacts",
                                       "API Consumer.json");

        try
        {
            this.verifier
                .ServiceProvider("Weather API", ServerUri)
                .WithFileSource(new FileInfo(pactPath))
                .WithProviderStateUrl(new Uri(ServerUri, "/provider-states"))
                .Verify();
        } catch (Exception e)
        {
            throw;
        }
        
    }
}

Answer 1

I'm facing the same problem. Check if your ServerUri (http://localhost:7058) is the same as where the application is being hosted. You can check it on your launchSettings.json, and you can also set the port at the Program.cs like:

public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup<Startup>()
            .UseUrls("http://localhost:5073")
            .Build();
}

I've done that but still receiving those 404 too. Hope I can come back here with more infos.

[UPDATE]

I find out that when we use the TestStartup the endpoints are not registered because the assembly that is calling the Startup isTest.csproj rather than Api.csproj.

There is a way to list all the endpoints being registered by just adding at the Configure method on the Api Startup.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IActionDescriptorCollectionProvider actionProvider)
{
    //...

    var routes = actionProvider.ActionDescriptors.Items.Where(x => x.AttributeRouteInfo != null);
    foreach (var route in routes)
    {
        Console.WriteLine($"{route.AttributeRouteInfo.Template}");
    }

    //...
}

With this code we can see that when we run the Api it will log all endpoints, but when we run the Pact test, nothing will be logged.

[SOLUTION]

Its kinda cheesy but I added the Api.csproj assembly in the TestStartup before calling the Startup by proxy:

public class TestStartup
{
    private Startup _proxy;

    public TestStartup(IConfiguration configuration)
    {
        _proxy = new Startup(configuration);
    }

    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddMvc().AddApplicationPart(Assembly.GetAssembly(typeof(Startup)));
        _proxy.ConfigureServices(services);
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, IActionDescriptorCollectionProvider actionProvider)
    {
        app.UseMiddleware<ProviderStateMiddleware>();
        _proxy.Configure(app, env, actionProvider);
    }
}