@sixb/core 0.1.20 → 0.1.22

package/src/testing/sandboxes-contract.ts

@@ -239,8 +239,9 @@ export function runSandboxesContractSuite(
     })
 
     describe("timeout and abort", () => {
-      test("sleep beyond timeout marks the result timedOut and exits non-zero", async () => {
-        const sandbox = await factory.create()
+      test("a per-call timeout overrides the sandbox's, marks the result timedOut, and exits non-zero", async () => {
+        // The sandbox's own timeout outlasts the command, so only the per-call one can stop it.
+        const sandbox = await factory.create({ timeout: SLEEP_BUDGET_SECONDS * 2 * 1000 })
         try {
           const start = Date.now()
           const result = await sandbox.runCommand("sleep", [String(SLEEP_BUDGET_SECONDS)], {
@@ -271,18 +272,6 @@ export function runSandboxesContractSuite(
           await sandbox.destroy()
         }
       })
-
-      test("per-call timeout overrides sandbox-level timeout", async () => {
-        const sandbox = await factory.create({ timeout: SLEEP_BUDGET_SECONDS * 1000 })
-        try {
-          const result = await sandbox.runCommand("sleep", [String(SLEEP_BUDGET_SECONDS)], {
-            timeout: shortTimeoutMs,
-          })
-          expect(result.timedOut).toBe(true)
-        } finally {
-          await sandbox.destroy()
-        }
-      })
     })
 
     describe("file materialization", () => {

package/src/testing/share-grant-storage-contract.ts

@@ -80,6 +80,21 @@ export function runShareGrantStorageContractSuite<TStorage extends ShareGrantSto
       })
     })
 
+    test("reads several grants at once, in the order asked", async () => {
+      await withStorage(async (storage) => {
+        const first = await storage.create(grantInput())
+        const second = await storage.create(
+          grantInput({ id: "shr_2", tokenHash: "b".repeat(64), definitionId: "invoice" })
+        )
+        await storage.create(grantInput({ id: "shr_3", projectId: "other-project" }))
+
+        await expect(
+          storage.getByIds({ projectId, ids: ["shr_2", "missing", "shr_1", "shr_2", "shr_3"] })
+        ).resolves.toEqual([second, first])
+        await expect(storage.getByIds({ projectId, ids: [] })).resolves.toEqual([])
+      })
+    })
+
     test("lists a bounded deterministic page with total and hasMore", async () => {
       await withStorage(async (storage) => {
         await storage.create(grantInput({ id: "shr_a", tokenHash: "b".repeat(64) }))
@@ -109,7 +124,7 @@ export function runShareGrantStorageContractSuite<TStorage extends ShareGrantSto
       })
     })
 
-    test("filters by project, definition, target, expiry, and revocation", async () => {
+    test("filters by project, definition, target, expiry instant, and revocation", async () => {
       await withStorage(async (storage) => {
         await storage.create(grantInput({ id: "active", tokenHash: "b".repeat(64) }))
         await storage.create(
@@ -138,12 +153,17 @@ export function runShareGrantStorageContractSuite<TStorage extends ShareGrantSto
           revokedBy: { type: "user", id: "usr_revoker" },
         })
         await storage.create(grantInput({ projectId: "other-project" }))
+        // A grant is inactive from the exact instant it expires.
+        const now = new Date("2026-08-19T13:00:00.000Z")
+        await storage.create(
+          grantInput({ id: "expires-now", tokenHash: "a".repeat(64), expiresAt: now })
+        )
 
         const filter = {
           projectId,
           definitionId: "published-report",
           target: { objectTypeId: "Report", primaryId: "report-1" },
-          now: new Date("2026-08-19T13:00:00.000Z"),
+          now,
         }
         await expect(storage.list(filter)).resolves.toMatchObject({
           grants: [{ id: "active" }],
@@ -155,20 +175,12 @@ export function runShareGrantStorageContractSuite<TStorage extends ShareGrantSto
           includeExpired: true,
           includeRevoked: true,
         })
-        expect(allStates.grants.map((grant) => grant.id)).toEqual(["revoked", "expired", "active"])
-      })
-    })
-
-    test("treats the exact expiry instant as inactive", async () => {
-      await withStorage(async (storage) => {
-        await storage.create(grantInput())
-        await expect(storage.list({ projectId, now: expiresAt })).resolves.toMatchObject({
-          grants: [],
-          total: 0,
-        })
-        await expect(
-          storage.list({ projectId, now: expiresAt, includeExpired: true })
-        ).resolves.toMatchObject({ grants: [{ id: "shr_1" }], total: 1 })
+        expect(allStates.grants.map((grant) => grant.id)).toEqual([
+          "revoked",
+          "expires-now",
+          "expired",
+          "active",
+        ])
       })
     })
 

package/src/testing/share-session-storage-contract.ts

@@ -74,6 +74,10 @@ export function runShareSessionStorageContractSuite<TStorage extends ShareSessio
       await withStorage(async (storage) => {
         await storage.create(sessionInput())
         const valid = renewalInput({ expiresAt: new Date("2026-08-20T12:10:00.000Z") })
+        // The exact inactivity expiry is already expired.
+        await expect(
+          storage.renewIfValid({ ...valid, now: new Date(expiresAt) })
+        ).resolves.toBeNull()
         await expect(storage.renewIfValid(valid)).resolves.toMatchObject({
           id: "shs_1",
           expiresAt: new Date("2026-08-20T12:10:00.000Z"),
@@ -110,20 +114,6 @@ export function runShareSessionStorageContractSuite<TStorage extends ShareSessio
       })
     })
 
-    test("treats the exact inactivity expiry as expired", async () => {
-      await withStorage(async (storage) => {
-        await storage.create(sessionInput())
-        await expect(
-          storage.renewIfValid(
-            renewalInput({
-              now: new Date(expiresAt),
-              expiresAt: new Date("2026-08-20T12:10:00.000Z"),
-            })
-          )
-        ).resolves.toBeNull()
-      })
-    })
-
     test("keeps concurrent renewals monotonic", async () => {
       await withStorage(async (storage) => {
         await storage.create(sessionInput())