// Add optional parameters if they are not null
    if (!string.IsNullOrEmpty(pageViewsRequest.Timezone)) queryParams.Add($"timezone={pageViewsRequest.Timezone}");
    if (!string.IsNullOrEmpty(pageViewsRequest.Url)) queryParams.Add($"url={pageViewsRequest.Url}");
    if (!string.IsNullOrEmpty(pageViewsRequest.Referrer)) queryParams.Add($"referrer={pageViewsRequest.Referrer}");
    if (!string.IsNullOrEmpty(pageViewsRequest.Title)) queryParams.Add($"title={pageViewsRequest.Title}");
    if (!string.IsNullOrEmpty(pageViewsRequest.Host)) queryParams.Add($"host={pageViewsRequest.Host}");
    if (!string.IsNullOrEmpty(pageViewsRequest.Os)) queryParams.Add($"os={pageViewsRequest.Os}");
    if (!string.IsNullOrEmpty(pageViewsRequest.Browser)) queryParams.Add($"browser={pageViewsRequest.Browser}");
    if (!string.IsNullOrEmpty(pageViewsRequest.Device)) queryParams.Add($"device={pageViewsRequest.Device}");
    if (!string.IsNullOrEmpty(pageViewsRequest.Country)) queryParams.Add($"country={pageViewsRequest.Country}");
    if (!string.IsNullOrEmpty(pageViewsRequest.Region)) queryParams.Add($"region={pageViewsRequest.Region}");
    if (!string.IsNullOrEmpty(pageViewsRequest.City)) queryParams.Add($"city={pageViewsRequest.City}");

    // Combine the query parameters into a query string
    var queryString = string.Join("&", queryParams);

    // Make the HTTP request
    var response = await authService.HttpClient.GetAsync($"/api/websites/{WebsiteId}/pageviews?{queryString}");

    if (response.IsSuccessStatusCode)
    {
        logger.LogInformation("Successfully got page views");
        var content = await response.Content.ReadFromJsonAsync<PageViewsResponseModel>();
        return new UmamiResult<PageViewsResponseModel>(response.StatusCode, response.ReasonPhrase ?? "Success",
            content ?? new PageViewsResponseModel());
    }

    if (response.StatusCode == HttpStatusCode.Unauthorized)
    {
        await authService.LoginAsync();
        return await GetPageViews(pageViewsRequest);
    }

    logger.LogError("Failed to get page views");
    return new UmamiResult<PageViewsResponseModel>(response.StatusCode,
        response.ReasonPhrase ?? "Failed to get page views", null);
}

</details>
Όπως μπορείτε να δείτε αυτό πραγματικά απλά κατασκευάζει μια συμβολοσειρά ερώτημα. επικυρώνει την πρόσκληση (βλ. [τελευταίο άρθρο](/blog/unittestinglogginginaspnetcore) για κάποιες λεπτομέρειες σχετικά με αυτό) και στη συνέχεια κάνει την κλήση στο Umami API. Λοιπόν, πώς θα το δοκιμάσουμε αυτό;

## Δοκιμή του UmamiDataService

Σε αντίθεση με τη δοκιμή UmamiClient, αποφάσισα να δοκιμάσω το `UmamiDataService` χωρίς χρήση Moq. Αντ' αυτού, δημιούργησα ένα απλό `DelegatingHandler` Τάξη που μου επιτρέπει να ανακρίνω το αίτημα και μετά να απαντήσω. Αυτή είναι μια πολύ απλούστερη προσέγγιση από τη χρήση Moq και μου επιτρέπει να δοκιμάσετε το `UmamiDataService` χωρίς να χρειάζεται να κοροϊδεύουν το `HttpClient`.

Στον παρακάτω κώδικα μπορείτε να δείτε ότι απλά επεκτείνω `DelegatingHandler` και να παρακάμψει το `SendAsync` μέθοδος. Αυτή η μέθοδος μου επιτρέπει να επιθεωρήσω το αίτημα και να επιστρέψω μια απάντηση με βάση το αίτημα.

