perf: tune stress profiles and add real DB mode for performance tests

- Reduce StressProfile from 100 to 30 req/s to prevent unbounded backlog
- Add CalendarStressProfile (25 req/s) for calendar endpoint with 9 sequential queries
- Add PERF_USE_REAL_DB env var toggle to run against real PostgreSQL
- Resolve FirstAccountId from real DB when using real DB mode
- Set 30s HttpClient timeout for stress scenarios

Author: Fortinbra

tests/BudgetExperiment.Performance.Tests/Infrastructure/PerformanceWebApplicationFactory.cs

@@ -15,8 +15,9 @@
 namespace BudgetExperiment.Performance.Tests.Infrastructure;
 
 /// <summary>
-/// Custom <see cref="WebApplicationFactory{TEntryPoint}"/> for performance tests
-/// using an in-memory database and auto-authentication.
+/// Custom <see cref="WebApplicationFactory{TEntryPoint}"/> for performance tests.
+/// By default uses an in-memory database. Set environment variable <c>PERF_USE_REAL_DB=true</c>
+/// to use the real PostgreSQL database from user secrets (same as debug sessions).
 /// </summary>
 public sealed class PerformanceWebApplicationFactory : WebApplicationFactory<Program>
 {
@@ -32,6 +33,12 @@ public sealed class PerformanceWebApplicationFactory : WebApplicationFactory<Pro
 
     private readonly string _dbName = "PerfDb_" + Guid.NewGuid().ToString();
 
+    /// <summary>
+    /// Gets a value indicating whether the factory is configured to use the real database.
+    /// </summary>
+    public static bool UseRealDb { get; } =
+        string.Equals(Environment.GetEnvironmentVariable("PERF_USE_REAL_DB"), "true", StringComparison.OrdinalIgnoreCase);
+
     /// <summary>
     /// Creates an <see cref="HttpClient"/> pre-configured with test authentication.
     /// </summary>
@@ -40,11 +47,38 @@ public HttpClient CreateApiClient()
     {
         var client = this.CreateClient();
         client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("TestAuto", "authenticated");
+        client.Timeout = TimeSpan.FromSeconds(30);
         return client;
     }
 
     /// <inheritdoc />
     protected override void ConfigureWebHost(IWebHostBuilder builder)
+    {
+        if (UseRealDb)
+        {
+            ConfigureRealDb(builder);
+        }
+        else
+        {
+            this.ConfigureInMemoryDb(builder);
+        }
+    }
+
+    private static void ConfigureRealDb(IWebHostBuilder builder)
+    {
+        // Keep the real Npgsql DbContext from AddInfrastructure — only override auth
+        builder.ConfigureServices(services =>
+        {
+            services.AddAuthentication(options =>
+            {
+                options.DefaultAuthenticateScheme = "TestAuto";
+                options.DefaultChallengeScheme = "TestAuto";
+            })
+            .AddScheme<AuthenticationSchemeOptions, AutoAuthenticatingTestHandler>("TestAuto", options => { });
+        });
+    }
+
+    private void ConfigureInMemoryDb(IWebHostBuilder builder)
     {
         builder.ConfigureAppConfiguration((context, config) =>
         {

tests/BudgetExperiment.Performance.Tests/Infrastructure/TestDataSeeder.cs

@@ -7,6 +7,7 @@
 using BudgetExperiment.Domain.Recurring;
 using BudgetExperiment.Infrastructure.Persistence;
 
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace BudgetExperiment.Performance.Tests.Infrastructure;
@@ -35,13 +36,24 @@ public static class TestDataSeeder
 
     /// <summary>
     /// Seeds the database with realistic data for performance testing.
+    /// When <see cref="PerformanceWebApplicationFactory.UseRealDb"/> is true,
+    /// skips seeding but resolves <see cref="FirstAccountId"/> from the existing data.
     /// </summary>
     /// <param name="factory">The web application factory providing the service scope.</param>
     /// <returns>A task representing the asynchronous operation.</returns>
     public static async Task SeedAsync(PerformanceWebApplicationFactory factory)
     {
-        using var scope = factory.Services.CreateScope();
-        var db = scope.ServiceProvider.GetRequiredService<BudgetDbContext>();
+        if (PerformanceWebApplicationFactory.UseRealDb)
+        {
+            using var realScope = factory.Services.CreateScope();
+            var realDb = realScope.ServiceProvider.GetRequiredService<BudgetDbContext>();
+            var account = await realDb.Accounts.FirstOrDefaultAsync();
+            FirstAccountId = account?.Id ?? Guid.Empty;
+            return;
+        }
+
+        using var seedScope = factory.Services.CreateScope();
+        var db = seedScope.ServiceProvider.GetRequiredService<BudgetDbContext>();
 
         var categories = SeedCategories(db);
         var accounts = SeedAccounts(db);

tests/BudgetExperiment.Performance.Tests/Profiles/CalendarStressProfile.cs

@@ -0,0 +1,35 @@
+// Copyright (c) BecauseImClever. All rights reserved.
+
+using NBomber.Contracts;
+using NBomber.CSharp;
+
+namespace BudgetExperiment.Performance.Tests.Profiles;
+
+/// <summary>
+/// Reduced stress profile for the calendar endpoint, which performs 9 sequential
+/// DB queries per request and degrades rapidly at high concurrency.
+/// Uses 25 req/s (vs 100 for the standard stress profile) to identify degradation
+/// without creating an unbounded request backlog.
+/// </summary>
+public static class CalendarStressProfile
+{
+    /// <summary>
+    /// Gets the calendar stress simulation: ramp to 25 req/s over 30 seconds,
+    /// then sustain 25 req/s for 30 seconds.
+    /// </summary>
+    /// <returns>A load simulation array.</returns>
+    public static LoadSimulation[] Simulations()
+    {
+        return
+        [
+            Simulation.RampingInject(
+                rate: 25,
+                interval: TimeSpan.FromSeconds(1),
+                during: TimeSpan.FromSeconds(30)),
+            Simulation.Inject(
+                rate: 25,
+                interval: TimeSpan.FromSeconds(1),
+                during: TimeSpan.FromSeconds(30)),
+        ];
+    }
+}

tests/BudgetExperiment.Performance.Tests/Profiles/StressProfile.cs

@@ -6,28 +6,31 @@
 namespace BudgetExperiment.Performance.Tests.Profiles;
 
 /// <summary>
-/// Stress test profile: ramps from 10 to 100 concurrent requests per second
-/// over 120 seconds to find the system&apos;s breaking point.
+/// Stress test profile: ramps to 30 concurrent requests per second
+/// over 30 seconds, then sustains for another 30 seconds.
+/// Scaled for in-memory WebApplicationFactory testing; 30 req/s is 3x
+/// the load test baseline, pushing beyond normal load while remaining
+/// completable on local hardware.
 /// </summary>
 public static class StressProfile
 {
     /// <summary>
-    /// Gets the stress load simulation: ramp from 10 to 100 req/s over 60 seconds,
-    /// then sustain 100 req/s for another 60 seconds.
+    /// Gets the stress load simulation: ramp to 30 req/s over 30 seconds,
+    /// then sustain 30 req/s for another 30 seconds.
     /// </summary>
     /// <returns>A load simulation array.</returns>
     public static LoadSimulation[] Simulations()
     {
         return
         [
             Simulation.RampingInject(
-                rate: 100,
+                rate: 30,
                 interval: TimeSpan.FromSeconds(1),
-                during: TimeSpan.FromSeconds(60)),
+                during: TimeSpan.FromSeconds(30)),
             Simulation.Inject(
-                rate: 100,
+                rate: 30,
                 interval: TimeSpan.FromSeconds(1),
-                during: TimeSpan.FromSeconds(60)),
+                during: TimeSpan.FromSeconds(30)),
         ];
     }
 }

tests/BudgetExperiment.Performance.Tests/StressTests.cs

@@ -110,12 +110,14 @@ public void Transactions_StressTest()
 
     /// <summary>
     /// Calendar endpoint under stress — the most complex read endpoint (9 sequential DB queries).
+    /// Uses a reduced stress profile (25 req/s vs 100) because the calendar endpoint degrades
+    /// rapidly at high concurrency, creating unbounded request backlogs at 100 req/s.
     /// Stress tests observe degradation without hard latency thresholds.
     /// </summary>
     [Fact]
     public void Calendar_StressTest()
     {
-        var scenario = CalendarScenario.Create(this._client, StressProfile.Simulations())
+        var scenario = CalendarScenario.Create(this._client, CalendarStressProfile.Simulations())
             .WithThresholds(
                 Threshold.Create(stats => stats.Fail.Request.Percent < 5));