> Cancel(Guid id, CancellationToken ct)
+ {
+ var subscription = (await subscriptions.GetAllAsync(User.GetUserId(), ct)).SingleOrDefault(s => s.Id == id);
+ if (subscription is null) return NotFound();
+ await subscriptions.CancelAsync(subscription, ct);
+ return await Get(ct);
+ }
+
+ // A browser return is deliberately anonymous and never grants credit.
+ [AllowAnonymous, HttpGet("return")]
+ public ContentResult Return() => Content(
+ "PostIt - PayPal" +
+ "Retour dans PostIt
Revenez dans PostIt et appuyez sur Actualiser pour verifier " +
+ "votre abonnement et les paiements confirmes. Ce retour ne confirme aucun paiement.
", "text/html");
+
+ private static ResourceSubscriptionResponse Response(ResourceSubscription s)
+ => new(s.Id, s.Pack, s.State, s.PriceIncludingTax, s.MonthlyPoints, s.NextBillingAt);
+
+ public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+ {
+ var executed = await next();
+ if (executed.Exception is not SubscriptionOperationException error) return;
+ logger.LogWarning(error, "Resource subscription API operation failed");
+ executed.ExceptionHandled = true;
+ executed.Result = new JsonResult(new ProblemDetails
+ {
+ Status = error.StatusCode,
+ Title = error.Message,
+ Instance = Request.Path
+ })
+ {
+ StatusCode = error.StatusCode,
+ ContentType = "application/problem+json"
+ };
+ }
+}
diff --git a/src/Yavsc.Org/Services/ResourceSubscriptionService.cs b/src/Yavsc.Org/Services/ResourceSubscriptionService.cs
index 9c81ceb60..9ec9eea2f 100644
--- a/src/Yavsc.Org/Services/ResourceSubscriptionService.cs
+++ b/src/Yavsc.Org/Services/ResourceSubscriptionService.cs
@@ -16,12 +16,37 @@ public interface IResourceSubscriptionService
Task PrepareAsync(string userId, string pack, CancellationToken ct);
Task BindAsync(ResourceSubscription subscription, PayPalSubscriptionDetails remote, CancellationToken ct);
Task ReconcileAsync(ResourceSubscription subscription, CancellationToken ct);
+ Task CheckoutAsync(ResourceSubscription subscription, string returnUrl, string cancelUrl, CancellationToken ct);
+ Task CancelAsync(ResourceSubscription subscription, CancellationToken ct);
}
public sealed class ResourceSubscriptionService(ApplicationDbContext db, IPayPalSubscriptionGateway paypal,
IOptions options, IOptions usageOptions,
TimeProvider clock) : IResourceSubscriptionService
{
+ public async Task CheckoutAsync(ResourceSubscription subscription, string returnUrl, string cancelUrl, CancellationToken ct)
+ {
+ var remote = subscription.PayPalId is null
+ ? await paypal.CreateAsync(subscription, returnUrl, cancelUrl, ct)
+ : await paypal.GetAsync(subscription.PayPalId, ct);
+ await BindAsync(subscription, remote, ct);
+ if (remote.State == "APPROVAL_PENDING")
+ return remote.ApprovalUrl
+ ?? throw new SubscriptionOperationException(502, "Le lien d'approbation PayPal est manquant.");
+ await ReconcileAsync(subscription, ct);
+ return null;
+ }
+
+ public async Task CancelAsync(ResourceSubscription subscription, CancellationToken ct)
+ {
+ if (subscription.PayPalId is null)
+ throw new SubscriptionOperationException(409, "Reprenez la creation PayPal avant de resilier cet abonnement.");
+ await ReconcileAsync(subscription, ct);
+ if (subscription.State is not ("CANCELLED" or "EXPIRED"))
+ await paypal.CancelAsync(subscription.PayPalId, ct);
+ await ReconcileAsync(subscription, ct);
+ }
+
public Task> GetAllAsync(string userId, CancellationToken ct)
=> db.ResourceSubscriptions.Where(s => s.UserId == userId).OrderByDescending(s => s.CreatedAt).ToListAsync(ct);
diff --git a/src/Yavsc.Org/resource-subscriptions.http b/src/Yavsc.Org/resource-subscriptions.http
new file mode 100644
index 000000000..881c317ab
--- /dev/null
+++ b/src/Yavsc.Org/resource-subscriptions.http
@@ -0,0 +1,32 @@
+@baseUrl = https://localhost:5001
+@token = replace-with-access-token
+@subscriptionId = 00000000-0000-0000-0000-000000000000
+
+### Offers, own subscriptions and balance (authority host, not business API host)
+GET {{baseUrl}}/api/v1/resource-subscriptions
+Authorization: Bearer {{token}}
+
+### Prepare or resume approval; server owns all prices and PayPal plan identifiers
+POST {{baseUrl}}/api/v1/resource-subscriptions
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+{"pack":"Discovery"}
+
+### Reconcile verified payments after returning from PayPal
+POST {{baseUrl}}/api/v1/resource-subscriptions/refresh
+Authorization: Bearer {{token}}
+
+### Cancel own subscription; unknown or foreign identifiers return 404
+POST {{baseUrl}}/api/v1/resource-subscriptions/{{subscriptionId}}/cancel
+Authorization: Bearer {{token}}
+
+### Browser landing page (anonymous, never grants credit)
+GET {{baseUrl}}/api/v1/resource-subscriptions/return
+
+### Invalid pack: 400
+POST {{baseUrl}}/api/v1/resource-subscriptions
+Authorization: Bearer {{token}}
+Content-Type: application/json
+
+{"pack":"Unknown"}
diff --git a/src/Yavsc.Server/Helpers/ResourceUsageService.cs b/src/Yavsc.Server/Helpers/ResourceUsageService.cs
index 10ccdd27e..2445a0db1 100644
--- a/src/Yavsc.Server/Helpers/ResourceUsageService.cs
+++ b/src/Yavsc.Server/Helpers/ResourceUsageService.cs
@@ -3,6 +3,8 @@ using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Logging;
+using Microsoft.EntityFrameworkCore.Infrastructure;
using Yavsc.Abstract.Resources;
using Yavsc.Models;
using Yavsc.Settings;
@@ -15,6 +17,13 @@ public interface IResourceUsageService
Task> GetOverviewAsync(CancellationToken cancellationToken);
Task TryAdmitAsync(string userId, string userName, decimal apiCalls, decimal bandwidthMb,
long anticipatedStorageBytes, CancellationToken cancellationToken);
+ Task EraseAsync(string userId, string actorUserId,
+ EraseResourceUsageRequest request, CancellationToken cancellationToken);
+}
+
+public sealed class ResourceUsageAdjustmentException(int statusCode, string message) : InvalidOperationException(message)
+{
+ public int StatusCode { get; } = statusCode;
}
public sealed class ResourceUsageService(
@@ -51,6 +60,51 @@ public sealed class ResourceUsageService(
policy: _options, anticipatedStorageBytes: anticipatedStorageBytes,
cancellationToken: cancellationToken) is not null;
+ public Task EraseAsync(string userId, string actorUserId,
+ EraseResourceUsageRequest request, CancellationToken cancellationToken)
+ {
+ ArgumentException.ThrowIfNullOrWhiteSpace(userId);
+ ArgumentException.ThrowIfNullOrWhiteSpace(actorUserId);
+ const decimal maximum = 99999999999999999999.99999999m;
+ if (request.Points <= 0m || request.Points > maximum ||
+ decimal.Round(request.Points, 8) != request.Points ||
+ request.ExpectedCredits < 0m || request.ExpectedCredits > maximum ||
+ decimal.Round(request.ExpectedCredits, 8) != request.ExpectedCredits)
+ throw new ResourceUsageAdjustmentException(400, "Le montant doit être positif, avec au plus huit décimales.");
+
+ return ResourceUsageTracker.WithUserLockAsync(dbContext, userId, async () =>
+ {
+ var user = await dbContext.Users.AsNoTracking().SingleOrDefaultAsync(u => u.Id == userId, cancellationToken)
+ ?? throw new ResourceUsageAdjustmentException(404, "Utilisateur introuvable.");
+ if (user.WithdrawalRequestedAt is not null)
+ throw new ResourceUsageAdjustmentException(409, "Ce compte est retiré ou en cours de retrait.");
+ var record = await dbContext.ResourceUsageRecords.Where(r => r.UserId == userId)
+ .OrderByDescending(r => r.RecordedAtUtc).ThenByDescending(r => r.Id)
+ .FirstOrDefaultAsync(cancellationToken);
+ if (record is null)
+ throw new ResourceUsageAdjustmentException(409, "Cet utilisateur n’a pas atteint sa limite.");
+ await dbContext.Entry(record).ReloadAsync(cancellationToken);
+ if (record.CreditPoints != request.ExpectedCredits)
+ throw new ResourceUsageAdjustmentException(409, "Les crédits ont changé. Actualisez puis confirmez à nouveau.");
+ var current = ToSummary(record, user);
+ if (!current.IsQuotaReached)
+ throw new ResourceUsageAdjustmentException(409, "Cet utilisateur n’a pas atteint sa limite.");
+ if (request.Points > current.Consumption)
+ throw new ResourceUsageAdjustmentException(409, "Le montant dépasse les points actuellement consommés.");
+ if (request.Points > maximum - record.CreditPoints)
+ throw new ResourceUsageAdjustmentException(409, "La capacité du compteur de crédits serait dépassée.");
+ record.CreditPoints += request.Points;
+ record.RecordedAtUtc = (clock ?? TimeProvider.System).GetUtcNow().UtcDateTime;
+ record.DateModified = record.RecordedAtUtc;
+ record.UserModified = actorUserId;
+ await dbContext.SaveChangesAsync(actorUserId, cancellationToken);
+ dbContext.GetService().CreateLogger()
+ .LogInformation("Administrator {ActorUserId} erased {Points} consumption points for {UserId}; remaining consumption {Consumption}",
+ actorUserId, request.Points, userId, current.Consumption - request.Points);
+ return ToSummary(record, user);
+ }, cancellationToken);
+ }
+
private ResourceUsageSummary ToSummary(ResourceUsageRecord record, ApplicationUser? user)
{
var gross = _options.Calculate(record.ApiCalls, record.CpuSeconds, record.BandwidthMb, record.StorageMb);
diff --git a/src/test/Yavsc.Api.Tests/ResourceUsageReliefApiTests.cs b/src/test/Yavsc.Api.Tests/ResourceUsageReliefApiTests.cs
new file mode 100644
index 000000000..1177948a3
--- /dev/null
+++ b/src/test/Yavsc.Api.Tests/ResourceUsageReliefApiTests.cs
@@ -0,0 +1,155 @@
+using System.Net;
+using System.Net.Http.Headers;
+using System.Net.Http.Json;
+using System.Security.Claims;
+using System.Text;
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Yavsc.Abstract.Resources;
+using Yavsc.Api.Test.Fixtures;
+using Yavsc.Models;
+using Yavsc.Server.Helpers;
+using Yavsc.Tests.Shared;
+
+namespace Yavsc.Api.Test;
+
+[Collection("Yavsc Api")]
+public sealed class ResourceUsageReliefApiTests(ApiWebServerFixture fixture) : IClassFixture
+{
+ private const string Root = "/api/v1/resource-usage/admin";
+ private CancellationToken Ct => TestContext.Current.CancellationToken;
+
+ private HttpClient Client(string? role = "Administrator", string subject = "relief-admin")
+ {
+ var http = new HttpClient(new HttpClientHandler { ServerCertificateCustomValidationCallback = (_, _, _, _) => true })
+ { BaseAddress = new Uri(fixture.BaseAddress) };
+ if (role is not null)
+ http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer",
+ TestTokenIssuer.Issue(subject, "api", extraClaims: [new Claim(Yavsc.Constants.RoleClaimType, role)]));
+ return http;
+ }
+
+ private async Task SeedAsync(decimal cpu = 10000m, bool withdrawn = false)
+ {
+ var id = "relief-" + Guid.NewGuid().ToString("N");
+ using var scope = fixture.Services.CreateScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+ db.Users.Add(new ApplicationUser
+ {
+ Id = id, UserName = id, NormalizedUserName = id.ToUpperInvariant(),
+ Email = id + "@example.test", WithdrawalRequestedAt = withdrawn ? DateTimeOffset.UtcNow : null
+ });
+ await db.SaveChangesAsync(Ct);
+ db.ResourceUsageRecords.Add(new ResourceUsageRecord { UserId = id, UserName = id, CpuSeconds = cpu });
+ await db.SaveChangesAsync(Ct);
+ return id;
+ }
+
+ [Theory]
+ [InlineData(null, HttpStatusCode.Unauthorized)]
+ [InlineData("Moderator", HttpStatusCode.Forbidden)]
+ [InlineData("Performer", HttpStatusCode.Forbidden)]
+ [InlineData("administrator", HttpStatusCode.Forbidden)]
+ public async Task Only_administrators_can_erase_points(string? role, HttpStatusCode expected)
+ {
+ var id = await SeedAsync();
+ using var client = Client(role);
+ using var response = await client.PostAsJsonAsync($"{Root}/{id}/erase", new EraseResourceUsageRequest { Points = 100m }, Ct);
+ Assert.Equal(expected, response.StatusCode);
+ using var scope = fixture.Services.CreateScope();
+ Assert.Equal(0m, (await scope.ServiceProvider.GetRequiredService()
+ .ResourceUsageRecords.SingleAsync(r => r.UserId == id, Ct)).CreditPoints);
+ }
+
+ [Fact]
+ public async Task Erasure_works_at_administrator_quota_preserves_counters_and_unblocks_user()
+ {
+ var id = await SeedAsync();
+ using (var seed = fixture.Services.CreateScope())
+ await ResourceUsageTracker.RecordAsync(seed.ServiceProvider.GetRequiredService(),
+ "relief-admin-exhausted", "Admin", cpuSeconds: 20000m, cancellationToken: Ct);
+ using var admin = Client(subject: "relief-admin-exhausted");
+ using var target = Client("Performer", id);
+ Assert.Equal(HttpStatusCode.TooManyRequests, (await target.GetAsync("/api/v1/notifications/me", Ct)).StatusCode);
+ var request = new EraseResourceUsageRequest { Points = 200.12545678m, ExpectedCredits = 0m };
+ using var response = await admin.PostAsJsonAsync($"{Root}/{id}/erase", request, Ct);
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+ Assert.True(response.Headers.CacheControl?.NoStore);
+ var summary = await response.Content.ReadFromJsonAsync(Ct);
+ Assert.NotNull(summary);
+ Assert.Equal(799.87454322m, summary.Consumption);
+ Assert.Equal(0m, summary.CreditBalance);
+ Assert.False(summary.IsQuotaReached);
+ Assert.Equal(HttpStatusCode.OK, (await target.GetAsync("/api/v1/notifications/me", Ct)).StatusCode);
+ using var scope = fixture.Services.CreateScope();
+ var db = scope.ServiceProvider.GetRequiredService();
+ var record = await db.ResourceUsageRecords.SingleAsync(r => r.UserId == id, Ct);
+ Assert.Equal(10000m, record.CpuSeconds);
+ Assert.Equal(request.Points, record.CreditPoints);
+ var actor = await db.ResourceUsageRecords.SingleAsync(r => r.UserId == "relief-admin-exhausted", Ct);
+ Assert.Equal(0m, actor.ApiCalls);
+ Assert.Equal(0m, actor.BandwidthMb);
+ }
+
+ [Theory]
+ [InlineData("0")]
+ [InlineData("-1")]
+ [InlineData("0.000000001")]
+ [InlineData("100000000000000000000")]
+ public async Task Invalid_amount_returns_problem_details_and_does_not_change_credits(string points)
+ {
+ var id = await SeedAsync();
+ using var client = Client();
+ using var body = new StringContent("{\"points\":" + points + ",\"expectedCredits\":0}", Encoding.UTF8, "application/json");
+ using var response = await client.PostAsync($"{Root}/{id}/erase", body, Ct);
+ Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+ Assert.Equal("application/problem+json", response.Content.Headers.ContentType?.MediaType);
+ using var scope = fixture.Services.CreateScope();
+ Assert.Equal(0m, (await scope.ServiceProvider.GetRequiredService()
+ .ResourceUsageRecords.SingleAsync(r => r.UserId == id, Ct)).CreditPoints);
+ }
+
+ [Theory]
+ [InlineData("excess", HttpStatusCode.Conflict)]
+ [InlineData("stale", HttpStatusCode.Conflict)]
+ [InlineData("below", HttpStatusCode.Conflict)]
+ [InlineData("withdrawn", HttpStatusCode.Conflict)]
+ [InlineData("missing", HttpStatusCode.NotFound)]
+ public async Task Conflicts_and_unknown_users_do_not_grant_credit(string scenario, HttpStatusCode status)
+ {
+ var id = scenario == "missing" ? "relief-missing-user" :
+ await SeedAsync(scenario == "below" ? 100m : 10000m, scenario == "withdrawn");
+ using var client = Client();
+ using var response = await client.PostAsJsonAsync($"{Root}/{id}/erase", new EraseResourceUsageRequest
+ {
+ Points = scenario == "excess" ? 1001m : 100m, ExpectedCredits = scenario == "stale" ? 1m : 0m
+ }, Ct);
+ Assert.Equal(status, response.StatusCode);
+ Assert.Equal("application/problem+json", response.Content.Headers.ContentType?.MediaType);
+ }
+
+ [Fact]
+ public async Task Repeated_confirmation_cannot_erase_twice_even_when_quota_remains_reached()
+ {
+ var id = await SeedAsync(30000m);
+ using var client = Client();
+ var request = new EraseResourceUsageRequest { Points = 100m };
+ Assert.Equal(HttpStatusCode.OK, (await client.PostAsJsonAsync($"{Root}/{id}/erase", request, Ct)).StatusCode);
+ Assert.Equal(HttpStatusCode.Conflict, (await client.PostAsJsonAsync($"{Root}/{id}/erase", request, Ct)).StatusCode);
+ using var scope = fixture.Services.CreateScope();
+ Assert.Equal(100m, (await scope.ServiceProvider.GetRequiredService()
+ .ResourceUsageRecords.SingleAsync(r => r.UserId == id, Ct)).CreditPoints);
+ }
+
+ [Fact]
+ public async Task Openapi_documents_the_admin_action_and_its_status_codes()
+ {
+ using var client = Client();
+ var doc = await client.GetFromJsonAsync("/openapi/administration.json", Ct);
+ var operation = doc.GetProperty("paths").GetProperty(Root + "/{userId}/erase").GetProperty("post");
+ Assert.False(string.IsNullOrWhiteSpace(operation.GetProperty("summary").GetString()));
+ foreach (var status in new[] { "200", "400", "401", "403", "404", "409" })
+ Assert.True(operation.GetProperty("responses").TryGetProperty(status, out _));
+ }
+}
diff --git a/src/test/Yavsc.Org.Tests/Controllers/ResourceSubscriptionControllerTests.cs b/src/test/Yavsc.Org.Tests/Controllers/ResourceSubscriptionControllerTests.cs
index e2a6dd921..b06f9d0b5 100644
--- a/src/test/Yavsc.Org.Tests/Controllers/ResourceSubscriptionControllerTests.cs
+++ b/src/test/Yavsc.Org.Tests/Controllers/ResourceSubscriptionControllerTests.cs
@@ -1,12 +1,18 @@
using System.Net;
using System.Net.Http.Json;
+using System.Net.Http.Headers;
using System.Text.Json;
using System.Text.RegularExpressions;
using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.AspNetCore.TestHost;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
+using Microsoft.IdentityModel.Tokens;
+using Microsoft.IdentityModel.Protocols.OpenIdConnect;
+using Yavsc.Abstract.Resources;
+using Yavsc.Tests.Shared;
using Yavsc.Models;
using Yavsc.Models.Payment;
using Yavsc.Server.Helpers;
@@ -66,6 +72,123 @@ public sealed class ResourceSubscriptionControllerTests : IClassFixture(),
+ "listener", "Listener", cpuSeconds: 12000m, cancellationToken: Ct);
+ using var client = NativeClient();
+ var catalogue = await client.GetFromJsonAsync("/api/v1/resource-subscriptions", Ct);
+ Assert.Equal(1.2m, catalogue!.Offers[0].PriceIncludingTax);
+ Assert.Equal(2.4m, catalogue.Offers[1].PriceIncludingTax);
+ Assert.True(catalogue.Usage.IsQuotaReached);
+ using var created = await client.PostAsJsonAsync("/api/v1/resource-subscriptions",
+ new { pack = "Discovery", priceIncludingTax = 0.01m, userId = "author" }, Ct);
+ Assert.Equal(HttpStatusCode.Created, created.StatusCode);
+ Assert.NotNull(created.Headers.Location);
+ Assert.True(created.Headers.CacheControl?.NoStore);
+ var checkout = (await created.Content.ReadFromJsonAsync(Ct))!;
+ Assert.Equal("https://www.sandbox.paypal.com/approve", checkout.ApprovalUrl);
+ Assert.Equal(1.2m, checkout.Subscription.PriceIncludingTax);
+ Assert.Equal(1200m, (await UsageAsync()).Consumption);
+ using var resumed = await client.PostAsJsonAsync("/api/v1/resource-subscriptions", new { pack = "Discovery" }, Ct);
+ Assert.Equal(checkout.Subscription.Id,
+ (await resumed.Content.ReadFromJsonAsync(Ct))!.Subscription.Id);
+ using var conflict = await client.PostAsJsonAsync("/api/v1/resource-subscriptions", new { pack = "Premium" }, Ct);
+ Assert.Equal(HttpStatusCode.Conflict, conflict.StatusCode);
+ using var anonymous = _factory.CreateClient();
+ using var returned = await anonymous.GetAsync("/api/v1/resource-subscriptions/return?success=true", Ct);
+ Assert.Equal(HttpStatusCode.OK, returned.StatusCode);
+ Assert.Equal("text/html", returned.Content.Headers.ContentType?.MediaType);
+ Assert.Equal(1200m, (await UsageAsync()).Consumption);
+ using var other = NativeClient("author");
+ using var forbidden = await other.PostAsync($"/api/v1/resource-subscriptions/{checkout.Subscription.Id}/cancel", null, Ct);
+ Assert.Equal(HttpStatusCode.NotFound, forbidden.StatusCode);
+ Assert.Empty((await other.GetFromJsonAsync("/api/v1/resource-subscriptions", Ct))!.Subscriptions);
+ _factory.PayPal.Payments.Add(new("PAY-NATIVE", "COMPLETED", 1.2m, "EUR", DateTimeOffset.UtcNow));
+ using var refreshed = await client.PostAsync("/api/v1/resource-subscriptions/refresh", null, Ct);
+ Assert.Equal(HttpStatusCode.OK, refreshed.StatusCode);
+ Assert.Equal(200m, (await UsageAsync()).Consumption);
+ using var repeated = await client.PostAsync("/api/v1/resource-subscriptions/refresh", null, Ct);
+ Assert.Equal(HttpStatusCode.OK, repeated.StatusCode);
+ Assert.Equal(200m, (await UsageAsync()).Consumption);
+ using var cancelled = await client.PostAsync($"/api/v1/resource-subscriptions/{checkout.Subscription.Id}/cancel", null, Ct);
+ Assert.Equal(HttpStatusCode.OK, cancelled.StatusCode);
+ Assert.Equal("CANCELLED", (await cancelled.Content.ReadFromJsonAsync(Ct))!.Subscriptions.Single().State);
+ Assert.Equal(1, _factory.PayPal.CancelCount);
+ }
+
+ [Theory]
+ [InlineData("{}")]
+ [InlineData("""{"pack":"Other"}""")]
+ [InlineData("""{"pack":null}""")]
+ public async Task Native_checkout_rejects_invalid_packs(string json)
+ {
+ using var client = NativeClient();
+ using var response = await client.PostAsync("/api/v1/resource-subscriptions",
+ new StringContent(json, System.Text.Encoding.UTF8, "application/json"), Ct);
+ Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
+ using var scope = _factory.Services.CreateScope();
+ Assert.Empty(scope.ServiceProvider.GetRequiredService().ResourceSubscriptions);
+ }
+
+ private HttpClient NativeClient(string userId = "listener")
+ {
+ var client = _factory.CreateClient(new() { AllowAutoRedirect = false });
+ client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", TestTokenIssuer.Issue(userId, "api"));
+ return client;
+ }
+
+ [Fact]
+ public async Task Native_catalogue_uses_instance_prices_and_reports_unconfigured_offers_explicitly()
+ {
+ var options = _factory.Services.GetRequiredService>().Value;
+ var originalPrice = options.DiscoveryPriceExcludingTax;
+ var originalPlan = options.DiscoveryPlanId;
+ try
+ {
+ options.DiscoveryPriceExcludingTax = 3m;
+ options.DiscoveryPlanId = "";
+ using var client = NativeClient();
+ var catalogue = (await client.GetFromJsonAsync("/api/v1/resource-subscriptions", Ct))!;
+ Assert.Equal(3.6m, catalogue.Offers[0].PriceIncludingTax);
+ Assert.False(catalogue.Offers[0].Available);
+ using var response = await client.PostAsJsonAsync("/api/v1/resource-subscriptions", new { pack = "Discovery" }, Ct);
+ Assert.Equal(HttpStatusCode.ServiceUnavailable, response.StatusCode);
+ Assert.Equal("application/problem+json", response.Content.Headers.ContentType?.MediaType);
+ }
+ finally
+ {
+ options.DiscoveryPriceExcludingTax = originalPrice;
+ options.DiscoveryPlanId = originalPlan;
+ }
+ }
+
+ [Fact]
+ public async Task Native_routes_are_described_in_the_existing_openapi_document()
+ {
+ using var client = NativeClient();
+ using var document = JsonDocument.Parse(await client.GetStringAsync("/swagger/v1/swagger.json", Ct));
+ var paths = document.RootElement.GetProperty("paths");
+ Assert.True(paths.GetProperty("/api/v1/resource-subscriptions").TryGetProperty("get", out _));
+ Assert.True(paths.GetProperty("/api/v1/resource-subscriptions").TryGetProperty("post", out _));
+ Assert.True(paths.GetProperty("/api/v1/resource-subscriptions/refresh").TryGetProperty("post", out _));
+ Assert.True(paths.GetProperty("/api/v1/resource-subscriptions/{id}/cancel").TryGetProperty("post", out _));
+ }
+
[Fact]
public async Task Exhausted_free_usage_can_still_subscribe_and_browser_return_does_not_award_unpaid_credit()
{
@@ -225,6 +348,21 @@ public sealed class ResourceSubscriptionControllerTests : IClassFixture
{
+ services.PostConfigure("Bearer", o =>
+ {
+ o.Authority = null;
+ o.MetadataAddress = "";
+ o.ConfigurationManager = null;
+ o.Configuration = new OpenIdConnectConfiguration { Issuer = TestTokenIssuer.Issuer };
+ o.MapInboundClaims = false;
+ o.TokenValidationParameters = new TokenValidationParameters
+ {
+ ValidateIssuer = true, ValidIssuer = TestTokenIssuer.Issuer,
+ ValidateAudience = false, ValidateLifetime = true,
+ ValidateIssuerSigningKey = true, IssuerSigningKey = TestTokenIssuer.SigningKey,
+ NameClaimType = "name"
+ };
+ });
services.AddSingleton(PayPal);
services.Configure(o =>
{
diff --git a/src/test/Yavsc.Server.Tests/ResourceUsageTests.cs b/src/test/Yavsc.Server.Tests/ResourceUsageTests.cs
index a6c006d7d..8870b9b8c 100644
--- a/src/test/Yavsc.Server.Tests/ResourceUsageTests.cs
+++ b/src/test/Yavsc.Server.Tests/ResourceUsageTests.cs
@@ -8,11 +8,127 @@ using Microsoft.Extensions.Options;
using Yavsc.Models;
using Yavsc.Server.Helpers;
using Yavsc.Settings;
+using Yavsc.Abstract.Resources;
namespace Yavsc.Server.Tests;
public sealed class ResourceUsageTests
{
+ [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();
+ 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();
+ 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();
+ var points = decimal.Parse(input, System.Globalization.CultureInfo.InvariantCulture);
+ var error = await Assert.ThrowsAsync(() => service.EraseAsync(
+ "alice", "admin", new() { Points = points }, TestContext.Current.CancellationToken));
+ Assert.Equal(400, error.StatusCode);
+ Assert.Empty(scope.ServiceProvider.GetRequiredService().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();
+ 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();
+ var error = await Assert.ThrowsAsync(() => 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();
+ 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();
+ await ResourceUsageTracker.RecordAsync(db, "alice", "alice", cpuSeconds: 1m, cancellationToken: ct);
+ try
+ {
+ await scope.ServiceProvider.GetRequiredService()
+ .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().GetCurrentAsync("alice", "alice", ct);
+ Assert.Equal(1910m, summary.Consumption);
+ Assert.Equal(100m, summary.AppliedCredits);
+ }
+
private static ServiceProvider NewProvider(Action? configure = null)
{
var services = new ServiceCollection();