11937278774

Committed 20 Nov 2024 04:10PM UTC coverage: 59.17% (-0.1%) from 59.302%

Build # 11937278774

Build Type

push

github

Committed by

pwelter34

Commit Message

make HybridCache optional

Run Details

389 of 745 branches covered (52.21%)

Branch coverage included in aggregate %.

0 of 6 new or added lines in 2 files covered. (0.0%)

1 existing line in 1 file now uncovered.

1208 of 1954 relevant lines covered (61.82%)

19.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/MediatR.CommandQuery/Dispatcher/RemoteDispatcher.cs

using System.Net.Http.Json;
using System.Text.Json;

using MediatR.CommandQuery.Definitions;
using MediatR.CommandQuery.Extensions;
using MediatR.CommandQuery.Models;

using Microsoft.Extensions.Caching.Hybrid;
using Microsoft.Extensions.Options;

namespace MediatR.CommandQuery.Dispatcher;

public class RemoteDispatcher : IDispatcher
{
    private readonly HttpClient _httpClient;
    private readonly JsonSerializerOptions _serializerOptions;
    private readonly DispatcherOptions _dispatcherOptions;
    private readonly HybridCache? _hybridCache;

    public RemoteDispatcher(HttpClient httpClient, JsonSerializerOptions serializerOptions, IOptions<DispatcherOptions> dispatcherOptions, HybridCache? hybridCache = null)
    {
        ArgumentNullException.ThrowIfNull(httpClient);
        ArgumentNullException.ThrowIfNull(serializerOptions);
        ArgumentNullException.ThrowIfNull(dispatcherOptions);

        _httpClient = httpClient;
        _serializerOptions = serializerOptions;
        _dispatcherOptions = dispatcherOptions.Value;
        _hybridCache = hybridCache;
    }

    public async Task<TResponse?> Send<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(request);

        // cache only if implements interface
        var cacheRequest = request as ICacheResult;
        if (_hybridCache is null || cacheRequest?.IsCacheable() != true)
            return await SendCore(request, cancellationToken).ConfigureAwait(false);

        var cacheKey = cacheRequest.GetCacheKey();
        var cacheTag = cacheRequest.GetCacheTag();
        var cacheOptions = new HybridCacheEntryOptions
        {
            Expiration = cacheRequest.SlidingExpiration(),
        };

        return await _hybridCache
            .GetOrCreateAsync(
                key: cacheKey,
                factory: async token => await SendCore(request, token).ConfigureAwait(false),
                options: cacheOptions,
                tags: string.IsNullOrEmpty(cacheTag) ? null : [cacheTag],
                cancellationToken: cancellationToken)
            .ConfigureAwait(false);
    }

    private async Task<TResponse?> SendCore<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken)
    {
        var requestUri = _dispatcherOptions.FeaturePrefix
            .Combine(_dispatcherOptions.DispatcherPrefix)
            .Combine(_dispatcherOptions.SendRoute);

        var dispatchRequest = new DispatchRequest { Request = request };

        var responseMessage = await _httpClient
            .PostAsJsonAsync(
                requestUri: requestUri,
                value: dispatchRequest,
                options: _serializerOptions,
                cancellationToken: cancellationToken)
            .ConfigureAwait(false);

        await EnsureSuccessStatusCode(responseMessage, cancellationToken).ConfigureAwait(false);

        using var stream = await responseMessage.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);

        // no content, return null
        if (stream.Length == 0)
            return default;

        var response = await JsonSerializer.DeserializeAsync<TResponse>(stream, _serializerOptions, cancellationToken).ConfigureAwait(false);

        // expire cache
        if (_hybridCache is null || request is not ICacheExpire cacheRequest)
            return response;

        var cacheTag = cacheRequest.GetCacheTag();
        if (!string.IsNullOrEmpty(cacheTag))
            await _hybridCache.RemoveByTagAsync(cacheTag, cancellationToken).ConfigureAwait(false);

        return response;
    }

    private async Task EnsureSuccessStatusCode(HttpResponseMessage responseMessage, CancellationToken cancellationToken = default)
    {
        if (responseMessage.IsSuccessStatusCode)
            return;

        var message = $"Response status code does not indicate success: {responseMessage.StatusCode} ({responseMessage.ReasonPhrase}).";

        var mediaType = responseMessage.Content.Headers.ContentType?.MediaType;
        if (!string.Equals(mediaType, "application/problem+json", StringComparison.OrdinalIgnoreCase))
            throw new HttpRequestException(message, inner: null, responseMessage.StatusCode);

        var problemDetails = await responseMessage.Content
            .ReadFromJsonAsync<ProblemDetails>(
                options: _serializerOptions,
                cancellationToken: cancellationToken)
            .ConfigureAwait(false);

        if (problemDetails == null)
            throw new HttpRequestException(message, inner: null, responseMessage.StatusCode);

        var status = (System.Net.HttpStatusCode?)problemDetails.Status;
        status ??= responseMessage.StatusCode;

        var problemMessage = problemDetails.Title
            ?? responseMessage.ReasonPhrase
            ?? "Internal Server Error";

        if (!string.IsNullOrEmpty(problemDetails.Detail))
            problemMessage = $"{problemMessage} {problemDetails.Detail}";

        throw new HttpRequestException(
            message: problemMessage,
            inner: null,
            statusCode: status);
    }

}