```csharp
public class UmamiDataDelegatingHandler : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
        CancellationToken cancellationToken)
    {
        var absPath = request.RequestUri.AbsolutePath;
        switch (absPath)
        {
            case "/api/auth/login":
                var authContent = await request.Content.ReadFromJsonAsync<AuthRequest>(cancellationToken);
                if (authContent?.username == "username" && authContent?.password == "password")
                    return ReturnAuthenticatedMessage();
                else if (authContent?.username == "bad")
                {
                    return new HttpResponseMessage(HttpStatusCode.Unauthorized);
                }
                else
                {
                    return new HttpResponseMessage(HttpStatusCode.BadRequest);
                }
            default:

                if (absPath.StartsWith($"/api/websites/{Consts.WebSiteId}/pageviews"))
                {
                    var pageViews = GetParams<PageViewsRequest> (request);
                  
                    return ReturnPageViewsMessage(pageViews);
                }

                if (absPath.StartsWith($"/api/websites/{Consts.WebSiteId}/metrics"))
                {
                    var metricsRequest = GetParams<MetricsRequest>(request);
                    return ReturnMetrics(metricsRequest);
                }

                return new HttpResponseMessage(HttpStatusCode.NotFound);
        }
    }
 }

Ρύθμιση

Για τη δημιουργία του νέου UmamiDataService Η χρήση αυτού του χειριστή είναι εξίσου απλή.

    public IServiceProvider GetServiceProvider (string username="username", string password="password")
    {
        var services = new ServiceCollection();
        var mockLogger = new FakeLogger<UmamiDataService>();
        var authLogger = new FakeLogger<AuthService>();
        services.AddScoped<ILogger<UmamiDataService>>(_ => mockLogger);
        services.AddScoped<ILogger<AuthService>>(_ => authLogger);
        services.SetupUmamiData(username, password);
        return  services.BuildServiceProvider();
        
    }

Θα δεις ότι μόλις έφτιαξα το... ServiceCollection, προσθέστε το FakeLogger<T> (Πάλι δείτε το τελευταίο άρθρο για λεπτομέρειες σχετικά με αυτό και στη συνέχεια να ρυθμίσετε το UmamiData service with the username and password I want to use ( so I can test failure).

Στη συνέχεια, καλώ σε services.SetupUmamiData(username, password); που είναι μια μέθοδος επέκτασης που δημιούργησα για τη δημιουργία του UmamiDataService με το UmamiDataDelegatingHandler και το AuthService;

    public static void SetupUmamiData(this IServiceCollection services, string username="username", string password="password")
    {
        var umamiSettings = new UmamiDataSettings()
        {
            UmamiPath = Consts.UmamiPath,
            Username = username,
            Password = password,
            WebsiteId = Consts.WebSiteId
        };
        services.AddSingleton(umamiSettings);
        services.AddHttpClient<AuthService>((provider,client) =>
        {
            client.BaseAddress = new Uri(umamiSettings.UmamiPath);
            

        }).AddHttpMessageHandler<UmamiDataDelegatingHandler>()
            .SetHandlerLifetime(TimeSpan.FromMinutes(5));  //Set lifetime to five minutes

        services.AddScoped<UmamiDataDelegatingHandler>();
        services.AddScoped<UmamiDataService>();
    }

Μπορείς να δεις ότι εδώ είναι που κολλάω... UmamiDataDelegatingHandler και το AuthService έως την UmamiDataService. Ο τρόπος με τον οποίο δομείται αυτό είναι ότι AuthService 'Ιδιοκτήτες' HttpClient και το UmamiDataService χρησιμοποιεί το AuthService για να κάνει τις κλήσεις προς το Umami API με το bearer Μάρκα και BaseAddress Είσαι έτοιμος.

Οι δοκιμές

Πραγματικά αυτό κάνει πραγματικά δοκιμή αυτό είναι πραγματικά απλό. Είναι απλά λίγο ρήμα καθώς ήθελα να δοκιμάσω και την καταγραφή. Το μόνο που κάνει είναι να αναρτάει μέσα από το δικό μου DelegatingHandler και προσομοιώνω μια απάντηση με βάση το αίτημα.

public class UmamiData_PageViewsRequest_Test : UmamiDataBase
{
    private readonly DateTime StartDate = DateTime.ParseExact("2021-10-01", "yyyy-MM-dd", null);
    private readonly DateTime EndDate = DateTime.ParseExact("2021-10-07", "yyyy-MM-dd", null);
    
    [Fact]
    public async Task SetupTest_Good()
    {
        var serviceProvider = GetServiceProvider();
        var umamiDataService = serviceProvider.GetRequiredService<UmamiDataService>();
        var authLogger = serviceProvider.GetRequiredService<ILogger<AuthService>>();
        var umamiDataLogger = serviceProvider.GetRequiredService<ILogger<UmamiDataService>>();
        var result = await umamiDataService.GetPageViews(StartDate, EndDate);
        var fakeAuthLogger = (FakeLogger<AuthService>)authLogger;
        FakeLogCollector collector = fakeAuthLogger.Collector; 
        IReadOnlyList<FakeLogRecord> logs = collector.GetSnapshot();
        Assert.Contains("Login successful", logs.Select(x => x.Message));
        
        var fakeUmamiDataLogger = (FakeLogger<UmamiDataService>)umamiDataLogger;
        FakeLogCollector umamiDataCollector = fakeUmamiDataLogger.Collector;
        IReadOnlyList<FakeLogRecord> umamiDataLogs = umamiDataCollector.GetSnapshot();
        Assert.Contains("Successfully got page views", umamiDataLogs.Select(x => x.Message));
        
        Assert.NotNull(result);
    }
}

Προσομοίωση της Ανταπόκρισης

Για να προσομοιώσω την ανταπόκριση για αυτή τη μέθοδο θα θυμάστε ότι έχω αυτή τη γραμμή στο UmamiDataDelegatingHandler:

  if (absPath.StartsWith($"/api/websites/{Consts.WebSiteId}/pageviews"))
                {
                    var pageViews = GetParams<PageViewsRequest> (request);
                  
                    return ReturnPageViewsMessage(pageViews);
                }

Το μόνο που κάνει αυτό είναι να τραβήξει πληροφορίες από το ερώτημα και κατασκευάζει μια "ρεαλιστική" απάντηση (βάσει των Ζωντανών Δοκιμών που έχω συντάξει, και πάλι πολύ λίγα έγγραφα σχετικά με αυτό). Θα δείτε ότι ελέγχω για τον αριθμό των ημερών μεταξύ της έναρξης και της ημερομηνίας λήξης και στη συνέχεια θα επιστρέψω μια απάντηση με τον ίδιο αριθμό ημερών.

    private static HttpResponseMessage ReturnPageViewsMessage(PageViewsRequest request)
    {
        var startAt = request.StartAt;
        var endAt = request.EndAt;
        var startDate = DateTimeOffset.FromUnixTimeMilliseconds(startAt).DateTime;
        var endDate = DateTimeOffset.FromUnixTimeMilliseconds(endAt).DateTime;
        var days = (endDate - startDate).Days;

        var pageViewsList = new List<PageViewsResponseModel.Pageviews>();
        var sessionsList = new List<PageViewsResponseModel.Sessions>();
        for(int i=0; i<days; i++)
        {
            
            pageViewsList.Add(new PageViewsResponseModel.Pageviews()
            {
                x = startDate.AddDays(i).ToString("yyyy-MM-dd"),
                y = i*4
            });
            sessionsList.Add(new PageViewsResponseModel.Sessions()
            {
                x = startDate.AddDays(i).ToString("yyyy-MM-dd"),
                y = i*8
            });
        }
        var pageViewResponse = new PageViewsResponseModel()
        {
            pageviews = pageViewsList.ToArray(),
            sessions = sessionsList.ToArray()
        };
        var json = JsonSerializer.Serialize(pageViewResponse);
        return new HttpResponseMessage(HttpStatusCode.OK)
        {
            Content = new StringContent(json, Encoding.UTF8, "application/json")
        };
    }

Συμπέρασμα

Έτσι, αυτό είναι πραγματικά είναι αρκετά απλό να δοκιμάσετε ένα HttpClient Αίτημα χωρίς χρήση του Μοκ και νομίζω ότι είναι πολύ πιο καθαρό έτσι. Χάνεις κάποιες από τις εκλεπτύσεις που έγιναν δυνατές στο Μακ, αλλά για απλές εξετάσεις όπως αυτό, νομίζω ότι είναι μια καλή ανταλλαγή.