Adds basic request validation.

Added validations:
- ShouldHaveMadeRequests
- ShouldHaveMadeRequestsTo
- ShouldNotHaveMadeRequests
- ShouldNotHaveMadeRequestsTo

If any of these validations fail, an HttpRequestMessageAssertionException is thrown. The actual knowledge for how to assert what requests are made can be found in HttpRequestMessageAsserter.

Author: dnperfors

src/HttpClientTestHelpers/HttpRequestMessageAsserter.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+
+namespace HttpClientTestHelpers
+{
+    public class HttpRequestMessageAsserter
+    {
+        private readonly List<string> _expectedConditions = new List<string>();
+        private readonly bool _negate = false;
+
+        public HttpRequestMessageAsserter(IEnumerable<HttpRequestMessage> httpRequestMessages)
+        {
+            Requests = httpRequestMessages ?? throw new ArgumentNullException(nameof(httpRequestMessages));
+        }
+
+        public HttpRequestMessageAsserter(IEnumerable<HttpRequestMessage> httpRequestMessages, bool negate)
+        {
+            Requests = httpRequestMessages ?? throw new ArgumentNullException(nameof(httpRequestMessages));
+            _negate = negate;
+        }
+
+        public IEnumerable<HttpRequestMessage> Requests { get; private set; }
+
+        private void Assert(int? count = null)
+        {
+            var actualCount = Requests.Count();
+            var pass = count switch
+            {
+                null => Requests.Any(),
+                _ => actualCount == count,
+            };
+
+            if (_negate)
+            {
+                if (!count.HasValue)
+                {
+                    count = 0;
+                }
+                pass = !pass;
+            }
+
+            if (!pass)
+            {
+                var expected = count switch
+                {
+                    0 => "no requests to be made",
+                    _ => "at least one request to be made",
+                };
+                var actual = actualCount switch
+                {
+                    0 => "no requests were made",
+                    1 => "one request was made",
+                    _ => $"{actualCount} requests were made",
+                };
+
+                if (_expectedConditions.Any())
+                {
+                    var conditions = string.Join(", ", _expectedConditions);
+                    expected += $" with {conditions}";
+                }
+
+                var message = $"Expected {expected}, but {actual}.";
+                throw new HttpRequestMessageAssertionException(message);
+            }
+        }
+
+        public HttpRequestMessageAsserter WithUriPattern(string pattern)
+        {
+            if (pattern != "*")
+            {
+                _expectedConditions.Add($"uri pattern '{pattern}'");
+            }
+
+            Requests = Requests.Where(x => x.HasMatchingUri(pattern));
+            Assert();
+            return this;
+        }
+    }
+}

src/HttpClientTestHelpers/HttpRequestMessageAssertionException.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace HttpClientTestHelpers
+{
+    public class HttpRequestMessageAssertionException : Exception
+    {
+        private HttpRequestMessageAssertionException()
+        {
+        }
+
+        public HttpRequestMessageAssertionException(string message) : base(message)
+        {
+        }
+
+        public HttpRequestMessageAssertionException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+    }
+}

src/HttpClientTestHelpers/TestableHttpMessageHandler.cs

@@ -35,5 +35,51 @@ public void RespondWith(HttpResponseMessage httpResponseMessage)
         {
             response = httpResponseMessage ?? throw new ArgumentNullException(nameof(httpResponseMessage));
         }
+
+        /// <summary>
+        /// Validates that requests have been made, throws an exception when no requests were made.
+        /// </summary>
+        public void ShouldHaveMadeRequests()
+        {
+            _ = new HttpRequestMessageAsserter(Requests).WithUriPattern("*");
+        }
+
+        /// <summary>
+        /// Validates that requests to a specific uri have been made, throws an exception when no requests were made.
+        /// </summary>
+        /// <param name="pattern">The uri pattern to validate against, the pattern supports *.</param>
+        /// <returns>An <seealso cref="HttpRequestMessageAsserter"/> which can be used for further validations.</returns>
+        public HttpRequestMessageAsserter ShouldHaveMadeRequestsTo(string pattern)
+        {
+            if (pattern == null)
+            {
+                throw new ArgumentNullException(nameof(pattern));
+            }
+
+            return new HttpRequestMessageAsserter(Requests).WithUriPattern(pattern);
+        }
+
+        /// <summary>
+        /// Validates that no requests have been made, throws an exception when requests were made.
+        /// </summary>
+        public void ShouldNotHaveMadeRequests()
+        {
+            _ = new HttpRequestMessageAsserter(Requests, true).WithUriPattern("*");
+        }
+
+        /// <summary>
+        /// Validates that no requests to a specific uri have been made, throws an exception when requests were made.
+        /// </summary>
+        /// <param name="pattern">The uri pattern to validate against, the pattern supports *.</param>
+        /// <returns>An <seealso cref="HttpRequestMessageAsserter"/> which can be used for further validations.</returns>
+        public HttpRequestMessageAsserter ShouldNotHaveMadeRequestsTo(string pattern)
+        {
+            if (pattern == null)
+            {
+                throw new ArgumentNullException(nameof(pattern));
+            }
+
+            return new HttpRequestMessageAsserter(Requests, true).WithUriPattern(pattern);
+        }
     }
 }

