["DebugTable"] = null,

["TestRunner:ResponseTempTable:DebugTable"] = "Debugging aid: when set (e.g. \"_responses_debug\"), every captured response is ALSO mirrored into a PERMANENT table with this name — written on a separate autocommit connection, so it survives the test's rollback and connection close and can be examined in a query editor after the run.\nRecreated at the start of every run (holds the LAST run). ONE table covers everything: each HTTP block adds one row, with the block column recording that block's response-table name (Name, MultiNamePattern ordinal, or the # @response name) alongside test_file, method, path, status, body, content_type, headers, is_success, captured_at. Temp-table semantics unchanged. Do not enable in CI. Null (default) = off.",

// The debug mirror writes on its own POOLED connections (unlike test connections, which are

// deliberately non-pooled) — autocommit, outside any test transaction.

private readonly string _debugConnString;

private bool _debugTableWarned;

_debugConnString = baseConnectionString;

await EnsureDebugTableAsync(ct); // debug mirror holds the LAST run — recreated per run

sr = await InvokeHttpStepAsync(conn, http, ResolveResponseTable(http, httpOrdinal, httpTotal), lookup, contextName, ct);

NpgsqlConnection conn, HttpStep step, string responseTable, IReadOnlyDictionary<string, RoutineEndpoint> lookup, string testFile, CancellationToken ct)

if (string.IsNullOrWhiteSpace(_opt.ResponseTempTable.DebugTable) is false)

{

await MirrorResponseAsync(testFile, responseTable, step, response, ct);

}

/// <summary>

/// Debug mirror (ResponseTempTable.DebugTable): recreate the PERMANENT mirror table at the start of a

/// run and print the do-not-use-in-CI warning once. Runs on its own autocommit connection, so mirrored

/// rows survive test rollbacks and connection closes — that is the whole point.

/// </summary>

private async Task EnsureDebugTableAsync(CancellationToken ct)

{

var table = _opt.ResponseTempTable.DebugTable;

if (string.IsNullOrWhiteSpace(table))

{

return;

}

if (!ValidateIdentifier(table))

{

throw new InvalidOperationException($"invalid ResponseTempTable.DebugTable name '{table}'");

}

if (_debugTableWarned is false)

{

_debugTableWarned = true;

_out.Line($"WARNING: ResponseTempTable.DebugTable is enabled — every captured response is written to the PERMANENT table \"{table}\" (debugging aid; do not enable in CI)", ConsoleColor.Yellow);

_log?.LogWarning("ResponseTempTable.DebugTable enabled: mirroring responses into permanent table {Table}", table);

}

await using var conn = new NpgsqlConnection(_debugConnString);

await conn.OpenAsync(ct);

await using var cmd = conn.CreateCommand();

cmd.CommandText = $"""

// The debug connection is plain Npgsql (SQL rewriting enabled is irrelevant here — no parameters),

// but the client disables rewriting globally, so run the two statements separately.

foreach (var statement in cmd.CommandText.Split(';', StringSplitOptions.RemoveEmptyEntries))

{

await using var one = new NpgsqlCommand(statement, conn);

await one.ExecuteNonQueryAsync(ct);

}

}

/// <summary>Best-effort mirror insert — a failure warns but never fails the test.</summary>

private async Task MirrorResponseAsync(string testFile, string block, HttpStep step, RoutineInvokeResult response, CancellationToken ct)

{

try

{

await using var conn = new NpgsqlConnection(_debugConnString);

await conn.OpenAsync(ct);

await using var ins = new NpgsqlCommand(

$"insert into \"{_opt.ResponseTempTable.DebugTable}\" (test_file, block, method, path, status, body, content_type, headers, is_success) values ($1,$2,$3,$4,$5,$6,$7,$8::jsonb,$9)",

conn);

ins.Parameters.AddWithValue(testFile);

ins.Parameters.AddWithValue(block);

ins.Parameters.AddWithValue(step.Method.ToString());

ins.Parameters.AddWithValue(step.Path);

ins.Parameters.AddWithValue(response.StatusCode);

ins.Parameters.AddWithValue((object?)response.Body ?? DBNull.Value);

ins.Parameters.AddWithValue((object?)response.ContentType ?? DBNull.Value);

ins.Parameters.AddWithValue((object?)response.Headers ?? DBNull.Value);

ins.Parameters.AddWithValue(response.IsSuccess);

await ins.ExecuteNonQueryAsync(ct);

}

catch (Exception ex)

{

_log?.LogWarning("debug table write failed for {File}: {Message}", testFile, ex.Message);

}

}

/// <summary>

/// Debugging aid: when set (e.g. "_responses_debug"), every captured response is ALSO mirrored into a

/// PERMANENT table with this name — written on a separate autocommit connection, so it survives the

/// test's rollback and the connection close, and can be examined in a query editor after the run.

/// Recreated at the start of every run (always holds the LAST run). ONE table covers all blocks and

/// files: each HTTP block adds one row, with the block column recording that block's response-table

/// name (<see cref="Name"/>, a <see cref="MultiNamePattern"/> ordinal, or the `# @response` name)

/// alongside test_file/method/path and the response columns. The temp-table semantics are unchanged.

/// Null (default) = off. Do not enable in CI. In the fresh-test-database workflow combine with Keep,

/// or teardown drops the database (and the mirror with it).

/// </summary>

public string? DebugTable { get; set; } = null;

"DebugTable": null,

**Debugging captured responses** — temp tables vanish with the test's rollback and connection, so you cannot inspect them afterwards (and re-issuing the request from an `.http` file cannot reproduce a response that depended on the test's uncommitted fixtures). Set **`ResponseTempTable.DebugTable`** (e.g. `"_responses_debug"`; default `null` = off) and every captured response is **also mirrored into a permanent table** — written on a separate autocommit connection, immune to rollbacks, recreated at the start of every run so it always holds the last run. One table covers everything: each HTTP block adds one row, with `test_file`, `block` (that block's response-table name — `_response`, a `_response_{n}` ordinal, or the `# @response` name), `method`, `path`, `status`, `body`, `content_type`, `headers`, `is_success`, and `captured_at` — so after a run you can open a query editor and dig into any response with jsonb operators. The temp-table semantics are unchanged; enabling it prints a loud warning (debugging aid — do not enable in CI). In the fresh-test-database workflow combine it with `Keep: true`, or teardown drops the database and the mirror with it.

"DebugTable": null, // debugging aid: ALSO mirror every response into this PERMANENT table (survives rollback; last run; not for CI)