Bifrost/tests/Bifrost.Web.Tests/MembershipSuspensionTests.cs

196 lines
9.8 KiB
C#

using Bifrost.Web.Data;
using Bifrost.Web.Domain;
using Bifrost.Web.Features.Membership;
using Bifrost.Web.Features.Shared;
using Bifrost.Web.Pages.App.Members;
using Bifrost.Web.Tests.Support;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
namespace Bifrost.Web.Tests;
/// <summary>A suspension is an admin's decision: only the admin path sets or lifts it, with a receipt, and the members page's Approve cannot lift it.</summary>
public sealed class MembershipSuspensionTests : IClassFixture<TestWebApplicationFactory>
{
private readonly TestWebApplicationFactory _factory;
public MembershipSuspensionTests(TestWebApplicationFactory factory) => _factory = factory;
private sealed record Seeded(Guid AdminId, Guid MemberId, Guid OrdinaryId, Guid OtherAdminId);
private async Task<Seeded> SeedAsync(MembershipStatus memberStatus = MembershipStatus.Active, bool approved = true)
{
using var scope = _factory.Services.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<BifrostDbContext>();
UserAccount Account(string name, MembershipStatus status, bool admin, bool wasApproved) => new()
{
DisplayName = name,
BifrostIdentity = $"{name}-{Guid.NewGuid():N}"[..20],
NormalizedBifrostIdentity = $"{name}-{Guid.NewGuid():N}"[..20],
Membership = new Bifrost.Web.Domain.Membership
{
Status = status,
IsPlatformAdmin = admin,
ApprovedAtUtc = wasApproved ? DateTimeOffset.UtcNow : null
}
};
var admin = Account("admin", MembershipStatus.Active, true, true);
var otherAdmin = Account("admin2", MembershipStatus.Active, true, true);
var member = Account("member", memberStatus, false, approved);
var ordinary = Account("ordinary", MembershipStatus.Active, false, true);
db.UserAccounts.AddRange(admin, otherAdmin, member, ordinary);
await db.SaveChangesAsync();
return new Seeded(admin.Id, member.Id, ordinary.Id, otherAdmin.Id);
}
private async Task<T> InScopeAsync<T>(Func<IServiceProvider, BifrostDbContext, Task<T>> body)
{
using var scope = _factory.Services.CreateScope();
return await body(scope.ServiceProvider, scope.ServiceProvider.GetRequiredService<BifrostDbContext>());
}
private Task<CurrentBifrostActor> ActorAsync(Guid id) => InScopeAsync(async (_, db) =>
new CurrentBifrostActor(true, await db.UserAccounts.Include(x => x.Membership!).ThenInclude(x => x.RoleAssignments).SingleAsync(x => x.Id == id)));
private Task<MembershipStatus> StatusAsync(Guid id) => InScopeAsync(async (_, db) =>
(await db.Memberships.AsNoTracking().SingleAsync(x => x.UserAccountId == id)).Status);
private Task<string?> ReasonAsync(Guid id) => InScopeAsync(async (_, db) =>
(await db.Memberships.AsNoTracking().SingleAsync(x => x.UserAccountId == id)).SuspensionReason);
private Task<Guid> MembershipIdAsync(Guid id) => InScopeAsync(async (_, db) =>
(await db.Memberships.AsNoTracking().SingleAsync(x => x.UserAccountId == id)).Id);
private Task<List<AuditEvent>> AuditAsync(string action) => InScopeAsync((_, db) =>
db.AuditEvents.AsNoTracking().Where(x => x.Action == action).ToListAsync());
private Task<SuspensionOutcome> SuspendAsync(Guid by, Guid target, string? reason) => InScopeAsync(async (sp, _) =>
await sp.GetRequiredService<MembershipSuspensionService>().SuspendAsync(await ActorAsync(by), target, reason, CancellationToken.None));
private Task<SuspensionOutcome> UnsuspendAsync(Guid by, Guid target, string? reason) => InScopeAsync(async (sp, _) =>
await sp.GetRequiredService<MembershipSuspensionService>().UnsuspendAsync(await ActorAsync(by), target, reason, CancellationToken.None));
[Fact]
public async Task Only_a_platform_admin_can_suspend_and_the_receipt_names_who_and_why()
{
var seed = await SeedAsync();
Assert.Equal(SuspensionOutcome.NotAdmin, await SuspendAsync(seed.OrdinaryId, seed.MemberId, "because"));
Assert.Equal(MembershipStatus.Active, await StatusAsync(seed.MemberId));
Assert.Equal(SuspensionOutcome.NoReason, await SuspendAsync(seed.AdminId, seed.MemberId, " "));
Assert.Equal(MembershipStatus.Active, await StatusAsync(seed.MemberId));
Assert.Equal(SuspensionOutcome.Done, await SuspendAsync(seed.AdminId, seed.MemberId, "spam in chat"));
Assert.Equal(MembershipStatus.Suspended, await StatusAsync(seed.MemberId));
var membershipId = (await MembershipIdAsync(seed.MemberId)).ToString();
var receipt = Assert.Single(await AuditAsync("membership.suspended"), x => x.EntityId == membershipId);
Assert.Equal(seed.AdminId, receipt.ActorUserAccountId);
Assert.Contains("Active -> Suspended", receipt.Detail);
Assert.DoesNotContain("spam in chat", receipt.Detail);
Assert.Equal("spam in chat", await ReasonAsync(seed.MemberId));
}
[Fact]
public async Task An_admin_cannot_suspend_themselves_or_another_platform_admin()
{
var seed = await SeedAsync();
Assert.Equal(SuspensionOutcome.ProtectedAccount, await SuspendAsync(seed.AdminId, seed.AdminId, "oops"));
Assert.Equal(SuspensionOutcome.ProtectedAccount, await SuspendAsync(seed.AdminId, seed.OtherAdminId, "coup"));
Assert.Equal(MembershipStatus.Active, await StatusAsync(seed.AdminId));
Assert.Equal(MembershipStatus.Active, await StatusAsync(seed.OtherAdminId));
}
[Fact]
public async Task A_suspension_reason_is_on_the_membership_row_not_the_audit_trail_or_the_member_dashboard_snapshot()
{
var seed = await SeedAsync();
await SuspendAsync(seed.AdminId, seed.MemberId, "private-reason-canary");
var snapshot = await InScopeAsync(async (sp, _) => await sp.GetRequiredService<DashboardSnapshotService>().GetAsync(seed.OrdinaryId, CancellationToken.None));
Assert.DoesNotContain(snapshot.RecentActivity, x => x.Detail.Contains("private-reason-canary"));
Assert.DoesNotContain(await AuditAsync("membership.suspended"), x => x.Detail.Contains("private-reason-canary"));
Assert.Equal("private-reason-canary", await ReasonAsync(seed.MemberId));
}
[Fact]
public async Task A_role_granted_admin_is_protected_like_a_flagged_one()
{
var seed = await SeedAsync();
await InScopeAsync(async (_, db) =>
{
var membership = await db.Memberships.SingleAsync(x => x.UserAccountId == seed.MemberId);
db.RoleAssignments.Add(new RoleAssignment { MembershipId = membership.Id, Role = MemberRole.PlatformAdmin });
await db.SaveChangesAsync();
return 0;
});
Assert.Equal(SuspensionOutcome.ProtectedAccount, await SuspendAsync(seed.AdminId, seed.MemberId, "role admin"));
}
[Theory]
[InlineData(true, MembershipStatus.Active)]
[InlineData(false, MembershipStatus.Authenticated)]
public async Task Unsuspend_works_only_by_the_admin_path_and_with_a_reason(bool approved, MembershipStatus restored)
{
var seed = await SeedAsync(MembershipStatus.Suspended, approved);
Assert.Equal(SuspensionOutcome.NotAdmin, await UnsuspendAsync(seed.OrdinaryId, seed.MemberId, "please"));
Assert.Equal(SuspensionOutcome.NoReason, await UnsuspendAsync(seed.AdminId, seed.MemberId, null));
Assert.Equal(MembershipStatus.Suspended, await StatusAsync(seed.MemberId));
await InScopeAsync(async (_, db) =>
{
(await db.Memberships.SingleAsync(x => x.UserAccountId == seed.MemberId)).SuspensionReason = "old reason";
await db.SaveChangesAsync();
return 0;
});
Assert.Equal(SuspensionOutcome.Done, await UnsuspendAsync(seed.AdminId, seed.MemberId, "appeal upheld"));
Assert.Equal(restored, await StatusAsync(seed.MemberId));
Assert.Contains(await AuditAsync("membership.unsuspended"), x => x.ActorUserAccountId == seed.AdminId && !x.Detail.Contains("appeal upheld"));
Assert.Null(await ReasonAsync(seed.MemberId));
Assert.Equal(SuspensionOutcome.NotApplicable, await UnsuspendAsync(seed.AdminId, seed.MemberId, "again"));
}
[Fact]
public async Task The_members_page_Approve_cannot_lift_a_suspension()
{
var seed = await SeedAsync(MembershipStatus.Suspended);
var result = await InScopeAsync(async (sp, db) =>
{
var page = new IndexModel(
db, new FixedActor(await ActorAsync(seed.AdminId)), sp.GetRequiredService<AuditTrailService>(),
sp.GetRequiredService<MembershipSuspensionService>(), TimeProvider.System);
return await page.OnPostApproveAsync(seed.MemberId, CancellationToken.None);
});
Assert.IsType<RedirectToPageResult>(result);
Assert.Equal(MembershipStatus.Suspended, await StatusAsync(seed.MemberId));
}
[Fact]
public async Task The_members_page_suspend_handler_forbids_a_non_admin_and_changes_nothing()
{
var seed = await SeedAsync();
var result = await InScopeAsync(async (sp, db) =>
{
var page = new IndexModel(
db, new FixedActor(await ActorAsync(seed.OrdinaryId)), sp.GetRequiredService<AuditTrailService>(),
sp.GetRequiredService<MembershipSuspensionService>(), TimeProvider.System);
return await page.OnPostSuspendAsync(seed.MemberId, "nope", CancellationToken.None);
});
Assert.IsType<ForbidResult>(result);
Assert.Equal(MembershipStatus.Active, await StatusAsync(seed.MemberId));
}
private sealed class FixedActor(CurrentBifrostActor actor) : ICurrentBifrostActorAccessor
{
public Task<CurrentBifrostActor> GetAsync(CancellationToken cancellationToken) => Task.FromResult(actor);
}
}