test/HttpClientTestHelpers.Tests/HttpRequestMessageAsserterTests.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Linq;
+using System.Net.Http;
+
+using Xunit;
+
+namespace HttpClientTestHelpers.Tests
+{
+    public class HttpRequestMessageAsserterTests
+    {
+#nullable disable
+        [Fact]
+        public void Constructor_NullRequestList_ThrowsArgumentNullException()
+        {
+            Assert.Throws<ArgumentNullException>(() => new HttpRequestMessageAsserter(null));
+        }
+#nullable restore
+
+        [Fact]
+        public void WithUriPattern_RequestWithMatchingUri_DoesNotThrowException()
+        {
+            var sut = new HttpRequestMessageAsserter(new[] { new HttpRequestMessage(HttpMethod.Get, new Uri("https://example.com")) });
+
+            sut.WithUriPattern("https://example.com");
+        }
+
+        [Fact]
+        public void WithUriPattern_RequestWithMatchingUriAndNegationTurnedOn_ThrowsHttpRequestMessageAssertionExceptionWithSpecificMessage()
+        {
+            var sut = new HttpRequestMessageAsserter(new[] { new HttpRequestMessage(HttpMethod.Get, new Uri("https://example.com")) }, true);
+
+            var exception = Assert.Throws<HttpRequestMessageAssertionException>(() => sut.WithUriPattern("https://example.com"));
+            Assert.Equal("Expected no requests to be made with uri pattern 'https://example.com', but one request was made.", exception.Message);
+        }
+
+        [Fact]
+        public void WithUriPattern_RequestWithNotMatchingUri_ThrowsHttpRequestMessageassertionExceptionWithSpecificMessage()
+        {
+            var sut = new HttpRequestMessageAsserter(new[] { new HttpRequestMessage(HttpMethod.Get, new Uri("https://example.com")) });
+
+            var exception = Assert.Throws<HttpRequestMessageAssertionException>(() => sut.WithUriPattern("https://test.org"));
+            Assert.Equal("Expected at least one request to be made with uri pattern 'https://test.org', but no requests were made.", exception.Message);
+        }
+
+        [Fact]
+        public void WithUriPattern_RequestWithStarPatternAndNoRequests_ThrowsHttpRequestMessageassertionExceptionWithSpecificMessage()
+        {
+            var sut = new HttpRequestMessageAsserter(Enumerable.Empty<HttpRequestMessage>());
+
+            var exception = Assert.Throws<HttpRequestMessageAssertionException>(() => sut.WithUriPattern("*"));
+            Assert.Equal("Expected at least one request to be made, but no requests were made.", exception.Message);
+        }
+    }
+}

test/HttpClientTestHelpers.Tests/TestableHttpMessageHandlerTests.cs

@@ -64,7 +64,119 @@ public async Task SendAsync_WhenRespondWithIsSet_SetRespondIsUsed()
             Assert.Same(response, result);
         }
 
