This is a viewer only at the moment see the article on how this works.
To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk
This is a preview from the server running through my markdig pipeline
Yksikön testaus Umami.Net M SK1UamiBackgroundSender
Tuesday, 03 September 2024
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.