VersClientTest.cs

// Generated by Sterling SDK Generator — test suite
// Orchestrator Control Plane API v0.1.0

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Xunit;
using VersSdk;

namespace VersSdk.Tests
{
    /// <summary>Tests for VersSdkClient — verifies URL construction, HTTP methods, and error handling.</summary>
    public class VersSdkClientTests : IDisposable
    {
        private readonly CapturedRequest _captured = new();

        private class CapturedRequest
        {
            public string? Method { get; set; }
            public string? Path { get; set; }
            public string? Body { get; set; }
        }

        private class FakeHandler : HttpMessageHandler
        {
            private readonly CapturedRequest _captured;
            private readonly HttpStatusCode _statusCode;
            private readonly string _responseBody;

            public FakeHandler(CapturedRequest captured, HttpStatusCode statusCode = HttpStatusCode.OK, string? responseBody = null)
            {
                _captured = captured;
                _statusCode = statusCode;
                _responseBody = responseBody ?? "{\"status\":\"ok\"}";
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                _captured.Method = request.Method.Method;
                _captured.Path = request.RequestUri?.PathAndQuery;
                if (request.Content != null)
                {
                    _captured.Body = request.Content.ReadAsStringAsync(cancellationToken).GetAwaiter().GetResult();
                }

                var response = new HttpResponseMessage(_statusCode)
                {
                    Content = new StringContent(_responseBody, Encoding.UTF8, "application/json"),
                };
                return Task.FromResult(response);
            }
        }

        private VersSdkClient MakeClient(HttpStatusCode statusCode = HttpStatusCode.OK, string? responseBody = null)
        {
            var handler = new FakeHandler(_captured, statusCode, responseBody);
            var httpClient = new HttpClient(handler) { BaseAddress = new Uri("http://localhost:9999") };
            return new VersSdkClient(
                baseUrl: "http://localhost:9999",
                apiKey: "test-key",
                maxRetries: 0,
                httpClient: httpClient);
        }

        // ── Operation tests ──────────────────────────────────────────────────

        [Fact]
        public async Task VmStatus_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.VmStatusAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ResizeVmDisk_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ResizeVmDiskAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("PATCH", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ExecVmStreamAttach_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ExecVmStreamAttachAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListVms_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListVmsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task CreateNewRootVm_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.CreateNewRootVmAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task VmLogs_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.VmLogsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task BranchByRef_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.BranchByRefAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task LabelVm_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.LabelVmAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("PATCH", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListPublicCommits_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListPublicCommitsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task GetImageStatus_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.GetImageStatusAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListPublicRepoTags_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListPublicRepoTagsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task VersionHandler_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.VersionHandlerAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task BranchByTag_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.BranchByTagAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task GetRepoTag_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.GetRepoTagAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task DeleteRepoTag_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.DeleteRepoTagAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("DELETE", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task UpdateRepoTag_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.UpdateRepoTagAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("PATCH", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task BranchVm_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.BranchVmAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task GetRepository_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.GetRepositoryAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task DeleteRepository_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.DeleteRepositoryAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("DELETE", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListParentCommits_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListParentCommitsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ValidateKey_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ValidateKeyAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ForkRepository_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ForkRepositoryAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListRepositories_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListRepositoriesAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task CreateRepository_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.CreateRepositoryAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task UpdateVmState_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.UpdateVmStateAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("PATCH", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task CreateImage_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.CreateImageAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task RestoreFromCommit_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.RestoreFromCommitAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task GetDomain_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.GetDomainAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task DeleteDomain_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.DeleteDomainAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("DELETE", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListTags_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListTagsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task CreateTag_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.CreateTagAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListPublicRepositories_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListPublicRepositoriesAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task GetPublicRepoTag_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.GetPublicRepoTagAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task GetVmMetadata_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.GetVmMetadataAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListEnvVars_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListEnvVarsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task SetEnvVars_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.SetEnvVarsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("PUT", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task DeleteVm_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.DeleteVmAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("DELETE", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListCommits_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListCommitsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task GetTag_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.GetTagAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task DeleteTag_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.DeleteTagAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("DELETE", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task UpdateTag_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.UpdateTagAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("PATCH", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task BranchByVm_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.BranchByVmAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task DeleteEnvVar_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.DeleteEnvVarAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("DELETE", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task DeleteImage_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.DeleteImageAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("DELETE", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task CommitVm_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.CommitVmAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task DeleteCommit_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.DeleteCommitAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("DELETE", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task UpdateCommit_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.UpdateCommitAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("PATCH", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListRepoTags_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListRepoTagsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task CreateRepoTag_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.CreateRepoTagAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task DeployHandler_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.DeployHandlerAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ExecVm_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ExecVmAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task SetRepositoryVisibility_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.SetRepositoryVisibilityAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("PATCH", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ExecVmStream_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ExecVmStreamAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListDomains_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListDomainsAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task CreateDomain_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.CreateDomainAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task SshKey_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.SshKeyAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ListImages_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ListImagesAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task ReadFileVm_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.ReadFileVmAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task WriteFileVm_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.WriteFileVmAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("PUT", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task UploadImage_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.UploadImageAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task GetPublicRepository_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.GetPublicRepositoryAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("GET", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        [Fact]
        public async Task BranchByCommit_SendsCorrectMethodAndPath()
        {
            using var client = MakeClient();
            try
            {
                await client.BranchByCommitAsync();
            }
            catch { /* we only care about the captured request */ }
            Assert.Equal("POST", _captured.Method);
            Assert.NotNull(_captured.Path);
            Assert.StartsWith("/", _captured.Path!);
        }

        // ── Error handling tests ─────────────────────────────────────────────

        [Fact]
        public async Task Error400_ThrowsBadRequestException()
        {
            using var client = MakeClient(HttpStatusCode.BadRequest, "{\"message\":\"bad\"}");
            await Assert.ThrowsAsync<BadRequestException>(
                () => client.VmStatusAsync());
        }

        [Fact]
        public async Task Error404_ThrowsNotFoundException()
        {
            using var client = MakeClient(HttpStatusCode.NotFound, "{\"message\":\"not found\"}");
            await Assert.ThrowsAsync<NotFoundException>(
                () => client.VmStatusAsync());
        }

        [Fact]
        public async Task Error500_ThrowsInternalServerException()
        {
            using var client = MakeClient(HttpStatusCode.InternalServerError, "{\"message\":\"server\"}");
            await Assert.ThrowsAsync<InternalServerException>(
                () => client.VmStatusAsync());
        }

        public void Dispose()
        {
            GC.SuppressFinalize(this);
        }
    }
}