# Yksikön testaus Umami.Net M SK1UamiBackgroundSender

# Esitys

Aiemmassa artiklassa, keskustelimme siitä, miten testataan `UmamiClient` xUnitin ja Moqin avulla. Tässä artiklassaM SK1 keskustelemme siitä, miten testataan `UmamiBackgroundSender` luokka. `UmamiBackgroundSender` on hieman erilainen kuin `UmamiClient` kuten se käyttää `IHostedService` pysyä taustalla ja lähettää pyyntöjä läpi `UmamiClient` päätoimia koskevasta threadistä täysin pois. (siten se ei estä täytäntöönpanoa.

Kuten tavallista, voitte nähdä tämän koko lähdekoodin GitHubissani. [täällä](https://github.com/scottgal/mostlylucidweb/blob/main/Umami.Net.Test/UmamiBackgroundSender_Tests.cs).

[TOC]

<!--category-- xUnit, Umami, IHostedService, Moq -->
<datetime class="hidden">2024-09-03T09:00</datetime>

## `UmamiBackgroundSender`

Todellisen rakenteen `UmamiBackgroundSender` on varsin yksinkertainen. Se on hostoitu palvelu, joka lähettää pyyntöjä Umami-Serveriin heti kun se havaitsee uuden pyynnön. `UmamiBackgroundSender` luokka on nähtävissä jäljempänä:

```csharp
public class UmamiBackgroundSender(IServiceScopeFactory scopeFactory, ILogger<UmamiBackgroundSender> logger) : IHostedService
{

    private  Channel<SendBackgroundPayload> _channel = Channel.CreateUnbounded<SendBackgroundPayload>();

    private Task _sendTask = Task.CompletedTask;
    
        public Task StartAsync(CancellationToken cancellationToken)
    {

        _sendTask = SendRequest(_cancellationTokenSource.Token);
        return Task.CompletedTask;
    }
    
            public async Task StopAsync(CancellationToken cancellationToken)
        {
            logger.LogInformation("UmamiBackgroundSender is stopping.");

            // Signal cancellation and complete the channel
            await _cancellationTokenSource.CancelAsync();
            _channel.Writer.Complete();
            try
            {
                // Wait for the background task to complete processing any remaining items
                await Task.WhenAny(_sendTask, Task.Delay(Timeout.Infinite, cancellationToken));
            }
            catch (OperationCanceledException)
            {
                logger.LogWarning("StopAsync operation was canceled.");
            }
        }
        
                private async Task SendRequest(CancellationToken token)
    {
        logger.LogInformation("Umami background delivery started");

        while (await _channel.Reader.WaitToReadAsync(token))
        {
            while (_channel.Reader.TryRead(out var payload))
            {
                try
                {
                   using  var scope = scopeFactory.CreateScope();
                    var client = scope.ServiceProvider.GetRequiredService<UmamiClient>();
                    // Send the event via the client
                    await client.Send(payload.Payload, type:payload.EventType);

                    logger.LogInformation("Umami background event sent: {EventType}", payload.EventType);
                }
                catch (OperationCanceledException)
                {
                    logger.LogWarning("Umami background delivery canceled.");
                    return; // Exit the loop on cancellation
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, "Error sending Umami background event.");
                }
            }
        }
    }

    private record SendBackgroundPayload(string EventType, UmamiPayload Payload);
    
    }

```

Kuten voitte nähdä, tämä on vain klassinen `IHostedService` it's lisättiin ASP-palvelukokonaisuuteemme using the `services.AddHostedService<UmamiBackgroundSender>()` menetelmä. Tämä käynnistää `StartAsync` menetelmän soveltamisen alkaessa.
Näkemyksensä sisäpuolella `SendRequest` menetelmä on se, missä ihme tapahtuu. Tämä on se paikka, jossa lukemme kanaalista ja lähetämme pyynnön Umami-verkon serveriin

Tämä sulkee pois todelliset menetelmät, joilla pyynnöt lähetetään.

```csharp
public async Task TrackPageView(string url, string title, UmamiPayload? payload =null, UmamiEventData? eventData = null)

public async Task Identify(string? email = null, string? username = null,
        string? sessionId = null, string? userId = null, UmamiEventData? eventData = null)   

        public async Task IdentifySession(string sessionId, UmamiEventData? eventData = null)

public async Task Track(string eventName, UmamiEventData? eventData = null)

public async Task Send(UmamiPayload? payload = null, UmamiEventData? eventData = null,
        string eventType = "event")
```

Kaikki tämä todellakin paketoi pyynnön mukaan `SendBackgroundPayload` tallennetaan ja lähetetään kanavalle.

Our nested receive loop in `SendRequest` aikoo jatkaa kuuntelua kanavasta siihen asti, kunnes se on suljettu. Tähän keskitämme testausponnistelumme

```csharp
  while (await _channel.Reader.WaitToReadAsync(token))
        {
            while (_channel.Reader.TryRead(out var payload))
            {
            }
        }    

```

Taustapalvelussa on joitakin semanttikoita, joiden ansiosta se voi lopettaa viestin heti sen saapuessa.
Tämä aiheuttaa kuitenkin ongelman, jos emme saa palautettua arvoa `Send` miten testaamme sen, että se todellakin tekee mitä tahansa

## Testi `UmamiBackgroundSender`

Kysymys kuuluukin, miten testaamme tätä palvelua sen jälkeen, kun ' ei ole vastannut todelliseen testiin.

Vastaus on antaa `HttpMessageHandler` mocked HttpClient, jonka lähetämme UmamiClientiin. Näin voimme pysäyttää pyynnön ja tarkistaa sen

### EchoMockHttpMessageHandler

You' palauttaa mieleen edellisen artikkelin, jossa otimme käyttöön mock HttpMessageHandlerin. `EchoMockHandler` Staattinen luokka:

```csharp
public static class EchoMockHandler
{
    public static HttpMessageHandler Create(
        Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> responseFunc)
    {
        var mockHandler = new Mock<HttpMessageHandler>();
        mockHandler.Protected()
            .Setup<Task<HttpResponseMessage>>(
                "SendAsync",
                ItExpr.IsAny<HttpRequestMessage>(),
                ItExpr.IsAny<CancellationToken>())
            .ReturnsAsync((HttpRequestMessage request, CancellationToken cancellationToken) =>
                responseFunc(request, cancellationToken).Result);

        return mockHandler.Object;
    }
```

Voitte nähdä, että tässä Mock-järjestelmässä `SendAsync` menetelmä, joka palauttaa vastauksen pyynnöstä (HttpClientissä kaikki asynkkipyynnöt tehdään `SendAsync`).

Näette, että ensin järjestimme mokin

```csharp
     var mockHandler = new Mock<HttpMessageHandler>();
```

Sen jälkeen hyödynnämme `Protected` ottaa käyttöön `SendAsync` menetelmä. Tämä johtuu `SendAsync` ' ei ole tavallisesti saatavilla julkisessa API:ssa `HttpMessageHandler`.

```csharp
public abstract class HttpMessageHandler : IDisposable
    {
        protected HttpMessageHandler()
        {
        }
        protected internal abstract Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken);
```

Käytämme sen jälkeen vain saaliita `ItExpr.IsAny` vastata kaikkiin pyyntöihin ja palauttaa vastauksen `responseFunc` menemme läpi

## Testimenetelmät.

Sisäpuolella `UmamiBackgroundSender_Tests` luokissa meillä on yhteinen tapa määritellä kaikki testimenetelmät.

### Järjestelmä

```csharp
[Fact]
    public async Task Track_Page_View()
    {
        var page = "https://background.com";
        var title = "Background Example Page";
        var tcs = new TaskCompletionSource<bool>();
        // Arrange
        var handler = EchoMockHandler.Create(async (message, token) =>
        {
            try
            {
                var responseContent = EchoMockHandler.ResponseHandler(message, token);
                var jsonContent = await responseContent.Result.Content.ReadFromJsonAsync<EchoedRequest>(token);
                var content = new StringContent("{}", Encoding.UTF8, "application/json");
                Assert.Contains("api/send", message.RequestUri.ToString());
                Assert.NotNull(jsonContent);
                Assert.Equal(page, jsonContent.Payload.Url);
                Assert.Equal(title, jsonContent.Payload.Title);
                // Signal completion
                tcs.SetResult(true);

                return new HttpResponseMessage(HttpStatusCode.OK) { Content = content };
            }
            catch (Exception e)
            {
                
                tcs.SetException(e);
                return new HttpResponseMessage(HttpStatusCode.InternalServerError);
            }
        });

        var (backgroundSender, hostedService) = GetServices(handler);
        var cancellationToken = new CancellationToken();
        await hostedService.StartAsync(cancellationToken);
        await backgroundSender.TrackPageView(page, title);
        var completedTask = await Task.WhenAny(tcs.Task, Task.Delay(1000, cancellationToken));
        if (completedTask != tcs.Task)
        {
            throw new TimeoutException("The background task did not complete in time.");
        }
        
        await tcs.Task;
        await backgroundSender.StopAsync(CancellationToken.None);
    }
```

Kun tämä on määritelty, meidän on hoidettava `IHostedService` testausmenetelmän käyttöikä:

```csharp
       var (backgroundSender, hostedService) = GetServices(handler);
        var cancellationToken = new CancellationToken();
        await hostedService.StartAsync(cancellationToken);
        await backgroundSender.TrackPageView(page, title);
        var completedTask = await Task.WhenAny(tcs.Task, Task.Delay(1000, cancellationToken));
        if (completedTask != tcs.Task)
        {
            throw new TimeoutException("The background task did not complete in time.");
        }
        
        await tcs.Task;
        await backgroundSender.StopAsync(CancellationToken.None);
    }
```

Voitte nähdä, että välitämme hallinnoijalle `GetServices` järjestelymenetelmä:

```csharp
    private (UmamiBackgroundSender, IHostedService) GetServices(HttpMessageHandler handler)
    {
        var services = SetupExtensions.SetupServiceCollection(handler: handler);
        services.AddScoped<UmamiBackgroundSender>();
       

        services.AddScoped<IHostedService, UmamiBackgroundSender>(provider =>
            provider.GetRequiredService<UmamiBackgroundSender>());
        SetupExtensions.SetupUmamiClient(services);
        var serviceProvider = services.BuildServiceProvider();
        var backgroundSender = serviceProvider.GetRequiredService<UmamiBackgroundSender>();
        var hostedService = serviceProvider.GetRequiredService<IHostedService>();
        return (backgroundSender, hostedService);
    }
```

Siihen siirrämme hallinnoijan yksikköömme kiinnittääksemme sen `UmamiClient` setup.

Sitten lisäämme `UmamiBackgroundSender` palvelun keräämiseen ja saamaan `IHostedService` palveluntarjoajasta. Sitten palaa tämä testiluokkaan, jotta se voi käyttää sitä

#### Järjestetty palvelun kesto

Nyt kun meillä on kaikki nämä järjestelyt, voimme vain `StartAsync` Hosted Service, käyttää sitä ja odottaa siihen asti, kunnes se pysähtyy

```csharp
        await hostedService.StartAsync(cancellationToken);
        await backgroundSender.TrackPageView(page, title);
        var completedTask = await Task.WhenAny(tcs.Task, Task.Delay(1000, cancellationToken));
        if (completedTask != tcs.Task)
        {
            throw new TimeoutException("The background task did not complete in time.");
        }
        
        await tcs.Task;
        await backgroundSender.StopAsync(CancellationToken.None);
```

Tämä käynnistää vastaanotettavan palvelun, lähettää pyynnön, odottaa vastausta ja lopettaa palvelun

### Viestinkäsitys

Aloitamme ensin perustamalla `EchoMockHandler` ja `TaskCompletionSource` , joka merkitsee, että testi on täydellinen. On tärkeää palauttaa tausta keskeiseen testaussuuntaan, jotta voimme ottaa virheet ja keskeytykset asianmukaisesti huomioon

Euroopan unionin ` async (message, token) => {}` on se tehtävä, jonka välitämme edellä mainitsemaamme mallikäsittelyyn. Siihen voimme tarkistaa pyynnön ja palauttaa vastauksen (joka tässä tapauksessa emme todellakaan tee mitäänM SK2ei tehdä mitään ).

Meidän `EchoMockHandler.ResponseHandler` on avustajamenetelmä, joka palauttaa pyynnön elimen takaisin menetelmäänmme, tämä antaa meille varmistaa, että viesti kulkee läpi `UmamiClient` neuvoston `HttpClient` oikein.

```csharp
    public static async Task<HttpResponseMessage> ResponseHandler(HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        // Read the request content
        var requestBody = request.Content?.ReadAsStringAsync(cancellationToken).Result;
        // Create a response that echoes the request body
        var responseContent = requestBody ?? "No request body";
        // Return the response
        return await Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
        {
            Content = new StringContent(responseContent, Encoding.UTF8, "application/json")
        });
    }
```

Otamme tämän vastauksen ja deserialisoimme sen `EchoedRequest` object. Tämä on yksinkertainen objekti, joka edustaa pyyntöä, jonka lähetimme serverille.

```csharp
public class EchoedRequest
{
    public string Type { get; set; }
    public UmamiPayload Payload { get; set; }
}
```

Näette, että tämä sisältyy `Type` ja `Payload` vaatimuksesta. Tätä tarkastelemme testauksessamme

```csharp
      Assert.Contains("api/send", message.RequestUri.ToString());
      Assert.NotNull(jsonContent);
      Assert.Equal(page, jsonContent.Payload.Url);
      Assert.Equal(title, jsonContent.Payload.Title);
```

Tärkeintä on se, miten käsittelemme epäonnistuneita testejä. `TaskCompletionSource` palauttaa main threadille viestin, että testi on epäonnistunut.

```csharp
     catch (Exception e)
            {
                
                tcs.SetException(e);
                return new HttpResponseMessage(HttpStatusCode.InternalServerError);
            }
```

Tämä asettaa poikkeuksen `TaskCompletionSource` ja palauttaa 500 virheen testiin

# Päätelmissä

Näin ollen ' on ensimmäinen melko yksityiskohtaisemmista postistani `IHostedService` varmistaa tämän, koska se' on melko monimutkaista testata, kun se ei vastaa tältä osin arvoa callerille.