Seed all four SQL Server system databases in every Simulation so SSMS's msdb-dependent features work: has_dbaccess is now accessibility-aware, and msdb.dbo.syspolicy_system_health_state ships as a real empty view so server-level Policy Health displays clean instead of erroring on no-access.

Author: RyanLamansky

CLAUDE.md

@@ -64,7 +64,7 @@ Readonly struct, up to 4 inline slots (SQL Server's grammar limit). API: `Leaf`,
 Six scopes, one home each. **Add new state to whichever class matches its true scope** — when in doubt, ask who outlives whom. Field rosters live in the source XML docs; this captures only identity + load-bearing contracts.
 
 - **`Simulation`** = server / instance. Holds `SystemHeapTables`, the `Databases` dict, and `ServerCollationName` (`init`-only; defaults `SQL_Latin1_General_CP1_CI_AS`; mirrors `model.collation` — install-time seed for every new `Database`, both the lazy `"simulated"` seed and collation-less bacpac imports; `init` reflects real immutability). Public surface = `Simulation` ctor + `CreateDbConnection()` + `ImportBacpac()` + `AddRemoteSimulation()` + `ServerCollationName` + `ListenAsync()` → `SimulatedNetworkListener`.
-- **`Database`** (internal) = one database. Holds `Schemas`, `CompatibilityLevel`, `CollationName`, the rowversion counter (`@@DBTS`), the MVCC version store, and the principal/permission/extended-property/full-text/DDL-trigger surfaces. `Databases` is seeded at construction with the `master` system database (`database_id` 1, so `USE master` / `master.sys.*` / `master.dbo.<proc>` resolve without an import); the first `CreateDbConnection()` lazily seeds `DefaultDatabaseName` (`"simulated"`) when no *user* database is present, and master is excluded from the initial-database fallback so a fresh connection still lands on `simulated`. Database ids: master = 1, user databases from 5 in name order (real reserves 2-4 for tempdb/model/msdb, unmodeled) — single source of truth is `DbId.DatabasesWithIds`, consumed by `DB_ID`/`DB_NAME`, `sys.databases`, `OBJECT_NAME`, and `DBCC SHRINKDATABASE`. `USE <db>` switches session (Msg 911 on miss); 3-part names route cross-DB reads (`SELECT * FROM other.dbo.t`), but cross-DB writes raise `NotSupportedException` via `BatchContext.RejectCrossDatabaseMutation` — `USE` first.
+- **`Database`** (internal) = one database. Holds `Schemas`, `CompatibilityLevel`, `CollationName`, the rowversion counter (`@@DBTS`), the MVCC version store, and the principal/permission/extended-property/full-text/DDL-trigger surfaces. `Databases` is seeded at construction with all four system databases — `master` / `tempdb` / `model` / `msdb` (so `USE <systemdb>` / `master.sys.*` / `master.dbo.<proc>` / SSMS's `msdb.dbo.syspolicy_system_health_state` all resolve without an import); the first `CreateDbConnection()` lazily seeds `DefaultDatabaseName` (`"simulated"`) when no *user* database is present, and all four system databases are excluded from the initial-database fallback (`Simulation.SystemDatabaseNames`) so a fresh connection still lands on `simulated`. Database ids are a fixed map — master = 1, tempdb = 2, model = 3, msdb = 4; user databases from 5 in name order — single source of truth is `Simulation.SystemDatabaseIds` + `DbId.DatabasesWithIds`, consumed by `DB_ID`/`DB_NAME`, `sys.databases`, `OBJECT_NAME`, and `DBCC SHRINKDATABASE`. `has_dbaccess` is accessibility-aware: 1 for master/tempdb/msdb/user dbs, 0 for `model` (restricted template), NULL for unknown. `#temp` still routes through the connection's `TempTables`, not the seeded `tempdb`. `USE <db>` switches session (Msg 911 on miss); 3-part names route cross-DB reads (`SELECT * FROM other.dbo.t`), but cross-DB writes raise `NotSupportedException` via `BatchContext.RejectCrossDatabaseMutation` — `USE` first.
 - **`Schema`** (internal) = one namespace in a database. Holds the object dicts (`HeapTables` / `Functions` / `Views` / `Procedures` / `Sequences` / `Triggers` — DML triggers share the object namespace) + the type namespace (`TableTypes` / `AliasTypes` / `XmlSchemaCollections`). Schema-qualified refs route through `Database.Schemas[<schema>]`; unqualified falls back to `DefaultSchemaName` (`"dbo"`).
 - **`SimulatedDbConnection`** = session. Holds `@@`-state (`LastIdentity` = `SCOPE_IDENTITY`/`@@IDENTITY`, `LastStatementRowCount` = `@@ROWCOUNT`, `LastErrorNumber` = `@@ERROR`), `CurrentDatabase` / `CurrentTransaction`, per-session `TempTables` (`#foo`, cleared on Dispose), `NestingLevel` (cap 32), `Spid` (≥51), `SessionIsolationLevel`, `LockTimeoutMillis`, `CurrentExecutingThreadId` (same-thread-deadlock detection). Full roster in the source XML docs.
 - **`BatchContext`** (internal, `Parser/`) = one command execution. Owns the `ParserContext` (parse-time scratch) + batch-lifetime runtime state: `Variables`, `TableVariables` (`@t`), `CurrentUndoLog`, `CurrentTableVarUndoLog` (statement-only, disjoint from the tx-scoped log so `ROLLBACK TRAN` skips `@t`), `UdfFrame` / `ProcFrame` (non-null in a UDF/proc body — gates value-form `RETURN`). Exposes the **resolver contract** the parser depends on:

SqlServerSimulator.Tests.SqlClient/SystemDatabaseTests.cs

@@ -0,0 +1,50 @@
+using Microsoft.Data.SqlClient;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Loopback-wire oracle for the SSMS server-level Policy Health connect path:
+/// real SqlClient reads <c>has_dbaccess('msdb')</c> = 1 and then the empty
+/// <c>msdb.dbo.syspolicy_system_health_state</c> view. This is the exact
+/// sequence SSMS issues at connect; before the msdb seed it popped a
+/// permission error. The wire oracle catches TDS-level regressions the
+/// in-process tests can't.
+/// </summary>
+[TestClass]
+public sealed class SystemDatabaseTests
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    [TestMethod]
+    public async Task HasDbAccessMsdb_OverWire_ReturnsOne()
+    {
+        var simulation = new Simulation();
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+
+        await using var command = new SqlCommand("select has_dbaccess('msdb')", connection);
+        AreEqual(1, await command.ExecuteScalarAsync(TestContext.CancellationToken));
+    }
+
+    [TestMethod]
+    public async Task SyspolicyHealthState_OverWire_ReturnsSixColumnsNoRows()
+    {
+        var simulation = new Simulation();
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+
+        await using var command = new SqlCommand(
+            "select * from msdb.dbo.syspolicy_system_health_state", connection);
+        await using var reader = await command.ExecuteReaderAsync(TestContext.CancellationToken);
+
+        AreEqual(6, reader.FieldCount);
+        AreEqual("health_state_id", reader.GetName(0));
+        AreEqual("policy_id", reader.GetName(1));
+        AreEqual("last_run_date", reader.GetName(2));
+        AreEqual("target_query_expression_with_id", reader.GetName(3));
+        AreEqual("target_query_expression", reader.GetName(4));
+        AreEqual("result", reader.GetName(5));
+        IsFalse(await reader.ReadAsync(TestContext.CancellationToken));
+    }
+}

SqlServerSimulator.Tests/Bacpac/BacpacImportTests.cs

@@ -82,9 +82,9 @@ public void ImportBacpac_MultipleBacpacs_AllLandAsSeparateDatabases()
         IsTrue(SimulationHasDatabase(sim, "sales"));
         IsTrue(SimulationHasDatabase(sim, "ops"));
         IsFalse(SimulationHasDatabase(sim, "simulated"));
-        // Three rows: the always-present master system database plus the two
-        // imported user databases.
-        AreEqual(3, sim.ExecuteScalar("SELECT COUNT(*) FROM sys.databases"));
+        // Six rows: the four always-present system databases (master / tempdb
+        // / model / msdb) plus the two imported user databases.
+        AreEqual(6, sim.ExecuteScalar("SELECT COUNT(*) FROM sys.databases"));
         // Both imported databases are queryable via cross-database 3-part
         // names (CrossDatabaseTests covers USE + joins + DML rejection in
         // depth; here we just confirm the per-database row count surfaces).

SqlServerSimulator.Tests/DbIdNameTests.cs

@@ -5,10 +5,11 @@ namespace SqlServerSimulator;
 /// <summary>
 /// Tests for <c>DB_ID([name])</c> and <c>DB_NAME([id])</c>: round-trip the
 /// simulator's database list through the id allocation that
-/// <c>sys.databases.database_id</c> uses — <c>master</c> is always 1, user
-/// databases take 5, 6, … in case-insensitive name order (real SQL Server
-/// reserves 2-4 for tempdb / model / msdb, unmodeled here). NULL argument /
-/// unknown name / unknown id all return NULL.
+/// <c>sys.databases.database_id</c> uses — the four system databases carry
+/// their fixed reserved ids (master = 1, tempdb = 2, model = 3, msdb = 4) and
+/// user databases take 5, 6, … in case-insensitive name order (system-database
+/// coverage lives in <c>SystemDatabaseTests</c>). NULL argument / unknown name
+/// / unknown id all return NULL.
 /// </summary>
 [TestClass]
 public sealed class DbIdNameTests
@@ -60,38 +61,4 @@ public void DbName_NullArg_ReturnsNull()
     [TestMethod]
     public void DbId_DbName_RoundTrip()
         => AreEqual("simulated", new Simulation().ExecuteScalar("select db_name(db_id())"));
-
-    [TestMethod]
-    public void HasDbAccess_HostedDatabase_Returns1()
-        => AreEqual(1, new Simulation().ExecuteScalar("select has_dbaccess('master')"));
-
-    [TestMethod]
-    public void HasDbAccess_CaseInsensitive()
-        => AreEqual(1, new Simulation().ExecuteScalar("select has_dbaccess('SiMuLaTeD')"));
-
-    // SSMS probes msdb at connect to decide whether to surface Agent
-    // features; the simulator doesn't model msdb, so NULL — same as a real
-    // server where the login can't see it.
-    [TestMethod]
-    public void HasDbAccess_UnknownDatabase_ReturnsNull()
-        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select has_dbaccess('msdb')"));
-
-    [TestMethod]
-    public void HasDbAccess_EmptyOrNullName_ReturnsNull()
-    {
-        var simulation = new Simulation();
-        AreEqual(DBNull.Value, simulation.ExecuteScalar("select has_dbaccess('')"));
-        AreEqual(DBNull.Value, simulation.ExecuteScalar("select has_dbaccess(null)"));
-    }
-
-    [TestMethod]
-    public void HasDbAccess_NoArgument_RaisesMsg174()
-    {
-        var ex = new Simulation().AssertSqlError("select has_dbaccess()", 174);
-        AreEqual("The has_dbaccess function requires 1 argument(s).", ex.Message);
-    }
-
-    [TestMethod]
-    public void HasDbAccess_VariableArgument_Resolves()
-        => AreEqual(1, new Simulation().ExecuteScalar("declare @n sysname = 'master' select has_dbaccess(@n)"));
 }