1	using System.Net.Http.Json;
2	using System.Text.Json;
3
4	using MediatR.CommandQuery.Definitions;
5	using MediatR.CommandQuery.Extensions;
6	using MediatR.CommandQuery.Models;
7
8	using Microsoft.Extensions.Caching.Hybrid;
9	using Microsoft.Extensions.Options;
10
11	namespace MediatR.CommandQuery.Dispatcher;
12
13	public class RemoteDispatcher : IDispatcher
14	{
15	private readonly HttpClient _httpClient;
16	private readonly JsonSerializerOptions _serializerOptions;
17	private readonly DispatcherOptions _dispatcherOptions;
18	private readonly HybridCache? _hybridCache;
19
NEW 20	public RemoteDispatcher(HttpClient httpClient, JsonSerializerOptions serializerOptions, IOptions<DispatcherOptions> dispatcherOptions, HybridCache? hybridCache = null)	×
21	{
22	ArgumentNullException.ThrowIfNull(httpClient);	×
23	ArgumentNullException.ThrowIfNull(serializerOptions);	×
24	ArgumentNullException.ThrowIfNull(dispatcherOptions);	×
25
UNCOV 26	_httpClient = httpClient;	×
27	_serializerOptions = serializerOptions;	×
28	_dispatcherOptions = dispatcherOptions.Value;	×
29	_hybridCache = hybridCache;	×
30	}	×
31
32	public async Task<TResponse?> Send<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken = default)
33	{
34	ArgumentNullException.ThrowIfNull(request);	×
35
36	// cache only if implements interface
37	var cacheRequest = request as ICacheResult;	×
NEW 38	if (_hybridCache is null \|\| cacheRequest?.IsCacheable() != true)	×
39	return await SendCore(request, cancellationToken).ConfigureAwait(false);	×
40
41	var cacheKey = cacheRequest.GetCacheKey();	×
42	var cacheTag = cacheRequest.GetCacheTag();	×
43	var cacheOptions = new HybridCacheEntryOptions	×
44	{	×
45	Expiration = cacheRequest.SlidingExpiration(),	×
46	};	×
47
48	return await _hybridCache	×
49	.GetOrCreateAsync(	×
50	key: cacheKey,	×
51	factory: async token => await SendCore(request, token).ConfigureAwait(false),	×
52	options: cacheOptions,	×
53	tags: string.IsNullOrEmpty(cacheTag) ? null : [cacheTag],	×
54	cancellationToken: cancellationToken)	×
55	.ConfigureAwait(false);	×
56	}	×
57
58	private async Task<TResponse?> SendCore<TResponse>(IRequest<TResponse> request, CancellationToken cancellationToken)
59	{
60	var requestUri = _dispatcherOptions.FeaturePrefix	×
61	.Combine(_dispatcherOptions.DispatcherPrefix)	×
62	.Combine(_dispatcherOptions.SendRoute);	×
63
64	var dispatchRequest = new DispatchRequest { Request = request };	×
65
66	var responseMessage = await _httpClient	×
67	.PostAsJsonAsync(	×
68	requestUri: requestUri,	×
69	value: dispatchRequest,	×
70	options: _serializerOptions,	×
71	cancellationToken: cancellationToken)	×
72	.ConfigureAwait(false);	×
73
74	await EnsureSuccessStatusCode(responseMessage, cancellationToken).ConfigureAwait(false);	×
75
76	using var stream = await responseMessage.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);	×
77
78	// no content, return null
79	if (stream.Length == 0)	×
80	return default;	×
81
82	var response = await JsonSerializer.DeserializeAsync<TResponse>(stream, _serializerOptions, cancellationToken).ConfigureAwait(false);	×
83
84	// expire cache
NEW 85	if (_hybridCache is null \|\| request is not ICacheExpire cacheRequest)	×
86	return response;	×
87
88	var cacheTag = cacheRequest.GetCacheTag();	×
89	if (!string.IsNullOrEmpty(cacheTag))	×
90	await _hybridCache.RemoveByTagAsync(cacheTag, cancellationToken).ConfigureAwait(false);	×
91
92	return response;	×
93	}	×
94
95	private async Task EnsureSuccessStatusCode(HttpResponseMessage responseMessage, CancellationToken cancellationToken = default)
96	{
97	if (responseMessage.IsSuccessStatusCode)	×
98	return;	×
99
100	var message = $"Response status code does not indicate success: {responseMessage.StatusCode} ({responseMessage.ReasonPhrase}).";	×
101
102	var mediaType = responseMessage.Content.Headers.ContentType?.MediaType;	×
103	if (!string.Equals(mediaType, "application/problem+json", StringComparison.OrdinalIgnoreCase))	×
104	throw new HttpRequestException(message, inner: null, responseMessage.StatusCode);	×
105
106	var problemDetails = await responseMessage.Content	×
107	.ReadFromJsonAsync<ProblemDetails>(	×
108	options: _serializerOptions,	×
109	cancellationToken: cancellationToken)	×
110	.ConfigureAwait(false);	×
111
112	if (problemDetails == null)	×
113	throw new HttpRequestException(message, inner: null, responseMessage.StatusCode);	×
114
115	var status = (System.Net.HttpStatusCode?)problemDetails.Status;	×
116	status ??= responseMessage.StatusCode;	×
117
118	var problemMessage = problemDetails.Title	×
119	?? responseMessage.ReasonPhrase	×
120	?? "Internal Server Error";	×
121
122	if (!string.IsNullOrEmpty(problemDetails.Detail))	×
123	problemMessage = $"{problemMessage} {problemDetails.Detail}";	×
124
125	throw new HttpRequestException(	×
126	message: problemMessage,	×
127	inner: null,	×
128	statusCode: status);	×
129	}	×
130
131	}

loresoft / MediatR.CommandQuery / 11937278774

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous