C# – Eine einfache Anleitung zum Einrichten von Wiremock.Net für Integrationstests

 C Programming >> C-Programmierung >  >> Tags >> .NET
C# – Eine einfache Anleitung zum Einrichten von Wiremock.Net für Integrationstests

Suchen Sie eine einfache Anleitung zur Einrichtung von Wiremock.Net? Nun, ich hoffe, das kann Ihnen helfen :) Ich habe das gestern gemacht, weil ich es für ein Hobbyprojekt verwenden wollte. Ich verwende die Standardanwendung .Net Weatherforecast als Beispiel für diesen Beitrag. Ich verwende xUnit, aber Sie können jedes gewünschte Testframework verwenden.

Den Aufbau meines Projekts können Sie hier einsehen:

Der Standard WeatherForecastController sieht in etwa so aus:

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };
    
    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        var rng = new Random();
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = rng.Next(-20, 55),
            Summary = Summaries[rng.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

Wir können einen kleinen Test durchführen, um zu sehen, ob dieser Endpunkt funktioniert:

var webApplicationFactory = new WebApplicationFactory<TestRestApplication.Startup>();
var client = webApplicationFactory.CreateClient();
var result = await client.GetAsync("WeatherForecast/");
Assert.NotNull(result);
Assert.True(result.IsSuccessStatusCode);
var responseContent = await result.Content.ReadAsStringAsync();
Assert.NotEmpty(responseContent);

Oben verwenden wir die WebApplicationFactory, um unsere TestRestApplication zum Testen zu starten. Dies gibt einen HttpClient zurück, den wir verwenden können, um mit der Weatherforecast-REST-API zu interagieren. Aufgrund der Zufälligkeit der API behaupten wir nur, dass das Ergebnis nicht leer ist. Als Nächstes ändern wir den Endpunkt, um einen anderen Endpunkt aufzurufen und diesen mit Wiremock zu simulieren.

Wir stellen vor:Wiremock

Um dies mit Wiremock zu testen, bearbeiten wir unseren WeatherForecastController so, dass er einen anderen Endpunkt aufruft, den wir WeatherForecastBackend nennen, aber ansonsten dieselbe Signatur haben:

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private HttpClient _backendHttpClient;
    
    public WeatherForecastController()
    {
        _backendHttpClient = new HttpClient();
    }
    
    [HttpGet]
    public async Task<IEnumerable<WeatherForecast>> Get()
    {
        var result = await _backendHttpClient.GetAsync("http://localhost:58116/weatherforecastbackend");
        return JsonConvert.DeserializeObject<IEnumerable<WeatherForecast>>(await result.Content.ReadAsStringAsync());
    }
}

Das obige Beispiel ruft jetzt "http://localhost:58116/weatherforecastbackend" auf, was wir später verspotten werden, damit es die tatsächliche Wettervorhersage zurückgibt. Ansonsten wird die Signatur des Endpunkts nicht verändert. Im Beispiel habe ich die URL für diesen Beitrag der Einfachheit halber fest codiert. Für den professionellen Einsatz können Sie den Hostnamen/Port mithilfe von appsettings.json einfügen, sodass Sie ihn in Ihrem Test auf den Dummy-Endpunkt, aber in Ihrem Rest-API-Projekt auf den echten Endpunkt verweisen können.

Unten richten wir Wiremock ein, um Anfragen auf „http://localhost:58116/weatherforecastbackend“ zu verarbeiten:

var Summaries = new[] {
    "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" };

var rng = new Random();
var weatherForecastBackendStubResponse = Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
    Date = DateTime.Now.AddDays(index),
    TemperatureC = rng.Next(-20, 55),
    Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToList();

var stubResponseSerialized = JsonConvert.SerializeObject(weatherForecastBackendStubResponse);

var server = WireMockServer.Start(58116);
server
    .Given(
        Request.Create()
            .WithPath("/weatherforecastbackend")
            .UsingGet()
    )
    .RespondWith(
        Response.Create()
            .WithStatusCode(200)
            .WithBody(stubResponseSerialized)
    );

Wir haben die ursprüngliche Logik zum Erstellen der Wettervorhersage übernommen und in unsere Tests verschoben - nichts Erstaunliches. Dann starten wir unseren Wiremock-Server mit WireMockServer.Start(58116) und beginnen Sie mit der Konfiguration. Im "Gegebenen" Teil richten wir unseren Request-Matcher ein - Request.Create() - um Anforderungen auf dem Pfad "/weatherforecastbackend" mit dem HTTP GET-Verb abzugleichen. In der „RespondWith“-Methode konfigurieren wir die Antwort so, dass sie einen Statuscode 200 zurückgibt, und den Textkörper so, dass er die serialisierte Wettervorhersage als JSON enthält.

Wir können dann dieselbe Testlogik wie zuvor verwenden, um zu überprüfen, ob wir beim Ausführen des Tests die richtige Antwort erhalten:

var webApplicationFactory = new WebApplicationFactory<TestRestApplication.Startup>();
var client = webApplicationFactory.CreateClient();

var result = await client.GetAsync("WeatherForecast/");
Assert.NotNull(result);
Assert.True(result.IsSuccessStatusCode);

var responseContent = await result.Content.ReadAsStringAsync();
Assert.NotEmpty(responseContent);

var responseAsWeatherForecast = JsonConvert.DeserializeObject<IEnumerable<WeatherForecast>>(responseContent);
Assert.Equal(stubResponseSerialized.ToLowerInvariant(), responseContent.ToLowerInvariant());

und wir können sehen, dass wir die Antwort von Wiremock erhalten, wenn wir debuggen:

Das ist es!

Ich hoffe, Sie fanden diesen Beitrag zur Verwendung von Wiremock hilfreich. Lassen Sie mich in den Kommentaren unten wissen, ob ich irgendwo mehr Details in den Beitrag einfügen soll :)

Viel Spaß beim Testen!