Merge main into API Center environment variable fix

Preserve configuration-key validation tests alongside environment-variable resolution tests.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: waldekmastykarz

DevProxy.Abstractions/DevProxy.Abstractions.csproj

@@ -35,7 +35,7 @@
     <PackageReference Include="Markdig" Version="1.4.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.12" />
     <PackageReference Include="Microsoft.Extensions.Configuration" Version="10.0.13" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.12" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.13" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="10.0.12" />
     <PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" Version="10.0.13" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.12" />

DevProxy.Abstractions/packages.lock.json

@@ -35,12 +35,12 @@
       },
       "Microsoft.Extensions.Configuration.Binder": {
         "type": "Direct",
-        "requested": "[10.0.12, )",
-        "resolved": "10.0.12",
-        "contentHash": "dAgIf1TOr8KLs+aBRIbXUZBjHoSH4rDG8+XkX/Q6AZwkQdMA0+yPDKTHsieeXdZDfpOpZVHzOnuAb5Z2nX3KsA==",
+        "requested": "[10.0.13, )",
+        "resolved": "10.0.13",
+        "contentHash": "yJJl/b0+W+GEWbu+7viw6C3h2BoNkB69Vlz7s/4e+hm4mYbJqfhdcDSi9sCXJw47blsBaiQd3UDPgDtop92+ug==",
         "dependencies": {
-          "Microsoft.Extensions.Configuration": "10.0.12",
-          "Microsoft.Extensions.Configuration.Abstractions": "10.0.12"
+          "Microsoft.Extensions.Configuration": "10.0.13",
+          "Microsoft.Extensions.Configuration.Abstractions": "10.0.13"
         }
       },
       "Microsoft.Extensions.Configuration.Json": {

DevProxy.Integration.Tests/ApiCenterClientTests.cs

@@ -8,10 +8,31 @@
 
 namespace DevProxy.Integration.Tests;
 
-public class ApiCenterClientTests
+public sealed class ApiCenterClientTests
 {
     private const string VariableName = "DEVPROXY_TEST_APICENTER_SUBSCRIPTION_ID";
 
+    [Theory]
+    [InlineData("subscriptionId")]
+    [InlineData("resourceGroupName")]
+    [InlineData("serviceName")]
+    [InlineData("workspaceName")]
+    public void Constructor_MissingSetting_ErrorUsesConfigKeyName(string missingKey)
+    {
+        var configuration = new ApiCenterClientConfiguration
+        {
+            SubscriptionId = missingKey == "subscriptionId" ? "" : "sub",
+            ResourceGroupName = missingKey == "resourceGroupName" ? "" : "rg",
+            ServiceName = missingKey == "serviceName" ? "" : "svc",
+            WorkspaceName = missingKey == "workspaceName" ? "" : "default"
+        };
+
+        var ex = Assert.Throws<ArgumentException>(() =>
+            new ApiCenterClient(configuration, NullLogger<ApiCenterClient>.Instance));
+
+        Assert.Equal($"Specify {missingKey} in the configuration.", ex.Message);
+    }
+
     [Fact]
     public void Constructor_UnsetEnvironmentVariable_Throws()
     {

DevProxy.Integration.Tests/BehaviorPluginsIntegrationTests.cs

@@ -189,6 +189,107 @@ public async Task GenericRandomError_DynamicRetryAfterOnNon429_IsResolved()
         Assert.Equal(HttpStatusCode.TooManyRequests, retry.StatusCode);
     }
 
+    [Fact]
+    public async Task GenericRandomError_BodyWithoutContentType_DefaultsToApplicationJson()
+    {
+        await using var origin = await FakeOrigin.StartAsync();
+        var dir = Directory.CreateTempSubdirectory("devproxy-errors-");
+        try
+        {
+            await File.WriteAllTextAsync(
+                Path.Combine(dir.FullName, "errors.json"),
+                $$"""
+                {
+                  "errors": [
+                    {
+                      "request": { "url": "http://{{origin.Host}}/*" },
+                      "responses": [ { "statusCode": 500, "body": { "error": "boom" } } ]
+                    }
+                  ]
+                }
+                """);
+            var proxyConfig = new TestProxyConfiguration
+            {
+                ConfigFile = Path.Combine(dir.FullName, "devproxyrc.json"),
+            };
+            var plugin = new GenericRandomErrorPlugin(
+                SharedHttpClient,
+                NullLogger<GenericRandomErrorPlugin>.Instance,
+                KestrelProxyHarness.BuildUrlsToWatch(origin.Host),
+                proxyConfig,
+                PluginConfig.FromJson("""{ "rate": 100 }"""));
+
+            using var host = new PluginTestHost(proxyConfig);
+            await plugin.InitializeAsync(host.CreateInitArgs(), CancellationToken.None);
+
+            await using var proxy = await KestrelProxyHarness.StartAsync(origin.Host, [plugin]);
+            using var client = proxy.CreateHttpClient();
+
+            using var response = await client.GetAsync(new Uri($"http://{origin.Host}/get"));
+
+            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
+            Assert.Equal("application/json", response.Content.Headers.ContentType?.MediaType);
+        }
+        finally
+        {
+            dir.Delete(recursive: true);
+        }
+    }
+
+    [Fact]
+    public async Task GenericRandomError_ExplicitContentType_IsPreserved()
+    {
+        await using var origin = await FakeOrigin.StartAsync();
+        var dir = Directory.CreateTempSubdirectory("devproxy-errors-");
+        try
+        {
+            await File.WriteAllTextAsync(
+                Path.Combine(dir.FullName, "errors.json"),
+                $$"""
+                {
+                  "errors": [
+                    {
+                      "request": { "url": "http://{{origin.Host}}/*" },
+                      "responses": [
+                        {
+                          "statusCode": 500,
+                          "headers": [ { "name": "Content-Type", "value": "text/plain" } ],
+                          "body": "boom"
+                        }
+                      ]
+                    }
+                  ]
+                }
+                """);
+            var proxyConfig = new TestProxyConfiguration
+            {
+                ConfigFile = Path.Combine(dir.FullName, "devproxyrc.json"),
+            };
+            var plugin = new GenericRandomErrorPlugin(
+                SharedHttpClient,
+                NullLogger<GenericRandomErrorPlugin>.Instance,
+                KestrelProxyHarness.BuildUrlsToWatch(origin.Host),
+                proxyConfig,
+                PluginConfig.FromJson("""{ "rate": 100 }"""));
+
+            using var host = new PluginTestHost(proxyConfig);
+            await plugin.InitializeAsync(host.CreateInitArgs(), CancellationToken.None);
+
+            await using var proxy = await KestrelProxyHarness.StartAsync(origin.Host, [plugin]);
+            using var client = proxy.CreateHttpClient();
+
+            using var response = await client.GetAsync(new Uri($"http://{origin.Host}/get"));
+
+            Assert.Equal("text/plain", response.Content.Headers.ContentType?.MediaType);
+            Assert.True(response.Content.Headers.TryGetValues("Content-Type", out var values));
+            _ = Assert.Single(values);
+        }
+        finally
+        {
+            dir.Delete(recursive: true);
+        }
+    }
+
     [Fact]
     public async Task Latency_AddsConfiguredDelayBeforeForwarding()
     {
@@ -239,6 +340,47 @@ public void Latency_DelayRangeIncludesMaxMs()
         Assert.InRange(LatencyPlugin.GetDelay(random, int.MaxValue - 1, int.MaxValue), int.MaxValue - 1, int.MaxValue);
     }
 
+    [Fact]
+    public async Task Latency_InitializeFailsWhenMinMsGreaterThanMaxMs()
+    {
+        var config = PluginConfig.FromJson("""
+            { "minMs": 500, "maxMs": 100 }
+            """);
+        var plugin = new LatencyPlugin(
+            SharedHttpClient,
+            NullLogger<LatencyPlugin>.Instance,
+            KestrelProxyHarness.BuildUrlsToWatch("localhost"),
+            ProxyConfig,
+            config);
+
+        using var host = new PluginTestHost(ProxyConfig);
+        var ex = await Assert.ThrowsAsync<InvalidOperationException>(
+            () => plugin.InitializeAsync(host.CreateInitArgs(), CancellationToken.None));
+
+        Assert.Contains("minMs (500)", ex.Message, StringComparison.Ordinal);
+        Assert.Contains("maxMs (100)", ex.Message, StringComparison.Ordinal);
+        Assert.False(plugin.Enabled);
+    }
+
+    [Fact]
+    public async Task Latency_InitializeSucceedsWhenMinMsEqualsMaxMs()
+    {
+        var config = PluginConfig.FromJson("""
+            { "minMs": 100, "maxMs": 100 }
+            """);
+        var plugin = new LatencyPlugin(
+            SharedHttpClient,
+            NullLogger<LatencyPlugin>.Instance,
+            KestrelProxyHarness.BuildUrlsToWatch("localhost"),
+            ProxyConfig,
+            config);
+
+        using var host = new PluginTestHost(ProxyConfig);
+        await plugin.InitializeAsync(host.CreateInitArgs(), CancellationToken.None);
+
+        Assert.True(plugin.Enabled);
+    }
+
     [Fact]
     public async Task RateLimiting_ThrottlesOnceResourcesAreExhausted()
     {
@@ -268,6 +410,50 @@ public async Task RateLimiting_ThrottlesOnceResourcesAreExhausted()
         Assert.Equal(HttpStatusCode.TooManyRequests, second.StatusCode);
     }
 
+    [Fact]
+    public async Task RateLimiting_CustomResponseWithBody_DefaultsToApplicationJson()
+    {
+        await using var origin = await FakeOrigin.StartAsync();
+        var dir = Directory.CreateTempSubdirectory("devproxy-ratelimit-");
+        try
+        {
+            await File.WriteAllTextAsync(
+                Path.Combine(dir.FullName, "rate-limit-response.json"),
+                """
+                { "statusCode": 403, "body": { "error": "quota exceeded" } }
+                """);
+            var proxyConfig = new TestProxyConfiguration
+            {
+                ConfigFile = Path.Combine(dir.FullName, "devproxyrc.json"),
+            };
+            var plugin = new RateLimitingPlugin(
+                SharedHttpClient,
+                NullLogger<RateLimitingPlugin>.Instance,
+                KestrelProxyHarness.BuildUrlsToWatch(origin.Host),
+                proxyConfig,
+                PluginConfig.FromJson("""
+                    { "rateLimit": 2, "costPerRequest": 2, "resetTimeWindowSeconds": 300, "whenLimitExceeded": "Custom" }
+                    """));
+
+            using var host = new PluginTestHost(proxyConfig);
+            await plugin.InitializeAsync(host.CreateInitArgs(), CancellationToken.None);
+
+            await using var proxy = await KestrelProxyHarness.StartAsync(origin.Host, [plugin]);
+            using var client = proxy.CreateHttpClient();
+
+            using var first = await client.GetAsync(new Uri($"http://{origin.Host}/get"));
+            using var limited = await client.GetAsync(new Uri($"http://{origin.Host}/get"));
+
+            Assert.Equal(HttpStatusCode.OK, first.StatusCode);
+            Assert.Equal(HttpStatusCode.Forbidden, limited.StatusCode);
+            Assert.Equal("application/json", limited.Content.Headers.ContentType?.MediaType);
+        }
+        finally
+        {
+            dir.Delete(recursive: true);
+        }
+    }
+
     [Fact]
     public async Task RateLimitingPlusRetryAfter_ThrottledResponseCarriesRetryAfter()
     {

DevProxy.Integration.Tests/GenerationPluginsIntegrationTests.cs

@@ -11,6 +11,7 @@
 using DevProxy.Abstractions.Proxy.Http;
 using DevProxy.Abstractions.Utils;
 using DevProxy.Plugins.Generation;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Xunit;
 
@@ -160,6 +161,49 @@ public async Task MockGenerator_WritesMockFile()
         }
     }
 
+    [Fact]
+    public async Task MockGenerator_PreservesRecordedOrderForSameUrl()
+    {
+        var plugin = new MockGeneratorPlugin(NullLogger<MockGeneratorPlugin>.Instance, Watch);
+
+        // enough entries to exceed the insertion-sort threshold of an unstable sort
+        const int count = 40;
+        var logs = Enumerable.Range(0, count)
+            .Select(i => TestExchange
+                .Request("GET", i % 2 == 0 ? "https://api.contoso.com/a" : "https://api.contoso.com/b")
+                .WithResponse(
+                    HttpStatusCode.OK,
+                    headers: [("Content-Type", "application/json")],
+                    body: $$"""{ "seq": {{i}} }""")
+                .AsRequestLog(MessageType.InterceptedResponse))
+            .ToList();
+
+        var args = Recording(logs);
+        var dir = await InTempCwdAsync(() => plugin.AfterRecordingStopAsync(args, CancellationToken.None));
+        try
+        {
+            var mockFile = dir.GetFiles("mocks-*.json").Single();
+            using var doc = JsonDocument.Parse(await File.ReadAllTextAsync(mockFile.FullName));
+            var mocks = doc.RootElement.GetProperty("mocks").EnumerateArray()
+                .Select(m => (
+                    Url: m.GetProperty("request").GetProperty("url").GetString(),
+                    Seq: m.GetProperty("response").GetProperty("body").GetProperty("seq").GetInt32()))
+                .ToArray();
+
+            Assert.Equal(count, mocks.Length);
+
+            var expected = Enumerable.Range(0, count).Where(i => i % 2 == 1)
+                .Select(i => ("https://api.contoso.com/b", i))
+                .Concat(Enumerable.Range(0, count).Where(i => i % 2 == 0)
+                    .Select(i => ("https://api.contoso.com/a", i)));
+            Assert.Equal(expected, mocks.Select(m => (m.Url!, m.Seq)));
+        }
+        finally
+        {
+            dir.Delete(recursive: true);
+        }
+    }
+
     [Fact]
     public async Task HttpFileGenerator_WritesHttpFile()
     {
@@ -217,9 +261,10 @@ public async Task OpenApiSpecGenerator_WritesSpec()
     [Fact]
     public async Task TypeSpecGenerator_WritesSpec()
     {
+        var logger = new MessageCapturingLogger<TypeSpecGeneratorPlugin>();
         var plugin = new TypeSpecGeneratorPlugin(
             TestDefaults.HttpClient,
-            NullLogger<TypeSpecGeneratorPlugin>.Instance,
+            logger,
             Watch,
             new DisabledLanguageModelClient(),
             new TestProxyConfiguration(),
@@ -233,10 +278,30 @@ public async Task TypeSpecGenerator_WritesSpec()
                 ((Dictionary<string, object>)args.GlobalData[ProxyUtils.ReportsKey])[plugin.Name]);
             Assert.NotEmpty(report);
             Assert.NotEmpty(dir.GetFiles("*.tsp"));
+            Assert.Contains(logger.Messages, m => m.StartsWith("Writing TypeSpec file to ", StringComparison.Ordinal));
+            Assert.Contains(logger.Messages, m => m.StartsWith("Created TypeSpec file ", StringComparison.Ordinal));
+            Assert.DoesNotContain(logger.Messages, m => m.Contains("OpenAPI", StringComparison.Ordinal));
         }
         finally
         {
             dir.Delete(recursive: true);
         }
     }
+
+    private sealed class MessageCapturingLogger<T> : ILogger<T>
+    {
+        public List<string> Messages { get; } = [];
+
+        public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null;
+
+        public bool IsEnabled(LogLevel logLevel) => true;
+
+        public void Log<TState>(
+            LogLevel logLevel,
+            EventId eventId,
+            TState state,
+            Exception? exception,
+            Func<TState, Exception?, string> formatter) =>
+            Messages.Add(formatter(state, exception));
+    }
 }

DevProxy.Integration.Tests/JsonReporterTests.cs

@@ -0,0 +1,31 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using DevProxy.Abstractions.Proxy;
+using DevProxy.Plugins.Reporters;
+using DevProxy.Plugins.Reporting;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit;
+
+namespace DevProxy.Integration.Tests;
+
+public sealed class JsonReporterTests
+{
+    private sealed class TestJsonReporter() : JsonReporter(NullLogger<JsonReporter>.Instance, new HashSet<UrlToWatch>())
+    {
+        public string? Report(string key, object value) => GetReport(new(key, value));
+    }
+
+    [Fact]
+    public void FileExtension_IsDeterminedPerReport()
+    {
+        var reporter = new TestJsonReporter();
+
+        _ = reporter.Report("UrlDiscoveryPlugin", new UrlDiscoveryPluginReport { Data = ["https://api.contoso.com/*"] });
+        Assert.Equal(".jsonc", reporter.FileExtension);
+
+        _ = reporter.Report("OtherPlugin", new { Value = 1 });
+        Assert.Equal(".json", reporter.FileExtension);
+    }
+}