# Yksikön testaus Umami.Net M SK1 Testi UmamiClient

# Esitys

Nyt minulla on [Umami.Net-paketti](https://www.nuget.org/packages/Umami.Net/) tietenkään haluan varmistaa, että kaikki toimii odotetulla tavalla. Paras tapa tehdä tämä on testata kaikki menetelmät ja luokkat jossain määrin kaikilta osin.
Huomautuksena on, että tämä ei ole 'perfecti lähestymistapa 'tyyppinen lähennys, vaan , se on vain tapa, jolla olen tällä hetkellä tehnyt sen. `IHttpMessageHandler` täällä voi hyökätä DelegatingMessageHandler:ia tavalliseen HttpClient -palveluun tehdäkseen tämän. Halusin vain osoittaa, miten te voitte tehdä sen Mockilla.

[TOC]

<!--category-- xUnit, Umami -->
<datetime class="hidden">2024-09-01T17:22</datetime>

# Yksikön testaus

Yksikön testaus tarkoittaa yksittäisten koodiyksiköiden testaamista sen varmistamiseksi, että ne toimivat odotetulla tavalla. Tämä tehdään kirjoittamalla testejä, jotka kutsuvat menetelmät ja luokit valvottuun tapaan ja tarkistaa sitten, että tulos on odotettu.

Umami.Netin kaltaiselle paketille tämä on melko hankalaa, koska molemmat kutsuvat kaukolähettilään `HttpClient` ja on `IHostedService` se tekee uusien tapahtumatietojen lähettämisestä mahdollisimman sujuvan.

## UmamiClient testataan

Suurin osa testauksesta `HttpClient` perustavan kirjaston on vältettävä todellista 'HttpClient' puhelua . Tämä tehdään luomalla `HttpClient` jossa käytetään `HttpMessageHandler` , joka palauttaa tietyn vastauksen. Tämä tehdään luomalla `HttpClient` omalla `HttpMessageHandler` , joka palauttaa tietyn vastauksen; tässä tapauksessa minä vain toistan takaisin input-vastauksen ja tarkistan, että `UmamiClient`.

```csharp
    public static HttpMessageHandler Create()
    {
        var mockHandler = new Mock<HttpMessageHandler>();

        mockHandler.Protected()
            .Setup<Task<HttpResponseMessage>>(
                "SendAsync",
                ItExpr.Is<HttpRequestMessage>(x => x.RequestUri.ToString().Contains("api/send")),
                ItExpr.IsAny<CancellationToken>())
            .ReturnsAsync((HttpRequestMessage request, CancellationToken cancellationToken) =>
            {
                // Read the request content
                var requestBody = request.Content != null
                    ? request.Content.ReadAsStringAsync(cancellationToken).Result
                    : null;

                // Create a response that echoes the request body
                var responseContent = requestBody != null
                    ? requestBody
                    : "No request body";


                // Return the response
                return new HttpResponseMessage(HttpStatusCode.OK)
                {
                    Content = new StringContent(responseContent, Encoding.UTF8, "application/json")
                };
            });

        return mockHandler.Object;
    }
```

Kuten näette, tämä asettaa `Mock<HttpMessageHandler>` Siirryn sitten `UmamiClient`.
Tässä koodissa liitän tämän `IServiceCollection` järjestelymenetelmä. Tämä lisää kaikki palvelut, joita `UmamiClient` mukaan lukien uusi `HttpMessageHandler` ja palauttaa sen jälkeen `IServiceCollection` testeissä käytettäväksi.

```csharp
    public static IServiceCollection SetupServiceCollection(string webSiteId = Consts.WebSiteId,
        string umamiPath = Consts.UmamiPath, HttpMessageHandler? handler = null)
    {
        var services = new ServiceCollection();
        var umamiClientSettings = new UmamiClientSettings
        {
            WebsiteId = webSiteId,
            UmamiPath = umamiPath
        };
        services.AddSingleton(umamiClientSettings);
        services.AddScoped<PayloadService>();
        services.AddLogging(x => x.AddConsole());
        // Mocking HttpMessageHandler with Moq
        var mockHandler = handler ?? EchoMockHandler.Create();
        services.AddHttpClient<UmamiClient>((serviceProvider, client) =>
        {
            var umamiSettings = serviceProvider.GetRequiredService<UmamiClientSettings>();
            client.BaseAddress = new Uri(umamiSettings.UmamiPath);
        }).ConfigurePrimaryHttpMessageHandler(() => mockHandler);
        return services;
    }
```

Tämän käyttämiseksi ja sen siirtämiseksi `UmamiClient` Käytän sitten näitä palveluja `UmamiClient` setup.

```csharp
    public static UmamiClient GetUmamiClient(IServiceCollection? serviceCollection = null,
        HttpContextAccessor? contextAccessor = null)
    {
        serviceCollection ??= SetupServiceCollection();
        SetupUmamiClient(serviceCollection, contextAccessor);
        if (serviceCollection == null) throw new NullReferenceException(nameof(serviceCollection));
        var serviceProvider = serviceCollection.BuildServiceProvider();
        return serviceProvider.GetRequiredService<UmamiClient>();
    }
```

Huomaatte, että minulla on joukko vaihtoehtoisia valinnaisia parametreja, joiden avulla voin antaa erilaisia vaihtoehtoja eri testityypeille.

### Testit

Näin ollen nyt minulla on kaikki tämä järjestely paikallaan voin nyt alkaa kirjoittaa testejä `UmamiClient` menetelmät.

#### Siirtää

Kaikki tämä järjestely merkitsee sitä, että testimme voivat olla varsin yksinkertaisia

```csharp
public class UmamiClient_SendTests
{
    [Fact]
    public async Task Send_Wrong_Type()
    {
        var umamiClient = SetupExtensions.GetUmamiClient();
        await Assert.ThrowsAsync<ArgumentException>(async () => await umamiClient.Send(type: "boop"));
    }

    [Fact]
    public async Task Send_Empty_Success()
    {
        var umamiClient = SetupExtensions.GetUmamiClient();
        var response = await umamiClient.Send();
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
    }
}
```

Tässä on yksinkertaisin testitapaus,, jossa varmistetaan, että `UmamiClient` voi lähettää viestin ja saada vastauksen; on tärkeää, että testaamme myös poikkeustapauksen, jossa `type` on väärä. Tämä on usein unohdettu osa testaustaM SK1 varmistaa, että koodi epäonnistuu odotetulla tavalla

#### Luettelo sivuista

Pageview-menetelmämme testaamiseksi voimme tehdä jotain samanlaista. `EchoHttpHandler` vain heijastamaan lähetettyä vastausta ja varmistamaan, että se lähettää takaisin sen, mitä odotan

```csharp
    [Fact]
    public async Task TrackPageView_WithNoUrl()
    {
        var defaultUrl = "/testpath";
        var contextAccessor = SetupExtensions.SetupHttpContextAccessor(path: "/testpath");
        var umamiClient = SetupExtensions.GetUmamiClient(contextAccessor: contextAccessor);
        var response = await umamiClient.TrackPageView();

        var content = await response.Content.ReadFromJsonAsync<EchoedRequest>();
        Assert.NotNull(response);
        Assert.NotNull(content);
        Assert.Equal(content.Payload.Url, defaultUrl);
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
    }
```

### HttpContextAccessor

Siinä käytetään `HttpContextAccessor` siirtää tietä `/testpath` ja sitten tarkistaa, että `UmamiClient` lähettää tämän oikein.

```csharp
    public static HttpContextAccessor SetupHttpContextAccessor(string host = Consts.Host,
        string path = Consts.Path, string ip = Consts.Ip, string userAgent = Consts.UserAgent,
        string referer = Consts.Referer)
    {
        HttpContext httpContext = new DefaultHttpContext();
        httpContext.Request.Host = new HostString(host);
        httpContext.Request.Path = new PathString(path);
        httpContext.Connection.RemoteIpAddress = IPAddress.Parse(ip);
        httpContext.Request.Headers.UserAgent = userAgent;
        httpContext.Request.Headers.Referer = referer;

        var context = new HttpContextAccessor { HttpContext = httpContext };
        return context;
    }

```

Tämä on tärkeää Umami-klienttikoodillemme, koska suurin osa jokaisesta pyynnöstä lähetetyistä tiedoista syntyy dynaamisesti `HttpContext` object. Näin emme voi lähettää mitään lainkaan `await umamiClient.TrackPageView();` puhelu ja se lähettää edelleen oikeat tiedot ottamalla Url `HttpContext`.

Kuten näemme myöhemmin, on myös tärkeää, että kunnioitettavat lähettävät tuotteet kuten `UserAgent` ja `IPAddress` , koska ne käytetään Umami-Serverissä tietojen ja 'trackM SK1 käyttäjänäkymien seuraamiseen käyttämättä cookiesta

Jotta tämä olisi ennustettavissa määrittelemme joukon talletuksia `Consts` luokka. Näin voimme testata ennustettavissa olevia vastauksia ja vaatimuksia vastaan

```csharp
public class Consts
{
    public const string UmamiPath = "https://example.com";
    public const string WebSiteId = "B41A9964-FD33-4108-B6EC-9A6B68150763";
    public const string Host = "example.com";
    public const string Path = "/example";
    public const string Ip = "127.0.0.1";
    public const string UserAgent = "Test User Agent";
    public const string Referer = "Test Referer";
    public const string DefaultUrl = "/testpath";
    public const string DefaultTitle = "Example Page";
    public const string DefaultName = "RSS";
    public const string DefaultType = "event";

    public const string Email = "test@test.com";

    public const string UserId = "11224456";
    
    public const string UserName = "Test User";
    
    public const string SessionId = "B41A9964-FD33-4108-B6EC-9A6B68150763";
}
```

## Lisätestit

Tämä on vasta alku Umamia koskevasta testausstrategiasta. `IHostedService` ja testataan todellisia tietoja Umami tuottaa (, joka ei ole dokumentoitu missään, mutta sisältää JWT-tokenin ja joitakin hyödyllisiä tietoja.

```json
{
  "alg": "HS256",
  "typ": "JWT"
}{
  "id": "b9836672-feee-55c5-985a-a5a23d4a23ad",
  "websiteId": "32c2aa31-b1ac-44c0-b8f3-ff1f50403bee",
  "hostname": "example.com",
  "browser": "chrome",
  "os": "Windows 10",
  "device": "desktop",
  "screen": "1920x1080",
  "language": "en-US",
  "country": "GB",
  "subdivision1": null,
  "subdivision2": null,
  "city": null,
  "createdAt": "2024-09-01T09:26:14.418Z",
  "visitId": "e7a6542f-671a-5573-ab32-45244474da47",
  "iat": 1725182817
}2|Y*: �(N%-ޘ^1>@V
```

Näin ollen haluamme' testata sen, simuloida token ja mahdollisesti palauttaa tiedot jokaisesta vierailusta M SK2kuten te ' muistatte, että tämä on tehty `uuid(websiteId,ipaddress, useragent)`).

# Päätelmissä

Tämä on vasta alku Umami-paketin testaamisesta.,, ', on vielä paljon tehtävää, mutta tämä on hyvä alku.