HttpRequestMessageAsserter.cs

namespace TestableHttpClient;

/// <summary>
/// This class makes it easy to create assertions on a collection of <seealso cref="HttpRequestMessage"/>s.
/// </summary>
internal sealed class HttpRequestMessageAsserter : IHttpRequestMessagesCheck
{
    private readonly List<string> _expectedConditions = new();

    private readonly RequestBuilder expectedRequestBuilder;

    /// <summary>
    /// Construct a new HttpRequestMessageAsserter.
    /// </summary>
    /// <param name="httpRequestMessages">The list of requests to assert on.</param>
    /// <param name="options">Options that could be used by several assertions.</param>
    public HttpRequestMessageAsserter(IEnumerable<HttpRequestMessage> httpRequestMessages, TestableHttpMessageHandlerOptions? options = null)
        : this(httpRequestMessages, _ => { }, options)
    {
    }

    public HttpRequestMessageAsserter(IEnumerable<HttpRequestMessage> httpRequestMessages, Action<RequestBuilder> requestBuilderAction, TestableHttpMessageHandlerOptions? options = null)
    {
        Requests = httpRequestMessages ?? throw new ArgumentNullException(nameof(httpRequestMessages));
        Options = options ?? new TestableHttpMessageHandlerOptions();
        expectedRequestBuilder = new RequestBuilder(Options);
        requestBuilderAction?.Invoke(expectedRequestBuilder);
    }

    /// <summary>
    /// The list of requests received from <seealso cref="TestableHttpMessageHandler"/>.
    /// </summary>
    public IEnumerable<HttpRequestMessage> Requests { get; private set; }

    /// <summary>
    /// Options that could be used by several assertions.
    /// </summary>
    public TestableHttpMessageHandlerOptions Options { get; }

    internal HttpRequestMessageAsserter Assert(int? expectedCount = null)
    {
        int actualCount;
        Request expectedRequest = expectedRequestBuilder.Build();
        try
        {
            actualCount = Requests.Count(expectedRequest.Equals);
        }
        catch (ObjectDisposedException)
        {
            throw new HttpRequestMessageAssertionException("Can't validate requests, because one or more requests have content that is already disposed.");
        }

        var pass = expectedCount switch
        {
            null => actualCount > 0,
            _ => actualCount == expectedCount,
        };

        if (!pass)
        {
            var message = MessageBuilder.BuildMessage(expectedCount, actualCount, expectedRequest, _expectedConditions);
            throw new HttpRequestMessageAssertionException(message);
        }

        return this;
    }

    /// <summary>
    /// Asserts whether requests comply with a specific filter.
    /// </summary>
    /// <param name="requestFilter">The filter to filter requests with before asserting.</param>
    /// <param name="condition">The name of the condition, used in the exception message.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    [AssertionMethod]
    [Obsolete("WithFilter will be removed, since it should no longer be necesary to use.")]
    public IHttpRequestMessagesCheck WithFilter(Func<HttpRequestMessage, bool> requestFilter, string condition) => WithFilter(requestFilter, null, condition);

    /// <summary>
    /// Asserts whether requests comply with a specific filter.
    /// </summary>
    /// <param name="requestFilter">The filter to filter requests with before asserting.</param>
    /// <param name="expectedNumberOfRequests">The number of requests with this filter.</param>
    /// <param name="condition">The name of the condition, used in the exception message.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    [AssertionMethod]
    [Obsolete("WithFilter will be removed, since it should no longer be necesary to use.")]
    public IHttpRequestMessagesCheck WithFilter(Func<HttpRequestMessage, bool> requestFilter, int expectedNumberOfRequests, string condition) => WithFilter(requestFilter, (int?)expectedNumberOfRequests, condition);

    [AssertionMethod]
    [Obsolete("WithFilter will be removed, since it should no longer be necesary to use.")]
    public IHttpRequestMessagesCheck WithFilter(Func<HttpRequestMessage, bool> requestFilter, int? expectedNumberOfRequests, string condition)
    {
        if (!string.IsNullOrEmpty(condition))
        {
            _expectedConditions.Add(condition);
        }

        Requests = Requests.Where(requestFilter);
        Assert(expectedNumberOfRequests);

        return this;
    }

    /// <summary>
    /// Asserts whether requests were made to a given URI based on a pattern.
    /// </summary>
    /// <param name="pattern">The uri pattern that is expected.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithRequestUri(string pattern) => WithRequestUri(pattern, null);

    /// <summary>
    /// Asserts whether requests were made to a given URI based on a pattern.
    /// </summary>
    /// <param name="pattern">The uri pattern that is expected.</param>
    /// <param name="expectedNumberOfRequests">The expected number of requests.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithRequestUri(string pattern, int expectedNumberOfRequests) => WithRequestUri(pattern, (int?)expectedNumberOfRequests);

    private HttpRequestMessageAsserter WithRequestUri(string pattern, int? expectedNumberOfRequests)
    {
        Guard.ThrowIfNullOrEmpty(pattern);

        expectedRequestBuilder.WithRequestUri(pattern);

        return Assert(expectedNumberOfRequests);
    }

