Add some convenience methods to quicly assert for gets and posts and different types of content

Author: dnperfors

Directory.Build.props

@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <LangVersion>13.0</LangVersion>
+    <LangVersion>14.0</LangVersion>
     <Nullable>enable</Nullable>
     <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
     <EnableNETAnalyzers>true</EnableNETAnalyzers>

src/TestableHttpClient/HttpRequestMessageAsserter.cs

@@ -18,14 +18,14 @@ public HttpRequestMessageAsserter(IEnumerable<HttpRequestMessage> httpRequestMes
     {
         Requests = httpRequestMessages ?? throw new ArgumentNullException(nameof(httpRequestMessages));
         Options = options ?? new TestableHttpMessageHandlerOptions();
-        expectedRequestBuilder = new RequestBuilder(Options.UriPatternMatchingOptions);
+        expectedRequestBuilder = new RequestBuilder(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.UriPatternMatchingOptions);
+        expectedRequestBuilder = new RequestBuilder(Options);
         requestBuilderAction?.Invoke(expectedRequestBuilder);
     }
 

src/TestableHttpClient/PublicAPI.Unshipped.txt

@@ -1,4 +1,9 @@
 override TestableHttpClient.TestableHttpMessageHandler.Dispose(bool disposing) -> void
+static TestableHttpClient.RequestBuilderExtension.Get(this TestableHttpClient.RequestBuilder! builder, string! pattern) -> TestableHttpClient.RequestBuilder!
+static TestableHttpClient.RequestBuilderExtension.Post(this TestableHttpClient.RequestBuilder! builder, string! pattern, string! content) -> TestableHttpClient.RequestBuilder!
+static TestableHttpClient.RequestBuilderExtension.PostAsJson(this TestableHttpClient.RequestBuilder! builder, string! pattern, object? content) -> TestableHttpClient.RequestBuilder!
+static TestableHttpClient.RequestBuilderExtension.WithFormUrlEncodedContent(this TestableHttpClient.RequestBuilder! builder, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string?, string?>>! formValues) -> TestableHttpClient.RequestBuilder!
+static TestableHttpClient.RequestBuilderExtension.WithJsonContent(this TestableHttpClient.RequestBuilder! builder, object? content) -> TestableHttpClient.RequestBuilder!
 TestableHttpClient.IHttpRequestMessagesCheck.WithContent(string! pattern) -> TestableHttpClient.IHttpRequestMessagesCheck!
 TestableHttpClient.IHttpRequestMessagesCheck.WithContent(string! pattern, int expectedNumberOfRequests) -> TestableHttpClient.IHttpRequestMessagesCheck!
 TestableHttpClient.IHttpRequestMessagesCheck.WithHeader(string! headerName) -> TestableHttpClient.IHttpRequestMessagesCheck!
@@ -18,5 +23,6 @@ TestableHttpClient.RequestBuilder.WithHeader(string! headerName, string! pattern
 TestableHttpClient.RequestBuilder.WithMethod(System.Net.Http.HttpMethod! httpMethod) -> TestableHttpClient.RequestBuilder!
 TestableHttpClient.RequestBuilder.WithRequestUri(string! pattern) -> TestableHttpClient.RequestBuilder!
 TestableHttpClient.RequestBuilder.WithVersion(System.Version! httpVersion) -> TestableHttpClient.RequestBuilder!
+TestableHttpClient.RequestBuilderExtension
 TestableHttpClient.TestableHttpMessageHandler.ShouldHaveMadeRequests(int numberOfRequests, System.Action<TestableHttpClient.RequestBuilder!>! builder) -> void
 TestableHttpClient.TestableHttpMessageHandler.ShouldHaveMadeRequests(System.Action<TestableHttpClient.RequestBuilder!>! builder) -> void

src/TestableHttpClient/RequestBuilder.cs

@@ -3,10 +3,12 @@
 public sealed class RequestBuilder
 {
     private Request request;
+    internal TestableHttpMessageHandlerOptions Options { get; }
 
-    internal RequestBuilder(UriPatternMatchingOptions uriPatternMatchingOptions)
+    internal RequestBuilder(TestableHttpMessageHandlerOptions? options = null)
     {
-        request = new(uriPatternMatchingOptions);
+        Options = options ?? new();
+        request = new(Options.UriPatternMatchingOptions);
     }
 
     public RequestBuilder WithMethod(HttpMethod httpMethod)

src/TestableHttpClient/RequestBuilderExtension.cs

@@ -0,0 +1,42 @@
+namespace TestableHttpClient;
+
+public static class RequestBuilderExtension
+{
+    public static RequestBuilder Get(this RequestBuilder builder, string pattern)
+    {
+        Guard.ThrowIfNull(builder);
+        return builder.WithMethod(HttpMethod.Get).WithRequestUri(pattern);
+    }
+
+    public static RequestBuilder Post(this RequestBuilder builder, string pattern, string content)
+    {
+        Guard.ThrowIfNull(builder);
+        return builder.WithMethod(HttpMethod.Post).WithRequestUri(pattern).WithContent(content);
+    }
+
+    public static RequestBuilder PostAsJson(this RequestBuilder builder, string pattern, object? content)
+    {
+        Guard.ThrowIfNull(builder);
+
+        return builder.WithMethod(HttpMethod.Post).WithRequestUri(pattern).WithJsonContent(content);
+    }
+
+    public static RequestBuilder WithJsonContent(this RequestBuilder builder, object? content)
+    {
+        Guard.ThrowIfNull(builder);
+
+        string jsonContent = JsonSerializer.Serialize(content, builder.Options.JsonSerializerOptions);
+
+        return builder.WithContent(jsonContent).WithHeader("Content-Type", "application/json*");
+    }
+
+    public static RequestBuilder WithFormUrlEncodedContent(this RequestBuilder builder, IEnumerable<KeyValuePair<string?, string?>> formValues)
+    {
+        Guard.ThrowIfNull(builder);
+
+        using FormUrlEncodedContent content = new(formValues);
+        string contentString = content.ReadAsStringAsync().Result;
+
+        return builder.WithContent(contentString).WithHeader("Content-Type", "application/x-www-form-urlencoded*");
+    }
+}

test/TestableHttpClient.Tests/RequestBuilderExtensionsTests.cs

@@ -0,0 +1,160 @@
+using TestableHttpClient.Utils;
+
+namespace TestableHttpClient.Tests;
+
+public sealed class RequestBuilderExtensionsTests
+{
+    private readonly RequestBuilder sut = new(new());
+
+    [Fact]
+    public void Get_WithNullBuilder_ShouldThrowArgumentNullException()
+    {
+        RequestBuilder sut = null!;
+        Assert.Throws<ArgumentNullException>(() => sut.Get("https://localhost"));
+    }
+
+    [Fact]
+    public void Get_WithNullRequestUri_ShouldThrowArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => sut.Get(null!));
+    }
+
+    [Fact]
+    public void Get_ShouldSetHttpMethodAndRequestUri()
+    {
+        Request request = sut.Get("https://localhost").Build();
+
+        Assert.Equal(HttpMethod.Get, request.Method);
+        Assert.Equal(UriPatternParser.Parse("https://localhost"), request.RequestUri);
+        Assert.Null(request.Version);
+        Assert.Null(request.Headers);
+        Assert.Null(request.Content);
+    }
+
+    [Fact]
+    public void Post_WithNullBuilder_ShouldThrowArgumentNullException()
+    {
+        RequestBuilder sut = null!;
+        Assert.Throws<ArgumentNullException>(() => sut.Post("https://localhost", "{\"hello\":1}"));
+    }
+
+    [Fact]
+    public void Post_WithNullRequestUri_ShouldThrowArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => sut.Post(null!, "{\"hello\":1}"));
+    }
+
+    [Fact]
+    public void Post_WithNullContent_ShouldThrowArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => sut.Post("https://localhost", null!));
+    }
+
+    [Fact]
+    public void Post_ShouldBuildCorrectRequest()
+    {
+        Request request = sut.Post("https://localhost", "{\"hello\":1}").Build();
+
+        Assert.Equal(HttpMethod.Post, request.Method);
+        Assert.Equal(UriPatternParser.Parse("https://localhost"), request.RequestUri);
+        Assert.Null(request.Version);
+        Assert.Null(request.Headers);
+        Assert.Equal("{\"hello\":1}", request.Content);
+    }
+
+    [Fact]
+    public void PostAsJson_WithNullBuilder_ShouldThrowArgumentNullException()
+    {
+        RequestBuilder sut = null!;
+
+        Assert.Throws<ArgumentNullException>(() => sut.PostAsJson("https://localhost", new()));
+    }
+
+    [Fact]
+    public void PostAsJson_WithNullRequestUri_ShouldThrowArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => sut.PostAsJson(null!, new()));
+    }
+
+    [Fact]
+    public void PostAsJson_WithNullContent_ShouldBuildCorrectRequest()
+    {
+        Request request = sut.PostAsJson("https://localhost", null).Build();
+
+        Assert.Equal(HttpMethod.Post, request.Method);
+        Assert.Equal(UriPatternParser.Parse("https://localhost"), request.RequestUri);
+        Assert.Null(request.Version);
+        Assert.Equivalent(new Dictionary<string, Value>() { ["Content-Type"] = Value.Pattern("application/json*") }, request.Headers);
+        Assert.Equal("null", request.Content);
+    }
+
+    [Fact]
+    public void PostAsJson_ShouldBuildCorrectRequest()
+    {
+        Request request = sut.PostAsJson("https://localhost", new { hello = 1 }).Build();
+
+        Assert.Equal(HttpMethod.Post, request.Method);
+        Assert.Equal(UriPatternParser.Parse("https://localhost"), request.RequestUri);
+        Assert.Null(request.Version);
+        Assert.Equivalent(new Dictionary<string, Value>() { ["Content-Type"] = Value.Pattern("application/json*") }, request.Headers);
+        Assert.Equal("{\"hello\":1}", request.Content);
+    }
+
+    [Fact]
+    public void WithJsonContent_WithNullBuilder_ShouldThrowArgumentNullException()
+    {
+        RequestBuilder sut = null!;
+
+        Assert.Throws<ArgumentNullException>(() => sut.WithJsonContent(new()));
+    }
+
+    [Fact]
+    public void WithJsonContent_WithNullContent_ShouldBuildCorrectRequest()
+    {
+        Request request = sut.WithJsonContent(null).Build();
+
+        Assert.Null(request.Method);
+        Assert.Null(request.RequestUri);
+        Assert.Null(request.Version);
+        Assert.Equivalent(new Dictionary<string, Value>() { ["Content-Type"] = Value.Pattern("application/json*") }, request.Headers);
+        Assert.Equal("null", request.Content);
+    }
+
+    [Fact]
+    public void WithJsonContent_ShouldBuildCorrectRequest()
+    {
+        Request request = sut.WithJsonContent(new { hello = 1 }).Build();
+
+        Assert.Null(request.Method);
+        Assert.Null(request.RequestUri);
+        Assert.Null(request.Version);
+        Assert.Equivalent(new Dictionary<string, Value>() { ["Content-Type"] = Value.Pattern("application/json*") }, request.Headers);
+        Assert.Equal("{\"hello\":1}", request.Content);
+    }
+
+    [Fact]
+    public void WithFormUrlEncodedContent_WithNullBuilder_ShouldThrowArgumentNullException()
+    {
+        RequestBuilder sut = null!;
+
+        Assert.Throws<ArgumentNullException>(() => sut.WithFormUrlEncodedContent([]));
+    }
+
+    [Fact]
+    public void WithFormUrlEncodedContent_WithNullFormValues_ShouldThrowArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => sut.WithFormUrlEncodedContent(null!));
+    }
+
+    [Fact]
+    public void WithFormUrlEncodedContent_ShouldBuildCorrectRequest()
+    {
+        Request request = sut.WithFormUrlEncodedContent([new KeyValuePair<string?, string?>("username", "alice")]).Build();
+
+        Assert.Null(request.Method);
+        Assert.Null(request.RequestUri);
+        Assert.Null(request.Version);
+        Assert.Equivalent(new Dictionary<string, Value>() { ["Content-Type"] = Value.Pattern("application/x-www-form-urlencoded*") }, request.Headers);
+        Assert.Equal("username=alice", request.Content);
+    }
+}

test/TestableHttpClient.Tests/RequestBuilderTests.cs

@@ -4,7 +4,7 @@ namespace TestableHttpClient.Tests;
 
 public sealed class RequestBuilderTests
 {
-    private readonly RequestBuilder sut = new(new UriPatternMatchingOptions());
+    private readonly RequestBuilder sut = new(new());
 
     [Fact]
     public void Build_ByDefault_CreatesEmptyRequest()