@graffiti-garden/api 0.2.7 → 0.2.9

package/tests/crud.ts

@@ -1,4 +1,4 @@
-import { it, expect, describe } from "vitest";
+import { it, expect, describe, beforeEach } from "vitest";
 import type {
   Graffiti,
   GraffitiSession,
@@ -16,18 +16,27 @@ import { randomPutObject, randomString } from "./utils";
 
 export const graffitiCRUDTests = (
   useGraffiti: () => Pick<Graffiti, "put" | "get" | "delete" | "patch">,
-  useSession1: () => GraffitiSession,
-  useSession2: () => GraffitiSession,
+  useSession1: () => GraffitiSession | Promise<GraffitiSession>,
+  useSession2: () => GraffitiSession | Promise<GraffitiSession>,
 ) => {
-  describe(
+  describe.concurrent(
     "CRUD",
     {
       timeout: 20000,
     },
     () => {
+      let graffiti: ReturnType<typeof useGraffiti>;
+      let session: GraffitiSession;
+      let session1: GraffitiSession;
+      let session2: GraffitiSession;
+      beforeEach(async () => {
+        graffiti = useGraffiti();
+        session1 = await useSession1();
+        session = session1;
+        session2 = await useSession2();
+      });
+
       it("put, get, delete", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
         const value = {
           something: "hello, world~ c:",
         };
@@ -63,7 +72,7 @@ export const graffitiCRUDTests = (
         expect(beforeReplaced.name).toEqual(previous.name);
         expect(beforeReplaced.actor).toEqual(previous.actor);
         expect(beforeReplaced.source).toEqual(previous.source);
-        expect(beforeReplaced.lastModified).toBeGreaterThan(
+        expect(beforeReplaced.lastModified).toBeGreaterThanOrEqual(
           gotten.lastModified,
         );
 
@@ -77,7 +86,7 @@ export const graffitiCRUDTests = (
         const beforeDeleted = await graffiti.delete(afterReplaced, session);
         expect(beforeDeleted.tombstone).toEqual(true);
         expect(beforeDeleted.value).toEqual(newValue);
-        expect(beforeDeleted.lastModified).toBeGreaterThan(
+        expect(beforeDeleted.lastModified).toBeGreaterThanOrEqual(
           beforeReplaced.lastModified,
         );
 
@@ -87,9 +96,6 @@ export const graffitiCRUDTests = (
       });
 
       it("get non-existant", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
-
         const putted = await graffiti.put(randomPutObject(), session);
         await expect(
           graffiti.get(
@@ -103,10 +109,6 @@ export const graffitiCRUDTests = (
       });
 
       it("put, get, delete with wrong actor", async () => {
-        const graffiti = useGraffiti();
-        const session1 = useSession1();
-        const session2 = useSession2();
-
         await expect(
           graffiti.put(
             { value: {}, channels: [], actor: session2.actor },
@@ -129,9 +131,6 @@ export const graffitiCRUDTests = (
       });
 
       it("put and get with schema", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
-
         const schema = {
           properties: {
             value: {
@@ -166,9 +165,6 @@ export const graffitiCRUDTests = (
       });
 
       it("put and get with invalid schema", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
-
         const putted = await graffiti.put({ value: {}, channels: [] }, session);
         await expect(
           graffiti.get(putted, {
@@ -183,9 +179,6 @@ export const graffitiCRUDTests = (
       });
 
       it("put and get with wrong schema", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
-
         const putted = await graffiti.put(
           {
             value: {
@@ -212,10 +205,6 @@ export const graffitiCRUDTests = (
       });
 
       it("put and get with empty access control", async () => {
-        const graffiti = useGraffiti();
-        const session1 = useSession1();
-        const session2 = useSession2();
-
         const value = {
           um: "hi",
         };
@@ -244,10 +233,6 @@ export const graffitiCRUDTests = (
       });
 
       it("put and get with specific access control", async () => {
-        const graffiti = useGraffiti();
-        const session1 = useSession1();
-        const session2 = useSession2();
-
         const value = {
           um: "hi",
         };
@@ -282,14 +267,14 @@ export const graffitiCRUDTests = (
       });
 
       it("patch value", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
-
         const value = {
           something: "hello, world~ c:",
         };
         const putted = await graffiti.put({ value, channels: [] }, session);
 
+        // Wait just a bit to make sure the lastModified is different
+        await new Promise((resolve) => setTimeout(resolve, 10));
+
         const patch: GraffitiPatch = {
           value: [
             { op: "replace", path: "/something", value: "goodbye, world~ :c" },
@@ -298,6 +283,7 @@ export const graffitiCRUDTests = (
         const beforePatched = await graffiti.patch(patch, putted, session);
         expect(beforePatched.value).toEqual(value);
         expect(beforePatched.tombstone).toBe(true);
+        expect(beforePatched.lastModified).toBeGreaterThan(putted.lastModified);
 
         const gotten = await graffiti.get(putted, {});
         expect(gotten.value).toEqual({
@@ -309,9 +295,6 @@ export const graffitiCRUDTests = (
       });
 
       it("patch deleted object", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
-
         const putted = await graffiti.put(randomPutObject(), session);
         const deleted = await graffiti.delete(putted, session);
         await expect(
@@ -320,9 +303,6 @@ export const graffitiCRUDTests = (
       });
 
       it("deep patch", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
-
         const value = {
           something: {
             another: {
@@ -361,9 +341,6 @@ export const graffitiCRUDTests = (
       });
 
       it("patch channels", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
-
         const channelsBefore = [randomString()];
         const channelsAfter = [randomString()];
 
@@ -383,9 +360,6 @@ export const graffitiCRUDTests = (
       });
 
       it("patch 'increment' with test", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
-
         const putted = await graffiti.put(
           {
             value: {
@@ -435,8 +409,6 @@ export const graffitiCRUDTests = (
       });
 
       it("invalid patch", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
         const object = randomPutObject();
         const putted = await graffiti.put(object, session);
 
@@ -455,8 +427,6 @@ export const graffitiCRUDTests = (
       });
 
       it("patch channels to be wrong", async () => {
-        const graffiti = useGraffiti();
-        const session = useSession1();
         const object = randomPutObject();
         object.allowed = [randomString()];
         const putted = await graffiti.put(object, session);

package/tests/discover.ts

@@ -1,4 +1,4 @@
-import { it, expect, describe, assert } from "vitest";
+import { it, expect, describe, assert, beforeEach } from "vitest";
 import type {
   Graffiti,
   GraffitiSession,
@@ -8,19 +8,27 @@ import { randomString, nextStreamValue, randomPutObject } from "./utils";
 
 export const graffitiDiscoverTests = (
   useGraffiti: () => Pick<Graffiti, "discover" | "put" | "delete" | "patch">,
-  useSession1: () => GraffitiSession,
-  useSession2: () => GraffitiSession,
+  useSession1: () => GraffitiSession | Promise<GraffitiSession>,
+  useSession2: () => GraffitiSession | Promise<GraffitiSession>,
 ) => {
-  describe("discover", { timeout: 20000 }, () => {
+  describe.concurrent("discover", { timeout: 20000 }, () => {
+    let graffiti: ReturnType<typeof useGraffiti>;
+    let session: GraffitiSession;
+    let session1: GraffitiSession;
+    let session2: GraffitiSession;
+    beforeEach(async () => {
+      graffiti = useGraffiti();
+      session1 = await useSession1();
+      session = session1;
+      session2 = await useSession2();
+    });
+
     it("discover nothing", async () => {
-      const graffiti = useGraffiti();
       const iterator = graffiti.discover([], {});
       expect(await iterator.next()).toHaveProperty("done", true);
     });
 
     it("discover single", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
       const object = randomPutObject();
 
       const putted = await graffiti.put(object, session);
@@ -39,8 +47,6 @@ export const graffitiDiscoverTests = (
     });
 
     it("discover wrong channel", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
       const object = randomPutObject();
       await graffiti.put(object, session);
       const iterator = graffiti.discover([randomString()], {});
@@ -48,10 +54,6 @@ export const graffitiDiscoverTests = (
     });
 
     it("discover not allowed", async () => {
-      const graffiti = useGraffiti();
-      const session1 = useSession1();
-      const session2 = useSession2();
-
       const object = randomPutObject();
       object.allowed = [randomString(), randomString()];
       const putted = await graffiti.put(object, session1);
@@ -73,10 +75,6 @@ export const graffitiDiscoverTests = (
     });
 
     it("discover allowed", async () => {
-      const graffiti = useGraffiti();
-      const session1 = useSession1();
-      const session2 = useSession2();
-
       const object = randomPutObject();
       object.allowed = [randomString(), session2.actor, randomString()];
       const putted = await graffiti.put(object, session1);
@@ -93,10 +91,6 @@ export const graffitiDiscoverTests = (
 
     for (const prop of ["name", "actor", "lastModified"] as const) {
       it(`discover for ${prop}`, async () => {
-        const graffiti = useGraffiti();
-        const session1 = useSession1();
-        const session2 = useSession2();
-
         const object1 = randomPutObject();
         const putted1 = await graffiti.put(object1, session1);
 
@@ -123,9 +117,6 @@ export const graffitiDiscoverTests = (
     }
 
     it("discover with lastModified range", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
-
       const object = randomPutObject();
       const putted1 = await graffiti.put(object, session);
       // Make sure the lastModified is different
@@ -219,10 +210,6 @@ export const graffitiDiscoverTests = (
     });
 
     it("discover schema allowed, as and not as owner", async () => {
-      const graffiti = useGraffiti();
-      const session1 = useSession1();
-      const session2 = useSession2();
-
       const object = randomPutObject();
       object.allowed = [randomString(), session2.actor, randomString()];
       await graffiti.put(object, session1);
@@ -315,10 +302,6 @@ export const graffitiDiscoverTests = (
     });
 
     it("discover schema channels, as and not as owner", async () => {
-      const graffiti = useGraffiti();
-      const session1 = useSession1();
-      const session2 = useSession2();
-
       const object = randomPutObject();
       object.channels = [randomString(), randomString(), randomString()];
       await graffiti.put(object, session1);
@@ -411,9 +394,6 @@ export const graffitiDiscoverTests = (
     });
 
     it("discover query for empty allowed", async () => {
-      const graffiti = useGraffiti();
-      const session1 = useSession1();
-
       const publicO = randomPutObject();
 
       const publicSchema = {
@@ -445,9 +425,6 @@ export const graffitiDiscoverTests = (
     });
 
     it("discover query for values", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
-
       const object1 = randomPutObject();
       object1.value = { test: randomString() };
       await graffiti.put(object1, session);
@@ -486,9 +463,6 @@ export const graffitiDiscoverTests = (
     });
 
     it("discover for deleted content", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
-
       const object = randomPutObject();
       const putted = await graffiti.put(object, session);
       const deleted = await graffiti.delete(putted, session);
@@ -506,9 +480,6 @@ export const graffitiDiscoverTests = (
     it("discover for replaced channels", async () => {
       // Do this a bunch to check for concurrency issues
       for (let i = 0; i < 10; i++) {
-        const graffiti = useGraffiti();
-        const session = useSession1();
-
         const object1 = randomPutObject();
         const putted = await graffiti.put(object1, session);
         const object2 = randomPutObject();
@@ -548,8 +519,6 @@ export const graffitiDiscoverTests = (
     });
 
     it("discover for patched allowed", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
       const object = randomPutObject();
       const putted = await graffiti.put(object, session);
       await graffiti.patch(
@@ -569,9 +538,6 @@ export const graffitiDiscoverTests = (
     });
 
     it("put concurrently and discover one", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
-
       const object = randomPutObject();
       object.name = randomString();
 

package/tests/location.ts

@@ -6,7 +6,7 @@ import { randomString } from "./utils";
 export const graffitiLocationTests = (
   useGraffiti: () => Pick<Graffiti, "locationToUri" | "uriToLocation">,
 ) => {
-  describe("URI and location conversion", () => {
+  describe.concurrent("URI and location conversion", () => {
     it("location to uri and back", async () => {
       const graffiti = useGraffiti();
       const location = {

package/tests/orphans.ts

@@ -1,4 +1,4 @@
-import { it, expect, describe, assert } from "vitest";
+import { it, expect, describe, assert, beforeEach } from "vitest";
 import type { Graffiti, GraffitiSession } from "@graffiti-garden/api";
 import { randomPutObject, randomString } from "./utils";
 
@@ -7,14 +7,22 @@ export const graffitiOrphanTests = (
     Graffiti,
     "recoverOrphans" | "put" | "delete" | "patch"
   >,
-  useSession1: () => GraffitiSession,
-  useSession2: () => GraffitiSession,
+  useSession1: () => GraffitiSession | Promise<GraffitiSession>,
+  useSession2: () => GraffitiSession | Promise<GraffitiSession>,
 ) => {
-  describe("recoverOrphans", () => {
-    it("list orphans", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
+  describe("recoverOrphans", { timeout: 20000 }, () => {
+    let graffiti: ReturnType<typeof useGraffiti>;
+    let session: GraffitiSession;
+    let session1: GraffitiSession;
+    let session2: GraffitiSession;
+    beforeEach(async () => {
+      graffiti = useGraffiti();
+      session1 = await useSession1();
+      session = session1;
+      session2 = await useSession2();
+    });
 
+    it("list orphans", async () => {
       const existingOrphans: string[] = [];
       const orphanIterator1 = graffiti.recoverOrphans({}, session);
       for await (const orphan of orphanIterator1) {
@@ -39,13 +47,13 @@ export const graffitiOrphanTests = (
     });
 
     it("replaced orphan, no longer", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
-
       const object = randomPutObject();
       object.channels = [];
       const putOrphan = await graffiti.put(object, session);
 
+      // Wait for the put to be processed
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
       const putNotOrphan = await graffiti.put(
         {
           ...putOrphan,
@@ -55,6 +63,7 @@ export const graffitiOrphanTests = (
         session,
       );
       expect(putNotOrphan.name).toBe(putOrphan.name);
+      expect(putNotOrphan.lastModified).toBeGreaterThan(putOrphan.lastModified);
 
       const orphanIterator = graffiti.recoverOrphans({}, session);
       let numResults = 0;

package/tests/synchronize.ts

@@ -1,16 +1,26 @@
-import { it, expect, describe, assert } from "vitest";
+import { it, expect, describe, assert, beforeEach } from "vitest";
 import type { GraffitiFactory, GraffitiSession } from "@graffiti-garden/api";
 import { randomPutObject, randomString } from "./utils";
 
 export const graffitiSynchronizeTests = (
   useGraffiti: GraffitiFactory,
-  useSession1: () => GraffitiSession,
-  useSession2: () => GraffitiSession,
+  useSession1: () => GraffitiSession | Promise<GraffitiSession>,
+  useSession2: () => GraffitiSession | Promise<GraffitiSession>,
 ) => {
-  describe("synchronizeDiscover", () => {
+  describe.concurrent("synchronizeDiscover", () => {
+    let graffiti: ReturnType<typeof useGraffiti>;
+    let session: GraffitiSession;
+    let session1: GraffitiSession;
+    let session2: GraffitiSession;
+    beforeEach(async () => {
+      graffiti = useGraffiti();
+      session1 = await useSession1();
+      session = session1;
+      session2 = await useSession2();
+    });
+
     it("get", async () => {
       const graffiti1 = useGraffiti();
-      const session = useSession1();
 
       const object = randomPutObject();
       const channels = object.channels.slice(1);
@@ -31,9 +41,6 @@ export const graffitiSynchronizeTests = (
     });
 
     it("put", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
-
       const beforeChannel = randomString();
       const afterChannel = randomString();
       const sharedChannel = randomString();
@@ -97,9 +104,6 @@ export const graffitiSynchronizeTests = (
     });
 
     it("patch", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
-
       const beforeChannel = randomString();
       const afterChannel = randomString();
       const sharedChannel = randomString();
@@ -178,9 +182,6 @@ export const graffitiSynchronizeTests = (
     });
 
     it("delete", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
-
       const channels = [randomString(), randomString(), randomString()];
 
       const oldValue = { hello: "world" };
@@ -209,10 +210,6 @@ export const graffitiSynchronizeTests = (
     });
 
     it("not allowed", async () => {
-      const graffiti = useGraffiti();
-      const session1 = useSession1();
-      const session2 = useSession2();
-
       const allChannels = [randomString(), randomString(), randomString()];
       const channels = allChannels.slice(1);
 
@@ -261,11 +258,19 @@ export const graffitiSynchronizeTests = (
     });
   });
 
-  describe("synchronizeGet", () => {
-    it("replace, delete", async () => {
-      const graffiti = useGraffiti();
-      const session = useSession1();
+  describe.concurrent("synchronizeGet", () => {
+    let graffiti: ReturnType<typeof useGraffiti>;
+    let session: GraffitiSession;
+    let session1: GraffitiSession;
+    let session2: GraffitiSession;
+    beforeEach(async () => {
+      graffiti = useGraffiti();
+      session1 = await useSession1();
+      session = session1;
+      session2 = await useSession2();
+    });
 
+    it("replace, delete", async () => {
       const object = randomPutObject();
       const putted = await graffiti.put(object, session);
 
@@ -310,10 +315,6 @@ export const graffitiSynchronizeTests = (
     });
 
     it("not allowed", async () => {
-      const graffiti = useGraffiti();
-      const session1 = useSession1();
-      const session2 = useSession2();
-
       const object = randomPutObject();
       const putted = await graffiti.put(object, session1);