Refactored test to not use a new constructor but made Put/Get protected virtual to verify the API url

Author: ramonsmits

src/NServiceBus.Transport.RabbitMQ.Tests/ManagementClientApiUrlTests.cs

@@ -1,39 +1,24 @@
-using System;
-using System.Collections.Generic;
-using System.Net;
-using System.Net.Http;
-using System.Net.Http.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using NServiceBus;
+using NServiceBus.Transport.RabbitMQ;
 using NServiceBus.Transport.RabbitMQ.ManagementApi;
 using NUnit.Framework;
 
 [TestFixture]
 public class ManagementClientApiUrlTests
 {
-    TestHttpHandler handler = null!;
-    ManagementClient client = null!;
+    TestableManagementClient client = null!;
 
     [SetUp]
-    public void Setup()
-    {
-        handler = new TestHttpHandler();
-        var httpClient = new HttpClient(handler) { BaseAddress = new Uri("http://localhost/xxx/") };
-        client = new ManagementClient(httpClient);
-    }
+    public void Setup() => client = new TestableManagementClient();
 
     [TearDown]
-    public void Teardown()
-    {
-        client.Dispose();
-        handler.Dispose();
-    }
+    public void Teardown() => client.Dispose();
 
     [Test]
     public async Task CreatePolicy_PutsToCorrectUrl()
     {
-        handler.Expect(HttpMethod.Put, "/xxx/api/policies/%2Fvhosttest/my-policy");
-
         await client.CreatePolicy("my-policy", new Policy
         {
             Pattern = "my-pattern",
@@ -42,165 +27,127 @@ public async Task CreatePolicy_PutsToCorrectUrl()
 
         });
 
-        handler.Verify();
+        client.VerifyPut("api/policies/%2Fvhosttest/my-policy");
     }
 
     [Test]
     public async Task GetBindingsForExchange_GetsFromCorrectUrl()
     {
-        handler.Expect(HttpMethod.Get, "/xxx/api/exchanges/%2Fvhosttest/my-exchange/bindings/destination")
-            .Returns(new List<Binding>());
-
         await client.GetBindingsForExchange("my-exchange");
 
-        handler.Verify();
+        client.VerifyGet("api/exchanges/%2Fvhosttest/my-exchange/bindings/destination");
     }
 
     [Test]
     public async Task GetBindingsForQueue_GetsFromCorrectUrl()
     {
-        handler.Expect(HttpMethod.Get, "/xxx/api/queues/%2Fvhosttest/my-queue/bindings")
-            .Returns(new List<Binding>());
-
         await client.GetBindingsForQueue("my-queue");
 
-        handler.Verify();
+        client.VerifyGet("api/queues/%2Fvhosttest/my-queue/bindings");
     }
 
     [Test]
     public async Task GetFeatureFlags_GetsFromCorrectUrl()
     {
-        handler.Expect(HttpMethod.Get, "/xxx/api/feature-flags")
-            .Returns(new List<FeatureFlag>());
-
         await client.GetFeatureFlags();
 
-        handler.Verify();
+        client.VerifyGet("api/feature-flags");
     }
 
     [Test]
     public async Task GetOverview_GetsFromCorrectUrl()
     {
-        handler.Expect(HttpMethod.Get, "/xxx/api/overview")
-            .Returns(new Overview
-            {
-                BrokerVersion = "1.2.3",
-                DisableStats = false,
-            });
-
         await client.GetOverview();
 
-        handler.Verify();
+        client.VerifyGet("api/overview");
     }
 
     [Test]
     public async Task GetQueue_GetsFromCorrectUrl()
     {
-        handler.Expect(HttpMethod.Get, "/xxx/api/queues/%2Fvhosttest/my-queue")
-            .Returns(new Queue
-            {
-                Name = "my-queue",
-                Arguments = new QueueArguments()
-            });
-
-        var result = await client.GetQueue("my-queue");
+        await client.GetQueue("my-queue");
 
-        Assert.That(result.Name, Is.EqualTo("my-queue"));
-        handler.Verify();
+        client.VerifyGet("api/queues/%2Fvhosttest/my-queue");
     }
 
     [Test]
     public async Task GetQueues_GetsFromCorrectUrlWithPagination()
     {
-        handler.Expect(HttpMethod.Get, "/xxx/api/queues/%2Fvhosttest/?page=2&page_size=100")
-            .Returns(new GetQueuesResult
-            {
-                Items = [],
-                Page = 2,
-                PageCount = 5
-            });
-
-        var (_, morePages) = await client.GetQueues(page: 2, pageSize: 100);
+        await client.GetQueues(page: 2, pageSize: 100);
 
-        Assert.That(morePages, Is.True);
-        handler.Verify();
+        client.VerifyGet("api/queues/%2Fvhosttest/?page=2&page_size=100");
     }
 
     [Test]
     public async Task GetQueues_LastPage_ReturnsMorePagesFalse()
     {
-        handler.Expect(HttpMethod.Get, "/xxx/api/queues/%2Fvhosttest/?page=5&page_size=100")
-            .Returns(new GetQueuesResult
-            {
-                Items = [],
-                Page = 5,
-                PageCount = 5
-            });
+        client.SetupGetResult(new GetQueuesResult
+        {
+            Items = [],
+            Page = 5,
+            PageCount = 5
+        });
 
-        var (_, morePages) = await client.GetQueues(page: 5, pageSize: 100);
+        await client.GetQueues(page: 5, pageSize: 100);
 
-        Assert.That(morePages, Is.False);
-        handler.Verify();
+        client.VerifyGet("api/queues/%2Fvhosttest/?page=5&page_size=100");
     }
 
     [Test]
     public async Task GetQueue_WithSpecialCharacters_EscapesCorrectly()
     {
-        handler.Expect(HttpMethod.Get, "/xxx/api/queues/%2Fvhosttest/queue%2Fwith%2Fslashes")
-            .Returns(new Queue
-            {
-                Name = "queue/with/slashes",
-                Arguments = new QueueArguments()
-            });
-
         await client.GetQueue("queue/with/slashes");
 
-        handler.Verify();
+        client.VerifyGet("api/queues/%2Fvhosttest/queue%2Fwith%2Fslashes");
     }
 
-    class TestHttpHandler : HttpMessageHandler
+    class TestableManagementClient()
+        : ManagementClient(
+            ConnectionConfiguration.Create("host=.;virtualHost=/vhosttest;username=u;password=p;port=12345"),
+            new ManagementApiConfiguration("http://localhost:12345/xxx", "u", "p")
+        )
     {
-        HttpMethod expectedMethod;
-        string expectedPath;
-        object responseObject;
-        bool requestMade;
+        string capturedGetUrl;
+        string capturedPutUrl;
+        object getResult;
+
+        public void SetupGetResult<T>(T result) => getResult = result;
 
-        public TestHttpHandler Expect(HttpMethod method, string path)
+        protected override Task<T> Get<T>(string url, CancellationToken cancellationToken = default)
         {
-            expectedMethod = method;
-            expectedPath = path;
-            return this;
+            capturedGetUrl = url;
+
+            if (getResult is T typedResult)
+            {
+                return Task.FromResult(typedResult);
+            }
+
+            return Task.FromResult(CreateDefaultResult<T>());
         }
 
-        public TestHttpHandler Returns(object obj)
+        protected override Task Put<T>(string url, T value, CancellationToken cancellationToken = default)
         {
-            responseObject = obj;
-            return this;
+            capturedPutUrl = url;
+            return Task.CompletedTask;
         }
 
-        protected override Task<HttpResponseMessage> SendAsync(
-            HttpRequestMessage request,
-#pragma warning disable PS0003
-            CancellationToken cancellationToken
-#pragma warning restore PS0003
-        )
-        {
-            requestMade = true;
+        public void VerifyGet(string expectedUrl) => Assert.That(capturedGetUrl, Is.EqualTo(expectedUrl), $"Expected GET to {expectedUrl}, but got {capturedGetUrl}");
 
-            Assert.That(request.Method, Is.EqualTo(expectedMethod),
-                $"Expected {expectedMethod}, got {request.Method}");
-            Assert.That(request.RequestUri?.PathAndQuery, Is.EqualTo(expectedPath),
-                $"Expected {expectedPath}, got {request.RequestUri?.PathAndQuery}");
+        public void VerifyPut(string expectedUrl) => Assert.That(capturedPutUrl, Is.EqualTo(expectedUrl), $"Expected PUT to {expectedUrl}, but got {capturedPutUrl}");
 
-            var response = new HttpResponseMessage(HttpStatusCode.OK);
-            if (responseObject is not null)
+        static T CreateDefaultResult<T>()
+        {
+            if (typeof(T) == typeof(GetQueuesResult))
             {
-                response.Content = JsonContent.Create(responseObject);
+                return (T)(object)new GetQueuesResult
+                {
+                    Items = [],
+                    Page = 1,
+                    PageCount = 1
+                };
             }
 
-            return Task.FromResult(response);
+            return default;
         }
-
-        public void Verify() => Assert.That(requestMade, Is.True, "Expected HTTP request was not made");
     }
 }

src/NServiceBus.Transport.RabbitMQ/Administration/ManagementApi/ManagementClient.cs

@@ -21,12 +21,6 @@ class ManagementClient : IDisposable
 
     bool disposed;
 
-    internal ManagementClient(HttpClient httpClient)
-    {
-        escapedVirtualHost = Uri.EscapeDataString("/vhosttest");
-        this.httpClient = httpClient;
-    }
-
     public ManagementClient(ConnectionConfiguration connectionConfiguration, ManagementApiConfiguration? managementApiConfiguration = null, bool disableRemoteCertificateValidation = false)
     {
         ArgumentNullException.ThrowIfNull(connectionConfiguration);
@@ -142,14 +136,14 @@ public async Task<Queue> GetQueue(string queueName, CancellationToken cancellati
         return (response.Items, response.Page < response.PageCount);
     }
 
-    async Task<T> Get<T>(string url, CancellationToken cancellationToken)
+    protected virtual async Task<T> Get<T>(string url, CancellationToken cancellationToken = default)
     {
         var response = await httpClient.GetFromJsonAsync<T>(url, cancellationToken).ConfigureAwait(false);
 
         return response ?? throw new HttpRequestException("RabbitMQ management API returned success but deserializing the response body returned null.");
     }
 
-    async Task Put<T>(string url, T value, CancellationToken cancellationToken)
+    protected virtual async Task Put<T>(string url, T value, CancellationToken cancellationToken = default)
     {
         using var response = await httpClient.PutAsJsonAsync(url, value, cancellationToken).ConfigureAwait(false);