csharp: emit the test project, so dotnet test has something to run

csharp was the last target whose gates asserted nothing about behavior.
`toolchain-csharp` compiled the emit and stopped there; the archive's
README § Test said `dotnet test`, and that ran in 1.1 seconds over a
project with no test files, exited 0, and was green for months. The emit
simply had no test half — every other target has emitted the transpiled
real-blog suite for a while (#34 §0).

It does now: `tests/` — ArticleTest 4, CommentTest 5,
ArticlesControllerTest 9, CommentsControllerTest 3 = **21 executed**,
xUnit, against a per-test database.

A SEPARATE PROJECT (tests/App.Tests.csproj), not test files inside the
app: `Microsoft.NET.Test.Sdk` generates its own entry point, which
collides with the Web SDK app's top-level Program.cs. Two consequences
worth knowing —

  * the app csproj gains `<Compile Remove="tests/**" />`. The SDK globs
    `**/*.cs`, so without it the app itself tries to compile the xUnit
    code it references.
  * README § Test becomes `dotnet test tests`. § Build stays a bare
    `dotnet build`: project discovery looks in the current directory
    only, and the root still holds exactly one csproj.

XUNIT HAS NO @beforeeach — it constructs a fresh instance per test, so
the constructor IS the per-test hook. `RoundhouseTestCase`'s ctor resets
the schema and reloads fixtures; a test class that ingested a `setup`
gets a generated ctor calling `Setup()`. C# runs the base ctor first, so
the ordering matches what JUnit gets from superclass lifecycle methods
and XCTest from setUp chaining, without the emitter modelling any of it.

`Db.SetupTestDb` IS A FILE, NOT `:memory:`, and that is the one real
design call here. This Db pools connections, and every connection to
`:memory:` is its OWN database — the write would land somewhere the read
pool cannot see, and the count-delta assertions would fail in a way that
reads like a lowering bug. One path per process, deleted and recreated
per test, keeps every connection on the same bytes. Existing connections
point at the previous file, so they're dropped: pooled readers disposed
(the Gate counts concurrent rentals, not pool contents, so draining does
not desync it), the thread's write connection closed, and
`SqliteConnection.ClearAllPools()` for Microsoft.Data.Sqlite's own pool.
Being one process-wide static, the suite also can't run concurrently —
hence `[assembly: CollectionBehavior(DisableTestParallelization = true)]`.

The rest is the kotlin/swift recipe with no lowerer changes: fixtures →
`<Plural>Fixtures`, `lower_test_modules_with_inner` → `emit_test_class`
(`[Fact]` on `test_*`, inner classes hoisted, body ivars as properties),
and a generated TestSetup.cs carrying the schema DDL, fixture loaders,
and the routes/controllers tables the synchronous dispatch needs.
TestSupport.cs — RoundhouseTestCase plus the Dom substring stub — is the
port of runtime/kotlin/test_support.kt.

TWO GATES, both new teeth rather than new coverage:

  * `real_blog_csharp_tests_pass` parses the `Passed: N` summary and
    demands >= 21. `dotnet test` exits 0 when it discovers nothing, which
    is how the old gate passed; a count is the only thing that catches
    emit ceasing to produce tests, or the runner package dropping out.
  * scripts/smoke's csharp KNOWN-GAP floor of 0 is DELETED. csharp takes
    the default 21 like everyone else, and an archive that runs nothing
    now fails instead of warning.

A subtlety worth recording: the emitted ivar property for `@article` is
`public Article? Article`, which shadows the model type, so `Article.
Count()` in the same class binds the static through C#'s "Color Color"
rule (§7.6.4.1 — E.I where E names both a type and a property of that
type). It is exactly what that rule is for, and it is load-bearing here.

Verified against a REAL .NET 10.0.400 toolchain (installed locally for
this): `cargo test --test csharp_toolchain -- --ignored` green on both
legs, "csharp real-blog suite: 21 tests passed", 4.76s. Also 21/21
through the archive path (`--target csharp`, README and all), stable
across three consecutive runs, and `dotnet build` at the root still
clean with tests/ present. cargo test --all-targets green, no
regressions. The smoke recognizer reads dotnet's real summary as 21, and
an archive whose § Test runs nothing now exits 1.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: rubys

.github/workflows/ci.yml

@@ -779,9 +779,12 @@ jobs:
       - uses: actions/setup-dotnet@v4
         with:
           dotnet-version: '10.0.x'
-      # `dotnet build` of the emitted ASP.NET Core project — the C# analog of
-      # crystal's `--no-codegen` / go's `vet`: compiles the model layer, the
-      # transpiled framework runtime, and the primitives together.
+      # Two legs: `dotnet build` of the emitted ASP.NET Core project (the C#
+      # analog of crystal's `--no-codegen` / go's `vet` — model layer,
+      # transpiled framework runtime and primitives compiling together), and
+      # `dotnet test tests`, which RUNS the transpiled real-blog suite (21) as
+      # an xUnit project with an executed-count floor. csharp was the last
+      # target whose gates asserted nothing about behavior (#34 §0).
       - name: cargo test --test csharp_toolchain -- --ignored
         run: cargo test --test csharp_toolchain -- --ignored --nocapture
 

runtime/csharp/Db.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.IO;
 using System.Threading;
 using Microsoft.Data.Sqlite;
 
@@ -23,8 +24,12 @@ namespace Roundhouse;
 // committed write visible to the read pool immediately.
 public static class Db
 {
+    // Set only by `SetupTestDb`; production reads the environment.
+    private static string? _testPath;
+
     private static string DbPath =>
-        Environment.GetEnvironmentVariable("BLOG_DB")
+        _testPath
+        ?? Environment.GetEnvironmentVariable("BLOG_DB")
         ?? Environment.GetEnvironmentVariable("DATABASE_PATH")
         ?? "storage/development.sqlite3";
 
@@ -135,6 +140,50 @@ public static void Finalize(long stmt)
 
     private static SqliteConnection WriteConn() => _writeConn ??= Open();
 
+    // Per-test database: point every future connection at a fresh file and
+    // replay the schema DDL. The C# analog of kotlin's `Db.setupTestDb` /
+    // swift's per-test `:memory:`.
+    //
+    // A FILE, not `:memory:`, because this Db pools connections and each
+    // connection to `:memory:` is its OWN database — the write would land
+    // somewhere the read pool can't see. One path per process, deleted and
+    // recreated per test, keeps every connection looking at the same bytes.
+    //
+    // Existing connections point at the previous file, so they're dropped:
+    // pooled readers are disposed (the next `Rent` opens a fresh one — the
+    // Gate counts concurrent rentals, not pool contents, so draining it does
+    // not desync), and this thread's write connection is closed. Callers run
+    // on the test thread with parallelization disabled (see the test
+    // project's AssemblyInfo), so per-thread state is per-test state.
+    public static void SetupTestDb(string schema)
+    {
+        foreach (var handle in OpenReaders.Keys)
+        {
+            Finalize(handle);
+        }
+        while (Pool.TryTake(out var pooled))
+        {
+            pooled.Dispose();
+        }
+        _writeConn?.Dispose();
+        _writeConn = null;
+        SqliteConnection.ClearAllPools();
+
+        _testPath ??= Path.Combine(
+            Path.GetTempPath(), $"roundhouse-test-{Environment.ProcessId}.sqlite3");
+        foreach (var suffix in new[] { "", "-wal", "-shm" })
+        {
+            var f = _testPath + suffix;
+            if (File.Exists(f)) File.Delete(f);
+        }
+
+        if (schema.Length == 0) return;
+        foreach (var stmt in schema.Split(";\n"))
+        {
+            if (stmt.Trim().Length > 0) Exec(stmt);
+        }
+    }
+
     public static void Exec(string sql)
     {
         using var cmd = WriteConn().CreateCommand();

runtime/csharp/TestSupport.cs

@@ -0,0 +1,264 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Roundhouse;
+
+// The hand-written half of the C# test harness; the app-specific half is
+// the generated `TestSetup.cs` (RoundhouseTestSetup — schema DDL, fixture
+// loaders, routes, controller factories). Port of
+// `runtime/kotlin/test_support.kt` / `runtime/swift/test_support.swift`.
+//
+// Lifecycle: xUnit constructs a FRESH INSTANCE per test, so the
+// constructor is the per-test setup — the analog of JUnit's @BeforeEach.
+// A derived test class that ingested a `setup` method gets a generated
+// constructor calling it, and C# runs the base constructor first, so the
+// ordering (schema reset + fixtures, then the test's own setup) matches
+// the other targets.
+//
+// The controller-test surface (Get/Post/Patch/Delete + AssertResponse /
+// AssertRedirectedTo / AssertSelect) dispatches SYNCHRONOUSLY through the
+// transpiled Router — the same path Server.Dispatch takes, minus HTTP and
+// minus Kestrel. Assertion failures inside test bodies are plain
+// `throw new Exception(...)` (what the `inline_assertions` lowerer emits),
+// which xUnit records as a per-test failure; the harness's own checks use
+// `Assert.Fail` for the same effect with a better message.
+public class RoundhouseTestCase
+{
+    protected long __status = 200L;
+    protected string __body = "";
+    protected string __location = "";
+    protected Flash __flash = new Flash();
+    protected Session __session = new Session();
+
+    public RoundhouseTestCase()
+    {
+        if (RoundhouseTestSetup.SchemaSql.Length > 0)
+        {
+            Db.SetupTestDb(RoundhouseTestSetup.SchemaSql);
+            foreach (var loader in RoundhouseTestSetup.FixtureLoaders)
+            {
+                loader();
+            }
+        }
+        ViewHelpers.ResetSlotsBang();
+        __flash = new Flash();
+        __session = new Session();
+    }
+
+    // ── controller-test dispatch ─────────────────────────────────
+
+    public void Get(string path) =>
+        PerformRequest("GET", path, new Dictionary<string, object?>());
+
+    public void Post(string path, Dictionary<string, object?>? opts = null) =>
+        PerformRequest("POST", path, RequestParams(opts));
+
+    public void Patch(string path, Dictionary<string, object?>? opts = null) =>
+        PerformRequest("PATCH", path, RequestParams(opts));
+
+    public void Delete(string path, Dictionary<string, object?>? opts = null) =>
+        PerformRequest("DELETE", path, RequestParams(opts));
+
+    // `post path, params: { article: { … } }` lowers to a single options
+    // hash; the request body is its "params" entry.
+    private static Dictionary<string, object?> RequestParams(Dictionary<string, object?>? opts)
+    {
+        if (opts != null && opts.TryGetValue("params", out var p) &&
+            p is Dictionary<string, object?> nested)
+        {
+            return nested;
+        }
+        return new Dictionary<string, object?>();
+    }
+
+    private void PerformRequest(string method, string path, Dictionary<string, object?> prms)
+    {
+        ViewHelpers.ResetSlotsBang();
+        var match = Router.Match(method, path, RoundhouseTestSetup.Routes);
+        if (match == null)
+        {
+            Assert.Fail($"no route for {method} {path}");
+            return;
+        }
+        if (!RoundhouseTestSetup.Controllers.TryGetValue(match.Controller, out var factory))
+        {
+            Assert.Fail($"no controller registered for {match.Controller}");
+            return;
+        }
+
+        var merged = new Dictionary<string, object?>(prms);
+        foreach (var kv in match.PathParams)
+        {
+            merged[kv.Key] = kv.Value;
+        }
+
+        var controller = factory();
+        controller.Params = merged;
+        controller.RequestFormat = "html";
+        controller.RequestMethod = method;
+        controller.RequestPath = path;
+        controller.Flash = __flash;
+        controller.Session = __session;
+        try
+        {
+            controller.ProcessAction(match.Action);
+        }
+        catch (RecordNotFound)
+        {
+            // Rails' rescue_from: a missing record is a 404, not a crash.
+            __status = 404L;
+            __body = "";
+            __location = "";
+            return;
+        }
+        __status = controller.Status;
+        __body = controller.Body;
+        __location = controller.Location ?? "";
+        __flash = controller.Flash;
+    }
+
+    // ── HTTP response assertions ─────────────────────────────────
+
+    private static readonly Dictionary<string, (long Lo, long Hi)> StatusRanges = new()
+    {
+        ["success"] = (200L, 299L),
+        ["redirect"] = (300L, 399L),
+        ["missing"] = (404L, 404L),
+        ["not_found"] = (404L, 404L),
+        ["error"] = (500L, 599L),
+        ["ok"] = (200L, 200L),
+        ["created"] = (201L, 201L),
+        ["no_content"] = (204L, 204L),
+        ["moved_permanently"] = (301L, 301L),
+        ["found"] = (302L, 302L),
+        ["see_other"] = (303L, 303L),
+        ["bad_request"] = (400L, 400L),
+        ["unauthorized"] = (401L, 401L),
+        ["forbidden"] = (403L, 403L),
+        ["unprocessable_entity"] = (422L, 422L),
+        ["unprocessable_content"] = (422L, 422L),
+        ["internal_server_error"] = (500L, 500L),
+    };
+
+    public void AssertResponse(string expected)
+    {
+        if (!StatusRanges.TryGetValue(expected, out var range))
+        {
+            Assert.Fail($"unknown response expectation {expected}");
+            return;
+        }
+        if (__status < range.Lo || __status > range.Hi)
+        {
+            var preview = __body.Length > 200 ? __body.Substring(0, 200) : __body;
+            Assert.Fail($"expected response {expected}, got status={__status} body={preview}");
+        }
+    }
+
+    public void AssertRedirectedTo(string expectedPath)
+    {
+        if (__status < 300L || __status >= 400L)
+        {
+            Assert.Fail($"expected a redirect, got status={__status} location={__location}");
+            return;
+        }
+        if (!__location.Contains(expectedPath))
+        {
+            Assert.Fail($"expected Location to contain {expectedPath}, got {__location}");
+        }
+    }
+
+    // `AssertSelect` over the Dom primitive surface (below). Presence
+    // check: the selector matches at least one node. The stub Dom is a
+    // substring matcher, so this stays rough-but-effective for the
+    // scaffold-blog HTML shapes; cardinality kwargs are best-effort
+    // no-ops. A real engine tightens it without changing these sites.
+    public void AssertSelect(string selector)
+    {
+        if (Dom.Select(Dom.Parse(__body), selector).Count == 0)
+        {
+            Assert.Fail($"expected body to match selector {selector}");
+        }
+    }
+
+    // `content` is nullable: a nullable column read (`assert_select "h1",
+    // article.title`) is `string?`, and Rails compares the element's text
+    // against it — nil reads as the empty string, matching `nil.to_s`.
+    public void AssertSelect(string selector, string? content)
+    {
+        var nodes = Dom.Select(Dom.Parse(__body), selector);
+        if (nodes.Count == 0)
+        {
+            Assert.Fail($"expected body to match selector {selector}");
+            return;
+        }
+        if (!nodes.Any(n => Dom.Text(n).Contains(content ?? "")))
+        {
+            Assert.Fail($"expected text {content} under selector {selector}");
+        }
+    }
+
+    // `assert_select "h2", minimum: 1` — the cardinality kwargs arrive as
+    // an options hash; presence is what the stub can honour.
+    public void AssertSelect(string selector, Dictionary<string, object?> opts) =>
+        AssertSelect(selector);
+
+    // `assert_select "#articles" do … end` — the nested assertions run
+    // against the same body (the stub has no scoping).
+    public void AssertSelect(string selector, Action body)
+    {
+        AssertSelect(selector);
+        body();
+    }
+}
+
+// ── Dom primitive surface (the AssertSelect substrate) ─────────────
+//
+// The HTML-query contract AssertSelect lowers to, shared in shape with
+// the Ruby/Kotlin/Swift/TS/Python/Rust/Elixir twins (cross-target
+// contract in runtime/spinel/test/test_helper.rbs). Stub: the substring
+// matcher dressed as a Dom — Select fabricates one synthetic node (the
+// whole document) per fragment occurrence and Text returns it verbatim,
+// so presence / minimum / content checks degrade to exactly the
+// pre-contract behavior. The upgrade path is to swap these three methods
+// for a real HTML parser (AngleSharp) — real nodes, real CSS selectors —
+// touching only this class; the RoundhouseTestCase call sites stay put.
+public static class Dom
+{
+    // Parse an HTML document. Stub: the document *is* its html string.
+    public static string Parse(string html) => html;
+
+    // Nodes matching `selector` within `root` (a document or node). Stub:
+    // one synthetic node (the root's html) per substring-fragment
+    // occurrence.
+    public static List<string> Select(string root, string selector)
+    {
+        var fragment = FragmentFor(selector);
+        var nodes = new List<string>();
+        if (fragment.Length == 0) return nodes;
+        var from = 0;
+        while (true)
+        {
+            var i = root.IndexOf(fragment, from, StringComparison.Ordinal);
+            if (i < 0) break;
+            nodes.Add(root);
+            from = i + fragment.Length;
+        }
+        return nodes;
+    }
+
+    // Concatenated descendant text of a node. Stub: the node verbatim.
+    public static string Text(string node) => node;
+
+    // Loose selector → substring fragment (the stub's rule, replaced by a
+    // real CSS engine on upgrade): "#id" → id="id", ".cls" → cls", "tag"
+    // → <tag. Compound selectors take the first chunk.
+    private static string FragmentFor(string selector)
+    {
+        var first = selector.Split(' ').FirstOrDefault() ?? selector;
+        if (first.StartsWith("#", StringComparison.Ordinal)) return "id=\"" + first.Substring(1) + "\"";
+        if (first.StartsWith(".", StringComparison.Ordinal)) return first.Substring(1) + "\"";
+        return "<" + first;
+    }
+}

scripts/smoke

@@ -237,11 +237,8 @@ case "$TARGET" in
         # case this floor exists to catch. Upgrade to a number if the
         # README's command ever grows a counting flag.
         MIN_TESTS=ran ;;
-    csharp)
-        # KNOWN GAP (#34): csharp emits no test project, so `dotnet test`
-        # executes zero tests. Declared, warned about on every run, and
-        # NOT silent. Set to 21 the moment csharp test emit lands.
-        MIN_TESTS=0 ;;
+    # (csharp's KNOWN-GAP floor of 0 is retired: it now emits `tests/` —
+    # an xUnit project running the same 21 — and takes the default.)
 esac
 if [[ -n "${SMOKE_MIN_TESTS:-}" ]]; then
     MIN_TESTS="$SMOKE_MIN_TESTS"