+        [Fact]
+        public void ShouldHaveMadeRequests_WhenNoRequestsWereMade_ThrowsHttpRequestMessageAssertionException()
+        {
+            using var sut = new TestableHttpMessageHandler();
+
+            Assert.Throws<HttpRequestMessageAssertionException>(() => sut.ShouldHaveMadeRequests());
+        }
+
+        [Fact]
+        public async Task ShouldHaveMadeRequests_WhenRequestsWereMade_DoesNotThrowExceptions()
+        {
+            using var sut = new TestableHttpMessageHandler();
+            using var client = new HttpClient(sut);
+
+            _ = await client.GetAsync(new Uri("https://example.com"));
+
+            sut.ShouldHaveMadeRequests();
+        }
+
+        [Fact]
+        public void ShouldHaveMadeRequestsTo_WhenNoRequestsWereMade_ThrowsHttpRequestMessageAssertionException()
+        {
+            using var sut = new TestableHttpMessageHandler();
+
+            Assert.Throws<HttpRequestMessageAssertionException>(() => sut.ShouldHaveMadeRequestsTo("https://example.com"));
+        }
+
+        [Fact]
+        public async Task ShouldHaveMadeRequestsTo_WhenMatchinRequestsWereMade_ReturnsHttpRequestMessageAsserter()
+        {
+            using var sut = new TestableHttpMessageHandler();
+            using var client = new HttpClient(sut);
+
+            _ = await client.GetAsync(new Uri("https://example.com"));
+
+            var result = sut.ShouldHaveMadeRequestsTo("https://example.com");
+
+            Assert.NotNull(result);
+            Assert.IsType<HttpRequestMessageAsserter>(result);
+        }
+
+        [Fact]
+        public void ShouldNotHaveMadeRequests_WhenNoRequestsWereMade_DoesNotThrowExceptions()
+        {
+            using var sut = new TestableHttpMessageHandler();
+
+            sut.ShouldNotHaveMadeRequests();
+        }
+
+        [Fact]
+        public async Task ShouldNotHaveMadeRequests_WhenASingleRequestWasMade_ThrowsHttpRequestMessageAssertionException()
+        {
+            using var sut = new TestableHttpMessageHandler();
+            using var client = new HttpClient(sut);
+
+            _ = await client.GetAsync(new Uri("https://example.com"));
+
+            var result = Assert.Throws<HttpRequestMessageAssertionException>(() => sut.ShouldNotHaveMadeRequests());
+            Assert.Equal("Expected no requests to be made, but one request was made.", result.Message);
+        }
+
+        [Fact]
+        public async Task ShouldNotHaveMadeRequests_WhenMultipleRequestsWereMade_ThrowsHttpRequestMessageAssertionException()
+        {
+            using var sut = new TestableHttpMessageHandler();
+            using var client = new HttpClient(sut);
+
+            _ = await client.GetAsync(new Uri("https://example.com"));
+            _ = await client.GetAsync(new Uri("https://example.com"));
+
+            var result = Assert.Throws<HttpRequestMessageAssertionException>(() => sut.ShouldNotHaveMadeRequests());
+            Assert.Equal("Expected no requests to be made, but 2 requests were made.", result.Message);
+        }
+
+        [Fact]
+        public void ShouldNotHaveMadeRequestsTo_WhenNoRequestsWereMade_ReturnsHttpRequestMessageAsserter()
+        {
+            using var sut = new TestableHttpMessageHandler();
+
+            var result = sut.ShouldNotHaveMadeRequestsTo("https://example.com");
+
+            Assert.NotNull(result);
+            Assert.IsType<HttpRequestMessageAsserter>(result);
+        }
+
+        [Fact]
+        public async Task ShouldNotHaveMadeRequestsTo_WhenMatchinRequestsWereMade_ThrowsHttpRequestMessageAssertionException()
+        {
+            using var sut = new TestableHttpMessageHandler();
+            using var client = new HttpClient(sut);
+
+            _ = await client.GetAsync(new Uri("https://example.com"));
+
+            Assert.Throws<HttpRequestMessageAssertionException>(() => sut.ShouldNotHaveMadeRequestsTo("https://example.com"));
+        }
+
 #nullable disable
+        [Fact]
+        public void ShouldHaveMadeRequestsTo_WhenGivenPatternIsNull_ThrowsArgumentNullException()
+        {
+            using var sut = new TestableHttpMessageHandler();
+
+            Assert.Throws<ArgumentNullException>(() => sut.ShouldHaveMadeRequestsTo(null));
+        }
+
+        [Fact]
+        public void ShouldNotHaveMadeRequestsTo_WhenGivenPatternIsNull_ThrowsArgumentNullException()
+        {
+            using var sut = new TestableHttpMessageHandler();
+
+            Assert.Throws<ArgumentNullException>(() => sut.ShouldNotHaveMadeRequestsTo(null));
+        }
+
         [Fact]
         public void RespondWith_NullValue_ThrowsArgumentNullException()
         {