Yksikön testaus Umami.Net M SK1UamiBackgroundSender (Suomi (Finnish))

Yksikön testaus Umami.Net M SK1UamiBackgroundSender

Tuesday, 03 September 2024

//

7 minute read

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ä.

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ä:

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.

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

  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:

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

     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.

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ä

[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ä:

       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ä:

    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

        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.

    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.

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

      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.

     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.

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.