feat(postit): circles+ACL UI, blog fixture→SQLite, seed default user
Bundled end-of-branch commit on feat/postit-acl-members. PostIt UI for circles + per-post ACL - Reorganise PostIt.Tests into Auth/ and Blogs/ subfolders (Bearer/OIDC scope tests vs. blog API fakes live where they belong) and introduces PostItHeadlessCollection so the Avalonia.Headless tests share a single xUnit collection instead of contending with the EF-Core test host. - Adds BlogAclApiTests (a brand-new behavioural layer over POST /api/v1/blogacl) and the fakes it relies on (BlogApiTestFakes, BlogPostAuthorDtoTests, AddCircleMember DialogTests); pulls UserId-through-OIDC-sub path into BearerScopeTests / FakeAuthorizingBrowser / OidcStubAuthority. - App.axaml.cs gets a small PushPageAsync touch-up the new tests rely on. - Drops UnitTest1.cs (xUnit scaffold, never used). Yavsc.Blogs.Tests — SQLite instead of InMemory - Bumps Yavsc.Blogs.Tests.csproj on Microsoft.EntityFrameworkCore.Sqlite and rewrites BlogsWebServerFixture to hold a single shared SqliteConnection (Cache=Shared) for the fixture lifetime, with a sync Dispose close to dodge async teardown hangs. Reason: the EF Core InMemory provider silently ignores FKs, which masked the kind of bug we are about to pin in the ACL tests. SQLite enforces them, so any future INSERT that forgets to seed its parent rows fails loudly here instead of passing the test and breaking prod. - PublishEndpointTests and BlogApiSmokeTests get a one-line tweak to follow the new connection lifecycle. Foreign-key fallout: seed the default user in the fixture - Adds BlogsWebServerFixture.SeedUser(userName). Now that SQLite enforces BlogPost.AuthorId → AspNetUsers.Id, every test that POST/PUT/DELETE a BlogPost and sends AuthorId= 'tester' in the payload needs an AspNetUsers row to satisfy the FK or it returns 500 with SQLite Error 19. - BlogApiTests wraps the existing ResetDatabase with a ResetAndSeedDefaultUser helper for the six mutating tests; the four GET-only and ModelState-only tests keep the bare ResetDatabase. - Side benefit: every test in Yavsc.Blogs.Tests now finishes cleanly instead of hanging at teardown — previously a stuck test held the shared SqliteConnection open and the next tests waited indefinitely. Verified: dotnet test src/Yavsc.Blogs.Tests passes 25/25 green from a clean run, no fixture teardown hang.
This commit is contained in:
parent
6825f74308
commit
a44c04ad77
GPG key ID:
1DD5D838E5343B06
22 changed files with 806 additions and 460 deletions
|
|
@ -2,8 +2,8 @@ using System.Text;
|
|||
using Microsoft.AspNetCore.Authentication.JwtBearer;
|
||||
using Microsoft.AspNetCore.Authorization;
|
||||
using Microsoft.AspNetCore.Builder;
|
||||
using Microsoft.Data.Sqlite;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Microsoft.EntityFrameworkCore.Storage;
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.IdentityModel.Tokens;
|
||||
using Yavsc.Blogs.Controllers;
|
||||
|
|
@ -14,14 +14,20 @@ using Yavsc.Tests.Shared;
|
|||
namespace Yavsc.Blogs.Tests;
|
||||
|
||||
/// <summary>
|
||||
/// Test host for the Yavsc.Blogs API surface. Specialisation of
|
||||
/// <see cref="WebHostFixture"/> that wires up only the bits the
|
||||
/// blog API actually depends on:
|
||||
/// Shared integration-test host for the Yavsc.Blogs API surface.
|
||||
/// Specialisation of <see cref="WebHostFixture"/> that wires up
|
||||
/// only the bits the blog API actually depends on:
|
||||
///
|
||||
/// <list type="bullet">
|
||||
/// <item><description>An in-memory <see cref="ApplicationDbContext"/>
|
||||
/// (the real one — no mock) so <c>BlogSpotService.Index</c> can run
|
||||
/// against an empty table and return an empty list.</description></item>
|
||||
/// <item><description>A SQLite <c>:memory:</c> database
|
||||
/// (<see cref="Microsoft.EntityFrameworkCore.Sqlite"/>) backed
|
||||
/// by a single shared <see cref="SqliteConnection"/> held open
|
||||
/// for the lifetime of the host. SQLite enforces real foreign
|
||||
/// keys and real transactional semantics, so the tests see the
|
||||
/// same INSERT-time FK validation a production Postgres host
|
||||
/// would — unlike the EF Core InMemory provider, which silently
|
||||
/// ignores FKs and masks bugs that surface only against a real
|
||||
/// relational engine.</description></item>
|
||||
/// <item><description>A trivial <see cref="IFileSystemAuthManager"/>
|
||||
/// stub: the GET index path doesn't read the file system, so any
|
||||
/// implementation is fine.</description></item>
|
||||
|
|
@ -44,31 +50,58 @@ namespace Yavsc.Blogs.Tests;
|
|||
///
|
||||
/// No IdentityServer, no SMTP, no static assets — the Org fixture
|
||||
/// owns all of that and we don't need any of it for blog integration
|
||||
/// tests.
|
||||
/// tests. Marked <see cref="CollectionDefinitionAttribute"/> so the
|
||||
/// host is shared across every <c>[Collection("Yavsc Blogs")]</c>
|
||||
/// test class: one host, one SQLite DB, one Kestrel port.
|
||||
/// </summary>
|
||||
[CollectionDefinition("Yavsc Blogs")]
|
||||
public sealed class BlogsWebServerFixture : WebHostFixture
|
||||
{
|
||||
protected override int HttpsPort => 5103;
|
||||
|
||||
private InMemoryDatabaseRoot? _inMemoryRoot;
|
||||
// A single SqliteConnection held open at the static level,
|
||||
// mirroring how Yavsc.Org.Tests.WebServerFixture hoists its
|
||||
// shared configuration into static slots. Closing the
|
||||
// connection destroys the in-memory database — so we close
|
||||
// it only when the last fixture instance is disposed (see
|
||||
// Dispose below), exactly when WebHostFixture tears down the
|
||||
// host.
|
||||
private static SqliteConnection? _sharedSqliteConnection;
|
||||
private static readonly object _sqliteLock = new();
|
||||
|
||||
protected override WebApplication BuildApp(WebApplicationBuilder builder)
|
||||
{
|
||||
// Use the real ApplicationDbContext with an in-memory store.
|
||||
// BlogSpotService reads _context.BlogSpot directly, so any
|
||||
// attempt to mock it would be wasted work; the real service
|
||||
// against an empty table returns an empty list, which is
|
||||
// exactly what the first test wants to assert.
|
||||
//
|
||||
// Share a single InMemoryDatabaseRoot across the test
|
||||
// lifetime so POST + GET on the same fixture see the same
|
||||
// store. Without the root, EF Core's In-Memory provider
|
||||
// creates independent stores per DbContext in some
|
||||
// configurations, and the second request would see an
|
||||
// empty list even after the first wrote a row.
|
||||
_inMemoryRoot = new InMemoryDatabaseRoot();
|
||||
// Open the shared in-memory connection lazily on the first
|
||||
// fixture construction. Subsequent constructions (xUnit
|
||||
// creates one fixture instance per IClassFixture) reuse
|
||||
// the same connection so all DbContexts across all tests
|
||||
// see the same database.
|
||||
SqliteConnection sharedConnection;
|
||||
lock (_sqliteLock)
|
||||
{
|
||||
if (_sharedSqliteConnection is null)
|
||||
{
|
||||
// Mode=Memory + Cache=Shared gives us a named
|
||||
// in-memory database that every connection string
|
||||
// referencing "File:YavscBlogsTests?mode=memory&cache=shared"
|
||||
// will resolve to the same backing store, as long
|
||||
// as at least one SqliteConnection stays open
|
||||
// against it.
|
||||
_sharedSqliteConnection = new SqliteConnection(
|
||||
"Data Source=YavscBlogsTests;Mode=Memory;Cache=Shared");
|
||||
_sharedSqliteConnection.Open();
|
||||
}
|
||||
sharedConnection = _sharedSqliteConnection;
|
||||
}
|
||||
|
||||
builder.Services.AddDbContext<ApplicationDbContext>(opt =>
|
||||
opt.UseInMemoryDatabase("Yavsc.Blogs.Tests", _inMemoryRoot));
|
||||
// UseSqlite(DbConnection) keeps the connection we just
|
||||
// opened alive for the DbContext's lifetime, instead of
|
||||
// letting EF open and close its own. Without this,
|
||||
// each DbContext would get a fresh connection pointing
|
||||
// at an empty :memory: store and nothing would persist
|
||||
// across requests.
|
||||
opt.UseSqlite(sharedConnection));
|
||||
|
||||
// Trivial file-system auth: the GET index path never calls
|
||||
// into it, but the DI container needs an instance.
|
||||
|
|
@ -168,6 +201,75 @@ public sealed class BlogsWebServerFixture : WebHostFixture
|
|||
return app;
|
||||
}
|
||||
|
||||
public override void Dispose()
|
||||
{
|
||||
try
|
||||
{
|
||||
base.Dispose();
|
||||
}
|
||||
finally
|
||||
{
|
||||
// Close the shared SQLite connection only when the
|
||||
// last fixture instance goes away, matching the
|
||||
// lifetime contract of WebHostFixture.Dispose. We
|
||||
// rely on base.Dispose's _instanceCount decrement
|
||||
// having run, so we close only if the host is gone
|
||||
// (base already nulled _app when count==0).
|
||||
lock (_sqliteLock)
|
||||
{
|
||||
if (_sharedSqliteConnection is not null)
|
||||
{
|
||||
// Synchronous close: SQLite's Close() is
|
||||
// documented as safe to call from a sync
|
||||
// context and avoids the GetAwaiter().GetResult()
|
||||
// pattern that's historically caused teardown
|
||||
// hangs in this repo's async pipeline.
|
||||
_sharedSqliteConnection.Close();
|
||||
_sharedSqliteConnection.Dispose();
|
||||
_sharedSqliteConnection = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>Seed an <see cref="ApplicationUser"/> in the shared
|
||||
/// SQLite store, so tests that POST/PUT/DELETE a
|
||||
/// <c>BlogPost</c> (whose <c>AuthorId</c> is a FK to
|
||||
/// <c>AspNetUsers.Id</c>) don't trip the FK constraint that
|
||||
/// SQLite enforces but the EF Core InMemory provider silently
|
||||
/// ignored. Idempotent on <paramref name="userName"/>: a
|
||||
/// second call for the same id is a no-op (the user already
|
||||
/// exists).</summary>
|
||||
/// <param name="userName">Both the PK id and the login name.
|
||||
/// The JWT subject in tests is this same string, so seeding
|
||||
/// this id is enough to make the FK from a
|
||||
/// <c>BlogPost.AuthorId</c> resolve.</param>
|
||||
/// <param name="configure">Optional hook to fill in fields
|
||||
/// like <c>FullName</c> / <c>Avatar</c> / <c>EmailConfirmed</c>
|
||||
/// that downstream tests assert on.</param>
|
||||
public ApplicationUser SeedUser(string userName, Action<ApplicationUser>? configure = null)
|
||||
{
|
||||
using var scope = Services.CreateScope();
|
||||
var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
|
||||
var existing = db.Users.SingleOrDefault(u => u.Id == userName);
|
||||
if (existing != null) return existing;
|
||||
|
||||
// Email is an alternate key on ApplicationUser; seeding
|
||||
// it explicitly avoids the InMemory provider's null-claim
|
||||
// tracking quirk (cf. PublishEndpointTests.ResetDatabase)
|
||||
// and keeps the column shape realistic for prod.
|
||||
var user = new ApplicationUser
|
||||
{
|
||||
Id = userName,
|
||||
UserName = userName,
|
||||
Email = $"{userName}@example.test",
|
||||
};
|
||||
configure?.Invoke(user);
|
||||
db.Users.Add(user);
|
||||
db.SaveChanges();
|
||||
return user;
|
||||
}
|
||||
|
||||
/// <summary>Trivial <see cref="IFileSystemAuthManager"/> stub. The
|
||||
/// blog API endpoints exercised by the first tests don't read the
|
||||
/// file system, so the implementation can be a no-op.</summary>
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue