yavsc/src/test/Yavsc.Server.Tests/ResourceUsageTests.cs
Paul Schneider 5dc991b885
feat(resources): notify users at consumption thresholds
Persist private alerts at 50, 75, 90, 95 and 99 percent of net consumption, reporting only the highest crossed threshold and rearming after consumption decreases. Keep notification reading and dismissal accessible at quota. Add crossing, concurrency, rollback and privacy tests. Verified 229 API and 238 server tests pass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-12 18:33:28 +00:00

660 lines
34 KiB
C#

using System.Security.Claims;
using Microsoft.AspNetCore.Http;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Options;
using Yavsc.Models;
using Yavsc.Server.Helpers;
using Yavsc.Settings;
using Yavsc.Abstract.Resources;
namespace Yavsc.Server.Tests;
[Trait("Category", "non-reg")]
public sealed class ResourceUsageTests
{
[Theory]
[InlineData(50)]
[InlineData(75)]
[InlineData(90)]
[InlineData(95)]
[InlineData(99)]
public async Task Resource_alert_is_created_at_the_exact_threshold_and_not_repeated_above_it(int threshold)
{
var ct = TestContext.Current.CancellationToken;
using var provider = NewProvider(o => o.DefaultLimit = 1000m);
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: threshold * 10m - 0.001m,
cancellationToken: ct);
db.Notification.RemoveRange(db.Notification);
await db.SaveChangesAsync(ct);
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 0.001m, cancellationToken: ct);
var notification = Assert.Single(db.Notification);
Assert.Equal("user/alice", notification.Target);
Assert.Equal($"resource-usage/{threshold}", notification.tag);
Assert.Contains($"{threshold} %", notification.title);
Assert.Equal("Fermer", notification.click_action);
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 0.001m, cancellationToken: ct);
await scope.ServiceProvider.GetRequiredService<IResourceUsageService>().GetCurrentAsync("alice", "alice", ct);
Assert.Single(db.Notification);
}
[Fact]
public void Resource_alert_uses_personal_limit_all_resource_weights_and_net_credits()
{
using var provider = NewProvider(o => o.UserLimits["alice"] = 100m);
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
var record = new ResourceUsageRecord
{
UserId = "alice", UserName = "alice",
ApiCalls = 500m, CpuSeconds = 40m, BandwidthMb = 100m, StorageMb = 100m,
CreditPoints = 41m
};
db.ResourceUsageRecords.Add(record);
db.SaveChanges();
Assert.Empty(db.Notification);
record.ApiCalls += 50m;
db.SaveChanges();
Assert.Equal("resource-usage/50", Assert.Single(db.Notification).tag);
}
[Fact]
public async Task Resource_alert_for_a_jump_only_reports_the_highest_crossed_threshold()
{
using var provider = NewProvider(o => o.DefaultLimit = 1000m);
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 1000m,
cancellationToken: TestContext.Current.CancellationToken);
Assert.Equal("resource-usage/99", Assert.Single(db.Notification).tag);
}
[Fact]
public async Task Resource_alert_rearms_after_administrative_credits_lower_consumption()
{
var ct = TestContext.Current.CancellationToken;
using var provider = NewProvider(o => o.DefaultLimit = 1000m);
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
db.Users.Add(new ApplicationUser { Id = "alice", UserName = "alice", Email = "alice@example.test" });
await db.SaveChangesAsync(ct);
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 500m, cancellationToken: ct);
var firstId = Assert.Single(db.Notification).Id;
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 500m, cancellationToken: ct);
var count = db.Notification.Count();
await scope.ServiceProvider.GetRequiredService<IResourceUsageService>()
.EraseAsync("alice", "admin", new() { Points = 501m }, ct);
Assert.Equal(count, db.Notification.Count());
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 1m, cancellationToken: ct);
var alerts = db.Notification.Where(n => n.tag == "resource-usage/50").OrderBy(n => n.Id).ToArray();
Assert.Equal(2, alerts.Length);
Assert.Equal(firstId, alerts[0].Id);
Assert.NotEqual(firstId, alerts[1].Id);
}
[Fact]
public async Task Resource_alert_rearms_after_storage_is_released()
{
var ct = TestContext.Current.CancellationToken;
using var provider = NewProvider(o => o.DefaultLimit = 60m);
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
const long bytes = 100 * 1024 * 1024;
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "test-file", bytes, ct);
Assert.Single(db.Notification);
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "test-file", 0, ct);
Assert.Single(db.Notification);
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "test-file", bytes, ct);
Assert.Equal(2, db.Notification.Count());
Assert.All(db.Notification, note => Assert.Equal("resource-usage/50", note.tag));
}
[Fact]
public async Task Concurrent_resource_updates_only_create_one_alert_per_crossing()
{
var ct = TestContext.Current.CancellationToken;
using var provider = NewProvider(o => o.DefaultLimit = 1000m);
using (var seed = provider.CreateScope())
await ResourceUsageTracker.RecordAsync(seed.ServiceProvider.GetRequiredService<ApplicationDbContext>(),
"alice", "alice", cpuSeconds: 499m, cancellationToken: ct);
await Task.WhenAll(Enumerable.Range(0, 10).Select(async _ =>
{
using var scope = provider.CreateScope();
await ResourceUsageTracker.RecordAsync(scope.ServiceProvider.GetRequiredService<ApplicationDbContext>(),
"alice", "alice", cpuSeconds: 1m, cancellationToken: ct);
}));
using var verification = provider.CreateScope();
Assert.Equal("resource-usage/50",
Assert.Single(verification.ServiceProvider.GetRequiredService<ApplicationDbContext>().Notification).tag);
}
[Theory]
[InlineData("125.12345678", "1874.87654322", true)]
[InlineData("2000", "0", false)]
public async Task Administrative_erasure_preserves_counters_and_existing_credits_and_audits_actor(
string amount, string remaining, bool stillReached)
{
var ct = TestContext.Current.CancellationToken;
using var provider = NewProvider(o => o.DefaultLimit = 1000m);
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
db.Users.Add(new ApplicationUser { Id = "alice", UserName = "alice", Email = "alice@example.test" });
var old = new ResourceUsageRecord { UserId = "alice", CpuSeconds = 1200m, RecordedAtUtc = DateTime.UtcNow.AddDays(-1) };
var current = new ResourceUsageRecord
{
UserId = "alice", UserName = "alice", ApiCalls = 100m, CpuSeconds = 1800m,
BandwidthMb = 1000m, StorageMb = 1000m, CreditPoints = 202m, EstimatedCompensation = 17m
};
db.ResourceUsageRecords.AddRange(old, current);
await db.SaveChangesAsync(ct);
var points = decimal.Parse(amount, System.Globalization.CultureInfo.InvariantCulture);
var usage = scope.ServiceProvider.GetRequiredService<IResourceUsageService>();
var result = await usage.EraseAsync("alice", "admin", new() { Points = points, ExpectedCredits = 202m }, ct);
Assert.Equal(decimal.Parse(remaining, System.Globalization.CultureInfo.InvariantCulture), result.Consumption);
Assert.Equal(stillReached, result.IsQuotaReached);
Assert.Equal(0m, result.CreditBalance);
Assert.Equal(202m + points, current.CreditPoints);
Assert.Equal(100m, current.ApiCalls);
Assert.Equal(1800m, current.CpuSeconds);
Assert.Equal(1000m, current.BandwidthMb);
Assert.Equal(1000m, current.StorageMb);
Assert.Equal(17m, current.EstimatedCompensation);
Assert.Equal("admin", current.UserModified);
Assert.Equal(0m, old.CreditPoints);
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 1m, cancellationToken: ct);
Assert.Equal(result.Consumption + 1m, (await usage.GetCurrentAsync("alice", "alice", ct)).Consumption);
}
[Theory]
[InlineData("0")]
[InlineData("-1")]
[InlineData("0.000000001")]
[InlineData("100000000000000000000")]
public async Task Administrative_erasure_rejects_invalid_precision_and_nonpositive_amounts(string input)
{
using var provider = NewProvider();
using var scope = provider.CreateScope();
var service = scope.ServiceProvider.GetRequiredService<IResourceUsageService>();
var points = decimal.Parse(input, System.Globalization.CultureInfo.InvariantCulture);
var error = await Assert.ThrowsAsync<ResourceUsageAdjustmentException>(() => service.EraseAsync(
"alice", "admin", new() { Points = points }, TestContext.Current.CancellationToken));
Assert.Equal(400, error.StatusCode);
Assert.Empty(scope.ServiceProvider.GetRequiredService<ApplicationDbContext>().ResourceUsageRecords);
}
[Theory]
[InlineData("missing", 404)]
[InlineData("withdrawn", 409)]
[InlineData("below-limit", 409)]
[InlineData("no-usage", 409)]
[InlineData("excess", 409)]
[InlineData("stale", 409)]
public async Task Administrative_erasure_refuses_ineligible_targets_without_mutation(string scenario, int status)
{
var ct = TestContext.Current.CancellationToken;
using var provider = NewProvider(o => o.DefaultLimit = 1000m);
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
if (scenario != "missing") db.Users.Add(new ApplicationUser
{
Id = "alice", UserName = "alice", Email = "alice@example.test",
WithdrawalRequestedAt = scenario == "withdrawn" ? DateTimeOffset.UtcNow : null
});
if (scenario != "no-usage") db.ResourceUsageRecords.Add(new()
{
UserId = "alice", CpuSeconds = scenario == "below-limit" ? 999m : 1000m
});
await db.SaveChangesAsync(ct);
var service = scope.ServiceProvider.GetRequiredService<IResourceUsageService>();
var error = await Assert.ThrowsAsync<ResourceUsageAdjustmentException>(() => service.EraseAsync("alice", "admin",
new() { Points = scenario == "excess" ? 1001m : 100m, ExpectedCredits = scenario == "stale" ? 1m : 0m }, ct));
Assert.Equal(status, error.StatusCode);
Assert.All(db.ResourceUsageRecords, r => Assert.Equal(0m, r.CreditPoints));
}
[Fact]
public async Task Concurrent_confirmations_apply_once_and_do_not_lose_usage_updates()
{
var ct = TestContext.Current.CancellationToken;
using var provider = NewProvider(o => o.DefaultLimit = 1000m);
using (var seed = provider.CreateScope())
{
var db = seed.ServiceProvider.GetRequiredService<ApplicationDbContext>();
db.Users.Add(new ApplicationUser { Id = "alice", UserName = "alice", Email = "alice@example.test" });
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 2000m, cancellationToken: ct);
}
var results = await Task.WhenAll(Enumerable.Range(0, 10).Select(async _ =>
{
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 1m, cancellationToken: ct);
try
{
await scope.ServiceProvider.GetRequiredService<IResourceUsageService>()
.EraseAsync("alice", "admin", new() { Points = 100m, ExpectedCredits = 0m }, ct);
return true;
}
catch (ResourceUsageAdjustmentException error) when (error.StatusCode == 409) { return false; }
}));
Assert.Single(results, applied => applied);
using var final = provider.CreateScope();
var summary = await final.ServiceProvider.GetRequiredService<IResourceUsageService>().GetCurrentAsync("alice", "alice", ct);
Assert.Equal(1910m, summary.Consumption);
Assert.Equal(100m, summary.AppliedCredits);
}
private static ServiceProvider NewProvider(Action<ResourceUsageOptions>? configure = null)
{
var services = new ServiceCollection();
var databaseName = Guid.NewGuid().ToString();
services.AddLogging();
services.AddDbContext<ApplicationDbContext>(o => o.UseInMemoryDatabase(databaseName));
services.AddResourceUsage(new ConfigurationBuilder().Build());
services.Configure<ResourceUsageOptions>(o =>
{
o.ApiCallWeight = 0.02m;
o.CpuSecondWeight = 1m;
o.BandwidthMbWeight = 0.1m;
o.StorageMbWeight = 0.3m;
o.DefaultLimit = 10000m;
});
services.Configure<SiteSettings>(o => o.Authority = "https://instance.example");
if (configure is not null) services.Configure(configure);
return services.BuildServiceProvider();
}
private static DefaultHttpContext NewContext(IServiceProvider services)
=> new()
{
RequestServices = services,
User = new ClaimsPrincipal(new ClaimsIdentity([new Claim("sub", "alice")], "Bearer")),
Response = { Body = new MemoryStream() }
};
[Fact]
public async Task Instrumented_storage_admits_before_writing_and_refunds_disk_under_the_same_lock()
{
using var provider = NewProvider(o => o.DefaultLimit = 0.4m);
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
var ct = TestContext.Current.CancellationToken;
const long mib = 1024 * 1024;
var user = new ApplicationUser { Id = "alice", UserName = "alice", Email = "alice@example.test" };
db.Users.Add(user);
await db.SaveChangesAsync(ct);
var policy = scope.ServiceProvider.GetRequiredService<IOptions<ResourceUsageOptions>>().Value;
await ResourceUsageTracker.RecordStorageAsync(db, user.Id, user.UserName!, "podcast/test", mib, ct,
write: () => { user.DiskUsage += mib; return Task.CompletedTask; }, policy: policy, bandwidthMb: 1m);
Assert.Equal(mib, user.DiskUsage);
Assert.Equal(mib, (await db.ResourceStorageRecords.SingleAsync(ct)).Bytes);
var wrote = false;
await Assert.ThrowsAsync<ResourceUsageLimitException>(() =>
ResourceUsageTracker.RecordStorageAsync(db, user.Id, user.UserName!, "podcast/test", 2 * mib, ct,
write: () => { wrote = true; return Task.CompletedTask; }, policy: policy, bandwidthMb: 1m));
Assert.False(wrote);
Assert.Equal(mib, (await db.ResourceStorageRecords.SingleAsync(ct)).Bytes);
await ResourceUsageTracker.RecordStorageAsync(db, user.Id, user.UserName!, "podcast/test", 0, ct,
write: () => { user.DiskUsage -= mib; return Task.CompletedTask; });
Assert.Equal(0, user.DiskUsage);
Assert.Empty(db.ResourceStorageRecords);
var usage = await db.ResourceUsageRecords.SingleAsync(ct);
Assert.Equal(0m, usage.StorageMb);
Assert.Equal(1m, usage.BandwidthMb);
}
[Fact]
public void Configured_formula_uses_exact_decimal_points()
{
var rule = new ResourceUsageOptions
{
ApiCallWeight = 0.2m, CpuSecondWeight = 0.1m,
BandwidthMbWeight = 0.05m, StorageMbWeight = 0.5m, DefaultLimit = 1000m
};
Assert.Equal(29.34m, rule.Calculate(12.5m, 3.2m, 18.4m, 51.2m));
Assert.Equal(0m, rule.Calculate(0m, 0m, 0m, 0m));
Assert.Equal(0.002m, rule.Calculate(0.01m, 0m, 0m, 0m));
Assert.Equal(1000m, rule.GetLimit("unknown-user"));
}
[Fact]
public async Task Summary_uses_latest_snapshot_and_individual_limit_without_summing_snapshots()
{
using var provider = NewProvider(o => o.UserLimits["alice"] = 100m);
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
db.ResourceUsageRecords.AddRange(
new ResourceUsageRecord { UserId = "alice", UserName = "old", CpuSeconds = 500m, RecordedAtUtc = DateTime.UtcNow.AddDays(-1) },
new ResourceUsageRecord { UserId = "alice", UserName = "alice", ApiCalls = 10m, CpuSeconds = 3m, BandwidthMb = 2m, StorageMb = 4m });
await db.SaveChangesAsync();
var usage = scope.ServiceProvider.GetRequiredService<IResourceUsageService>();
var summary = await usage.GetCurrentAsync("alice", "alice", TestContext.Current.CancellationToken);
Assert.Equal(4.6m, summary.Consumption);
Assert.Equal(100m, summary.ConsumptionLimit);
Assert.Equal(95.4m, summary.RemainingConsumption);
Assert.False(summary.IsQuotaReached);
var overview = await usage.GetOverviewAsync(TestContext.Current.CancellationToken);
Assert.Single(overview);
Assert.Equal(summary.Consumption, overview[0].Consumption);
}
[Fact]
public async Task Concurrent_admissions_allow_exact_limit_without_lost_updates_or_duplicate_snapshots()
{
using var provider = NewProvider(o => o.DefaultLimit = 0.04m);
var results = await Task.WhenAll(Enumerable.Range(0, 20).Select(async _ =>
{
using var scope = provider.CreateScope();
return await scope.ServiceProvider.GetRequiredService<IResourceUsageService>()
.TryAdmitAsync("alice", "alice", 1m, 0m, 0, TestContext.Current.CancellationToken);
}));
Assert.Equal(2, results.Count(accepted => accepted));
using var finalScope = provider.CreateScope();
var db = finalScope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
var record = Assert.Single(await db.ResourceUsageRecords.ToListAsync(TestContext.Current.CancellationToken));
Assert.Equal(2m, record.ApiCalls);
var summary = await finalScope.ServiceProvider.GetRequiredService<IResourceUsageService>()
.GetCurrentAsync("alice", "alice", TestContext.Current.CancellationToken);
Assert.True(summary.IsQuotaReached);
Assert.Equal(0m, summary.RemainingConsumption);
}
[Fact]
public async Task Concurrent_accounting_preserves_all_resource_deltas()
{
using var provider = NewProvider();
await Task.WhenAll(Enumerable.Range(0, 20).Select(async _ =>
{
using var scope = provider.CreateScope();
await ResourceUsageTracker.RecordAsync(
scope.ServiceProvider.GetRequiredService<ApplicationDbContext>(),
"alice", "alice", cpuSeconds: 0.1m, apiCalls: 1m,
storageBytes: 1048576, bandwidthMb: 0.5m);
}));
using var finalScope = provider.CreateScope();
var record = Assert.Single(await finalScope.ServiceProvider.GetRequiredService<ApplicationDbContext>()
.ResourceUsageRecords.ToListAsync(TestContext.Current.CancellationToken));
Assert.Equal(20m, record.ApiCalls);
Assert.Equal(2m, record.CpuSeconds);
Assert.Equal(20m, record.StorageMb);
Assert.Equal(10m, record.BandwidthMb);
}
[Fact]
public async Task Known_ingress_or_storage_cost_is_refused_before_consumption()
{
using var provider = NewProvider(o => o.DefaultLimit = 0.11m);
using var scope = provider.CreateScope();
var usage = scope.ServiceProvider.GetRequiredService<IResourceUsageService>();
Assert.False(await usage.TryAdmitAsync("alice", "alice", 1m, 1m, 0, TestContext.Current.CancellationToken));
Assert.False(await usage.TryAdmitAsync("alice", "alice", 0m, 0m, 1048576, TestContext.Current.CancellationToken));
Assert.Empty(await scope.ServiceProvider.GetRequiredService<ApplicationDbContext>()
.ResourceUsageRecords.ToListAsync(TestContext.Current.CancellationToken));
}
[Fact]
public async Task Observed_cost_can_exceed_limit_then_new_operations_are_refused_until_limit_is_increased()
{
using var provider = NewProvider(o => o.DefaultLimit = 1m);
using var scope = provider.CreateScope();
var usage = scope.ServiceProvider.GetRequiredService<IResourceUsageService>();
Assert.True(await usage.TryAdmitAsync("alice", "alice", 1m, 0m, 0, TestContext.Current.CancellationToken));
await ResourceUsageTracker.RecordAsync(scope.ServiceProvider.GetRequiredService<ApplicationDbContext>(),
"alice", "alice", cpuSeconds: 2m, cancellationToken: TestContext.Current.CancellationToken);
Assert.False(await usage.TryAdmitAsync("alice", "alice", 1m, 0m, 0, TestContext.Current.CancellationToken));
var summary = await usage.GetCurrentAsync("alice", "alice", TestContext.Current.CancellationToken);
Assert.Equal(2.02m, summary.Consumption);
Assert.Equal(0m, summary.RemainingConsumption);
Assert.True(summary.IsQuotaReached);
var raised = new ResourceUsageService(scope.ServiceProvider.GetRequiredService<ApplicationDbContext>(),
Options.Create(new ResourceUsageOptions
{
DefaultLimit = 3m, ApiCallWeight = 0.02m, CpuSecondWeight = 1m,
BandwidthMbWeight = 0.1m, StorageMbWeight = 0.3m
}));
Assert.True(await raised.TryAdmitAsync("alice", "alice", 1m, 0m, 0, TestContext.Current.CancellationToken));
}
[Theory]
[InlineData(false)]
[InlineData(true)]
public async Task Middleware_counts_streamed_bodies_once_with_or_without_declared_ingress(bool declared)
{
using var provider = NewProvider();
using var scope = provider.CreateScope();
var context = NewContext(scope.ServiceProvider);
using var originalRequest = new MemoryStream(new byte[1048576]);
using var originalResponse = new MemoryStream();
context.Request.Body = originalRequest;
context.Response.Body = originalResponse;
if (declared) context.Request.ContentLength = 1048576;
var middleware = new ResourceUsageTelemetryMiddleware(
async ctx =>
{
await ctx.Request.Body.CopyToAsync(Stream.Null);
await ctx.Response.BodyWriter.WriteAsync(new byte[2 * 1048576]);
},
provider.GetRequiredService<IServiceScopeFactory>(),
NullLogger<ResourceUsageTelemetryMiddleware>.Instance);
await middleware.InvokeAsync(context, scope.ServiceProvider.GetRequiredService<IResourceUsageService>());
Assert.Same(originalRequest, context.Request.Body);
Assert.Same(originalResponse, context.Response.Body);
Assert.True(originalRequest.CanRead);
Assert.True(originalResponse.CanWrite);
var summary = await scope.ServiceProvider.GetRequiredService<IResourceUsageService>()
.GetCurrentAsync("alice", "alice", TestContext.Current.CancellationToken);
Assert.Equal(1m, summary.ApiCalls);
Assert.Equal(3m, summary.BandwidthMb);
Assert.Equal(0.32m, summary.Consumption);
}
[Fact]
public async Task Failed_execution_is_accounted_and_original_streams_are_restored()
{
using var provider = NewProvider();
using var scope = provider.CreateScope();
var context = NewContext(scope.ServiceProvider);
var originalResponse = context.Response.Body;
var middleware = new ResourceUsageTelemetryMiddleware(
async ctx =>
{
await ctx.Response.Body.WriteAsync(new byte[1048576]);
throw new InvalidOperationException("Expected test failure");
}, provider.GetRequiredService<IServiceScopeFactory>(),
NullLogger<ResourceUsageTelemetryMiddleware>.Instance);
await Assert.ThrowsAsync<InvalidOperationException>(() =>
middleware.InvokeAsync(context, scope.ServiceProvider.GetRequiredService<IResourceUsageService>()));
Assert.Same(originalResponse, context.Response.Body);
var summary = await scope.ServiceProvider.GetRequiredService<IResourceUsageService>()
.GetCurrentAsync("alice", "alice", TestContext.Current.CancellationToken);
Assert.Equal(0.12m, summary.Consumption);
}
[Theory]
[InlineData("/login", false)]
[InlineData("/refresh", false)]
[InlineData("/logout", false)]
[InlineData("/api/v1/resource-usage/me", true)]
public async Task Exempt_endpoints_remain_available_without_consumption(string path, bool metadata)
{
using var provider = NewProvider(o => o.DefaultLimit = 0.01m);
using var scope = provider.CreateScope();
var context = NewContext(scope.ServiceProvider);
context.Request.Path = path;
if (metadata)
context.SetEndpoint(new Endpoint(_ => Task.CompletedTask,
new EndpointMetadataCollection(new ResourceUsageExemptAttribute()), "usage"));
var ran = false;
var middleware = new ResourceUsageTelemetryMiddleware(
_ => { ran = true; return Task.CompletedTask; },
provider.GetRequiredService<IServiceScopeFactory>(),
NullLogger<ResourceUsageTelemetryMiddleware>.Instance);
await middleware.InvokeAsync(context, scope.ServiceProvider.GetRequiredService<IResourceUsageService>());
Assert.True(ran);
Assert.Empty(await scope.ServiceProvider.GetRequiredService<ApplicationDbContext>()
.ResourceUsageRecords.ToListAsync(TestContext.Current.CancellationToken));
}
[Fact]
public async Task Rejected_request_returns_problem_details_without_running_or_charging()
{
using var provider = NewProvider(o => o.DefaultLimit = 0.01m);
using var scope = provider.CreateScope();
var context = NewContext(scope.ServiceProvider);
var middleware = new ResourceUsageTelemetryMiddleware(
_ => throw new InvalidOperationException("Must not run"),
provider.GetRequiredService<IServiceScopeFactory>(),
NullLogger<ResourceUsageTelemetryMiddleware>.Instance);
await middleware.InvokeAsync(context, scope.ServiceProvider.GetRequiredService<IResourceUsageService>());
Assert.Equal(429, context.Response.StatusCode);
Assert.StartsWith("application/problem+json", context.Response.ContentType);
context.Response.Body.Position = 0;
using var reader = new StreamReader(context.Response.Body);
var payload = await reader.ReadToEndAsync(TestContext.Current.CancellationToken);
Assert.Contains("resource_quota_exceeded", payload);
Assert.Contains("https://instance.example/Home/CGU", payload);
Assert.Empty(await scope.ServiceProvider.GetRequiredService<ApplicationDbContext>()
.ResourceUsageRecords.ToListAsync(TestContext.Current.CancellationToken));
}
[Fact]
public async Task Administrator_request_bypasses_quota_rejection_and_remains_accounted()
{
using var provider = NewProvider(o => o.DefaultLimit = 0.01m);
using var scope = provider.CreateScope();
var context = NewContext(scope.ServiceProvider);
context.User.AddIdentity(new ClaimsIdentity([
new Claim("http://schemas.microsoft.com/ws/2008/06/identity/claims/role", "Administrator")
], "Bearer"));
var ran = false;
var middleware = new ResourceUsageTelemetryMiddleware(
_ => { ran = true; return Task.CompletedTask; },
provider.GetRequiredService<IServiceScopeFactory>(),
NullLogger<ResourceUsageTelemetryMiddleware>.Instance);
await middleware.InvokeAsync(context, scope.ServiceProvider.GetRequiredService<IResourceUsageService>());
Assert.True(ran);
Assert.Equal(StatusCodes.Status200OK, context.Response.StatusCode);
var summary = await scope.ServiceProvider.GetRequiredService<IResourceUsageService>()
.GetCurrentAsync("alice", "alice", TestContext.Current.CancellationToken);
Assert.Equal(1m, summary.ApiCalls);
Assert.True(summary.IsQuotaReached);
}
[Fact]
public async Task Tracked_storage_replacement_and_deletion_refund_only_their_original_volume()
{
using var provider = NewProvider();
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
var ct = TestContext.Current.CancellationToken;
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 5m, storageBytes: 1048576, cancellationToken: ct);
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "personal/file", 2 * 1048576, ct);
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "personal/file", 1048576, ct);
var record = await db.ResourceUsageRecords.SingleAsync(ct);
Assert.Equal(2m, record.StorageMb);
var usage = scope.ServiceProvider.GetRequiredService<IResourceUsageService>();
Assert.Equal(5.6m, (await usage.GetCurrentAsync("alice", "alice", ct)).Consumption);
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "personal/legacy", 0, ct);
Assert.Equal(2m, record.StorageMb);
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "personal/file", 0, ct);
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "personal/file", 0, ct);
Assert.Equal(1m, record.StorageMb);
Assert.Equal(5m, record.CpuSeconds);
Assert.Equal(5.3m, (await usage.GetCurrentAsync("alice", "alice", ct)).Consumption);
Assert.Empty(await db.ResourceStorageRecords.ToListAsync(ct));
}
[Fact]
public async Task Concurrent_deletions_do_not_refund_the_same_receipt_twice()
{
using var provider = NewProvider();
var ct = TestContext.Current.CancellationToken;
using (var setup = provider.CreateScope())
{
var db = setup.ServiceProvider.GetRequiredService<ApplicationDbContext>();
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "file", 1048576, ct);
await ResourceUsageTracker.RecordAsync(db, "alice", "alice", storageBytes: 1048576, cancellationToken: ct);
}
await Task.WhenAll(Enumerable.Range(0, 5).Select(async _ =>
{
using var scope = provider.CreateScope();
await ResourceUsageTracker.RecordStorageAsync(scope.ServiceProvider.GetRequiredService<ApplicationDbContext>(),
"alice", "alice", "file", 0, ct);
}));
using var verify = provider.CreateScope();
Assert.Equal(1m, (await verify.ServiceProvider.GetRequiredService<ApplicationDbContext>()
.ResourceUsageRecords.SingleAsync(ct)).StorageMb);
}
[Fact]
public async Task Repeated_pdf_storage_accounting_is_idempotent_and_renamed_files_remain_refundable()
{
using var provider = NewProvider();
using var scope = provider.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
var ct = TestContext.Current.CancellationToken;
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "pdf/file", 1048576, ct);
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "pdf/file", 1048576, ct);
await ResourceUsageTracker.MoveStorageAsync(db, "alice", "pdf", "renamed", ct);
Assert.Equal("renamed/file", (await db.ResourceStorageRecords.SingleAsync(ct)).Path);
await ResourceUsageTracker.RecordStorageAsync(db, "alice", "alice", "renamed/file", 0, ct);
Assert.Equal(0m, (await db.ResourceUsageRecords.SingleAsync(ct)).StorageMb);
}
[Fact]
public async Task Relief_request_runs_at_the_limit_but_still_counts_api_and_transfer_costs()
{
using var provider = NewProvider(o => o.DefaultLimit = 0.01m);
using var scope = provider.CreateScope();
var context = NewContext(scope.ServiceProvider);
context.SetEndpoint(new Endpoint(_ => Task.CompletedTask,
new EndpointMetadataCollection(new ResourceUsageReliefAttribute()), "delete"));
var ran = false;
var middleware = new ResourceUsageTelemetryMiddleware(
async ctx =>
{
ran = true;
await ctx.Response.Body.WriteAsync(new byte[1048576], TestContext.Current.CancellationToken);
},
provider.GetRequiredService<IServiceScopeFactory>(),
NullLogger<ResourceUsageTelemetryMiddleware>.Instance);
await middleware.InvokeAsync(context, scope.ServiceProvider.GetRequiredService<IResourceUsageService>());
Assert.True(ran);
var record = await scope.ServiceProvider.GetRequiredService<ApplicationDbContext>()
.ResourceUsageRecords.SingleAsync(TestContext.Current.CancellationToken);
Assert.Equal(1m, record.ApiCalls);
Assert.Equal(1m, record.BandwidthMb);
}
[Fact]
public async Task Negative_counter_deltas_are_explicitly_rejected()
{
using var provider = NewProvider();
using var scope = provider.CreateScope();
await Assert.ThrowsAsync<ArgumentOutOfRangeException>(() =>
ResourceUsageTracker.RecordAsync(scope.ServiceProvider.GetRequiredService<ApplicationDbContext>(),
"alice", "alice", cpuSeconds: -1m, cancellationToken: TestContext.Current.CancellationToken));
}
[Theory]
[InlineData("ResourceUsage:ApiCallWeight", "0")]
[InlineData("ResourceUsage:BandwidthMbWeight", "-1")]
[InlineData("ResourceUsage:DefaultLimit", "0")]
[InlineData("ResourceUsage:UserLimits:alice", "-1")]
public void Invalid_configuration_is_rejected(string key, string value)
{
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary<string, string?> { [key] = value }).Build();
var services = new ServiceCollection().AddResourceUsage(configuration);
using var provider = services.BuildServiceProvider();
Assert.Throws<OptionsValidationException>(() =>
provider.GetRequiredService<IOptions<ResourceUsageOptions>>().Value);
}
}