@substrat-run/contract-tests 0.127.0 → 0.129.0

package/dist/scope-host-suite.js

@@ -1516,6 +1516,35 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
             // `poison-a` failed and is backed off: an error on the row, but a retry still due.
             expect(page.entries.some((d) => d.consumer === 'executor:flaky-effector')).toBe(false);
         });
+        it('replays a declared lifecycle over the outbox through the platform verb (#1744)', async () => {
+            // `readLifecycleFlow`'s own suite pins the replay over a hand-built outbox; this
+            // proves the wiring — real emits, on both adapters, read back through `lifecycleFlow`.
+            const stub = await host.getScope(alice, t1, s1);
+            const since = new Date(Date.now() - 60_000).toISOString();
+            await stub.invoke('test/move', { entityId: 'l1', state: 'draft' });
+            await stub.invoke('test/move', { entityId: 'l1', state: 'live' });
+            // No state in the payload: the declared edge says where it went.
+            await stub.invoke('test/move', { entityId: 'l1' });
+            const flow = await host.admin.lifecycleFlow(staff, t1, s1, {
+                entityType: 'test-lifecycle',
+                lifecycle: {
+                    field: 'state',
+                    initial: 'draft',
+                    states: {
+                        draft: { on: { 'test/move': 'live' } },
+                        live: { on: { 'test/move': 'done' } },
+                        done: { terminal: true },
+                    },
+                },
+                since,
+                until: new Date(Date.now() + 60_000).toISOString(),
+            });
+            expect(flow.edges.find((e) => e.from === 'draft' && e.to === 'live').count).toBe(1);
+            expect(flow.edges.find((e) => e.from === 'live' && e.to === 'done').count).toBe(1);
+            expect(flow.states.find((s) => s.state === 'done').current).toBe(1);
+            expect(flow.observation).toMatchObject({ entities: 1, events: 3, inferred: 1, complete: true });
+            expect(flow.totals.finished).toBe(1);
+        });
         // -- scope data introspection: the §5.4 admin-query RPC --------------------
         //
         // A read-only window into a scope's OWN database (the console/dashboard Data
@@ -2166,10 +2195,10 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
                 const dump = await host.admin.exportScope(staff, t1, s1);
                 // Doctor the dump into one captured before the `operation` column existed:
                 // the DDL loses the column and every row loses that cell — exactly what a
-                // dump exported by an older platform carries. The replay's DDL is
-                // authoritative, and KERNEL_DDL's IF NOT EXISTS cannot widen a table the
-                // dump brought, so without the post-replay re-run of the additive
-                // migrations the emit below fails with `no such column: operation`.
+                // dump exported by an older platform carries. The restore builds the outbox
+                // from the kernel's DDL, not the dump's (#1883), and inserts the rows by
+                // column name, so the missing cell reads NULL and the emit below still has
+                // its column.
                 const doctored = dump.tables.map((t) => {
                     if (t.name !== '_substrat_outbox')
                         return t;
@@ -2289,6 +2318,14 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
                         { name: 'MARKER', ddl: 'CREATE TABLE MARKER (id TEXT)', columns: ['id'], rows: [] },
                     ])).rejects.toThrow(/listed twice/);
                 });
+                // A column listed twice is the same shape one level down: the row insert names it twice,
+                // and which of the two cells lands is SQLite's choice, not the dump's. Case-folded, as
+                // SQLite resolves column names that way too (#1883 review).
+                it('refuses a column listed twice in one table, including differing only in case', async () => {
+                    await expect(importForged([
+                        { name: 'marker', ddl: 'CREATE TABLE marker (id TEXT, note TEXT)', columns: ['id', 'note', 'ID'], rows: [] },
+                    ])).rejects.toThrow(/column "ID" in table "marker" is listed twice/);
+                });
                 // Non-vacuous: proves the checks do not simply reject everything, and that a
                 // `;` inside a string literal is not read as a statement boundary — a DEFAULT
                 // of `'a;b'` is legal SQL, and a `split(';')` would refuse it.
@@ -2350,6 +2387,8 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
                 expect(ids).toContain(t2);
             });
             it('restores: a directory diverged past the copy is rewound, and still serves', async () => {
+                const ownRestores = { actor: staff, action: 'restoreDirectory' };
+                const restoresInCopy = (await host.admin.auditLog(staff, ownRestores)).length;
                 const backup = await host.admin.exportDirectory(staff);
                 // Diverge past the copy — a tenant that did not exist when it was taken.
                 const ghost = tenantId.parse(ulid());
@@ -2375,13 +2414,13 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
                 // The restore is audited, in the log it just replaced: the entry after a
                 // restored history is the restore itself, so the seam is legible.
                 //
-                // A wide window on purpose: this asks whether the entry EXISTS, and the 50 it used
-                // to read was incidental. `redrainEvents` now records an intent row per call (#1334
-                // review — the receipt must survive a crash between the reopen and its row), so the
-                // suite writes more admin rows than it did and a narrow window stopped reaching back
-                // this far. Nothing about what is asserted changes.
-                const log = await host.admin.auditLog(staff, { limit: 500 });
-                expect(log.some((e) => e.action === 'restoreDirectory')).toBe(true);
+                // Filtered to THIS suite's restores and read as a delta, never as a window over the
+                // whole log: the log reads oldest-first and is the whole directory's, so a window
+                // stops reaching the entry once enough other rows precede it. A 50-row window did
+                // when the suite's own rows grew (#1334), and a 500-row one did when other test
+                // files sharing the directory ran first (#1899). The copy carries the restores it
+                // had seen, so one more than it held is exactly this one.
+                expect((await host.admin.auditLog(staff, ownRestores)).length).toBe(restoresInCopy + 1);
             });
             // A directory dump is untrusted input exactly as a scope dump is (#1143), and
             // both adapters refuse it with the same words. The DO path always judged it;