    /// <summary>
    /// Asserts whether requests were made with a given HTTP Method.
    /// </summary>
    /// <param name="httpMethod">The <seealso cref="HttpMethod"/> that is expected.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithHttpMethod(HttpMethod httpMethod) => WithHttpMethod(httpMethod, null);

    /// <summary>
    /// Asserts whether requests were made with a given HTTP Method.
    /// </summary>
    /// <param name="httpMethod">The <seealso cref="HttpMethod"/> that is expected.</param>
    /// <param name="expectedNumberOfRequests">The expected number of requests.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithHttpMethod(HttpMethod httpMethod, int expectedNumberOfRequests) => WithHttpMethod(httpMethod, (int?)expectedNumberOfRequests);

    private HttpRequestMessageAsserter WithHttpMethod(HttpMethod httpMethod, int? expectedNumberOfRequests)
    {
        Guard.ThrowIfNull(httpMethod);

        expectedRequestBuilder.WithMethod(httpMethod);

        return Assert(expectedNumberOfRequests);
    }

    /// <summary>
    /// Asserts whether requests were made using a specific HTTP Version.
    /// </summary>
    /// <param name="check">The implementation that hold all the request messages.</param>
    /// <param name="httpVersion">The <seealso cref="System.Net.HttpVersion"/> that is expected.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithHttpVersion(Version httpVersion) => WithHttpVersion(httpVersion, null);

    /// <summary>
    /// Asserts whether requests were made using a specific HTTP Version.
    /// </summary>
    /// <param name="httpVersion">The <seealso cref="System.Net.HttpVersion"/> that is expected.</param>
    /// <param name="expectedNumberOfRequests">The expected number of requests.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithHttpVersion(Version httpVersion, int expectedNumberOfRequests) => WithHttpVersion(httpVersion, (int?)expectedNumberOfRequests);

    private HttpRequestMessageAsserter WithHttpVersion(Version httpVersion, int? expectedNumberOfRequests)
    {
        Guard.ThrowIfNull(httpVersion);

        expectedRequestBuilder.WithVersion(httpVersion);

        return Assert(expectedNumberOfRequests);
    }

    /// <summary>
    /// Asserts whether requests were made with a specific header name. Values are ignored.
    /// </summary>
    /// <param name="headerName">The name of the header that is expected.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithHeader(string headerName) => WithHeader(headerName, (int?)null);

    /// <summary>
    /// Asserts whether requests were made with a specific header name. Values are ignored.
    /// </summary>
    /// <param name="headerName">The name of the header that is expected.</param>
    /// <param name="expectedNumberOfRequests">The expected number of requests.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithHeader(string headerName, int expectedNumberOfRequests) => WithHeader(headerName, (int?)expectedNumberOfRequests);

    private HttpRequestMessageAsserter WithHeader(string headerName, int? expectedNumberOfRequests)
    {
        Guard.ThrowIfNullOrEmpty(headerName);

        expectedRequestBuilder.WithHeader(headerName);

        return Assert(expectedNumberOfRequests);
    }

    /// <summary>
    /// Asserts whether requests were made with a specific header name and value.
    /// </summary>
    /// <param name="headerName">The name of the header that is expected.</param>
    /// <param name="headerValue">The value of the expected header, supports wildcards.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithHeader(string headerName, string headerValue) => WithHeader(headerName, headerValue, null);

    /// <summary>
    /// Asserts whether requests were made with a specific header name and value.
    /// </summary>
    /// <param name="headerName">The name of the header that is expected.</param>
    /// <param name="headerValue">The value of the expected header, supports wildcards.</param>
    /// <param name="expectedNumberOfRequests">The expected number of requests.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithHeader(string headerName, string headerValue, int expectedNumberOfRequests) => WithHeader(headerName, headerValue, (int?)expectedNumberOfRequests);

    private HttpRequestMessageAsserter WithHeader(string headerName, string headerValue, int? expectedNumberOfRequests)
    {
        Guard.ThrowIfNullOrEmpty(headerName);
        Guard.ThrowIfNullOrEmpty(headerValue);

        expectedRequestBuilder.WithHeader(headerName, headerValue);

        return Assert(expectedNumberOfRequests);
    }

    /// <summary>
    /// Asserts whether requests were made with specific content.
    /// </summary>
    /// <param name="pattern">The expected content, supports wildcards.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithContent(string pattern) => WithContent(pattern, null);

    /// <summary>
    /// Asserts whether requests were made with specific content.
    /// </summary>
    /// <param name="pattern">The expected content, supports wildcards.</param>
    /// <param name="expectedNumberOfRequests">The expected number of requests.</param>
    /// <returns>The <seealso cref="IHttpRequestMessagesCheck"/> for further assertions.</returns>
    public IHttpRequestMessagesCheck WithContent(string pattern, int expectedNumberOfRequests) => WithContent(pattern, (int?)expectedNumberOfRequests);

    private HttpRequestMessageAsserter WithContent(string pattern, int? expectedNumberOfRequests)
    {
        Guard.ThrowIfNull(pattern);

        expectedRequestBuilder.WithContent(pattern);

        return Assert(expectedNumberOfRequests);
    }
}