@substrat-run/contract-tests 0.126.0 → 0.128.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.
@@ -5316,9 +5353,12 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
                     await move(folder('f1'), folder('fr'), folder('f3'));
                 });
                 it('terminates on a graph that is already cyclic', async () => {
-                    // `link` does not refuse a cycle (a follow-up), so one can exist: c1 ⇄ c2.
-                    await link(folder('c1'), folder('c2'));
-                    await link(folder('c2'), folder('c1'));
+                    // `link` refuses a cycle too now (#1875), so the only way one can exist is a
+                    // restored dump — c1 ⇄ c2, planted the same way an undeclared or expired edge is.
+                    await plant([
+                        { subject: 'folder:c1', object: 'folder:c2' },
+                        { subject: 'folder:c2', object: 'folder:c1' },
+                    ]);
                     await link(folder('cx'), folder('fr'));
                     await move(folder('cx'), folder('fr'), folder('c1'));
                     expect(await edges(folder('cx'))).toEqual([
@@ -5329,6 +5369,53 @@ export function scopeHostContractSuite(adapterName, makeFixture, opts = {}) {
                     await expectRefusal(move(folder('c1'), folder('c2'), folder('cx')), 'validation_failed', /its own ancestor/);
                 });
             });
+            /**
+             * #1875: `ctx.link` refuses a cycle the same way `ctx.relink` does, via the same shared
+             * walk (`entity-edges.ts`'s `assertNoCycle`) — a behaviour change to a shipped verb, since
+             * a module that already wrote one (by accident) now fails where it used to succeed.
+             */
+            describe("link refuses a cycle, sharing relink's walk (#1875)", () => {
+                // lr ← l1 ← l2, and a sibling subtree lr ← l3.
+                beforeAll(async () => {
+                    await link(folder('l1'), folder('lr'));
+                    await link(folder('l2'), folder('l1'));
+                    await link(folder('l3'), folder('lr'));
+                });
+                it('refuses linking a parent that is the child itself', async () => {
+                    await expectRefusal(link(folder('l1'), folder('l1')), 'validation_failed', /its own ancestor/);
+                    expect(await edges(folder('l1'))).toEqual([{ object: 'folder:lr', revoked: false }]);
+                });
+                it('refuses linking into its own descendant', async () => {
+                    // lr is an ancestor of l2 (lr ← l1 ← l2); linking lr under l2 would make lr its own
+                    // descendant.
+                    await expectRefusal(link(folder('lr'), folder('l2')), 'validation_failed', /its own ancestor/);
+                    expect(await edges(folder('lr'))).toEqual([]);
+                });
+                it('the twin: a link into a sibling subtree still succeeds', async () => {
+                    await link(folder('l2'), folder('l3'));
+                    expect(await edges(folder('l2'))).toEqual([
+                        { object: 'folder:l1', revoked: false },
+                        { object: 'folder:l3', revoked: false },
+                    ]);
+                });
+                it('an already-cyclic graph (planted via export/restore) terminates instead of looping', async () => {
+                    // `link` refuses a cycle now, so the only way one exists is a restored dump.
+                    await plant([
+                        { subject: 'folder:lc1', object: 'folder:lc2' },
+                        { subject: 'folder:lc2', object: 'folder:lc1' },
+                    ]);
+                    await link(folder('lc3'), folder('lr'));
+                    // lc1's own chain (lc1 → lc2 → lc1 → …) never reaches lc3, so this still succeeds —
+                    // the point is that the walk finishes at all instead of hanging on the cycle.
+                    await link(folder('lc3'), folder('lc1'));
+                    expect(await edges(folder('lc3'))).toEqual([
+                        { object: 'folder:lc1', revoked: false },
+                        { object: 'folder:lr', revoked: false },
+                    ]);
+                    // A member of the cycle still refuses becoming its own ancestor.
+                    await expectRefusal(link(folder('lc1'), folder('lc1')), 'validation_failed', /its own ancestor/);
+                });
+            });
             it('a tombstone survives export, restore and snapshot — never resurrected', async () => {
                 await link(item('rl10'), box('rb1'));
                 await move(item('rl10'), box('rb1'), box('rb2'));