test: e2e case

deno.jsonc

···
 {
   "workspace": [
     "packages/*"
-  ]
+  ],
+  "imports": {
+    "@std/expect": "jsr:@std/expect@^1.0.17",
+    "@atcute/lexicons": "npm:@atcute/lexicons@^1.2.2"
+  }
 }

deno.lock

···
     }
   },
   "workspace": {
+    "dependencies": [
+      "jsr:@std/expect@^1.0.17",
+      "npm:@atcute/lexicons@^1.2.2"
+    ],
     "members": {
       "packages/consumer": {
         "dependencies": [

e2e.test.ts

···
+import { expect } from "@std/expect";
+import { createConsumer } from "@cistern/consumer";
+import { createProducer } from "@cistern/producer";
+import type { Handle } from "@atcute/lexicons";
+
+/**
+ * End-to-end integration test for Cistern
+ *
+ * This test requires the following environment variables:
+ * - CISTERN_HANDLE: Your Bluesky handle (e.g., "user.bsky.social")
+ * - CISTERN_APP_PASSWORD: Your app password
+ *
+ * To run this test:
+ * ```bash
+ * CISTERN_HANDLE="your.handle" CISTERN_APP_PASSWORD="your-app-password" deno test --allow-env --allow-net e2e.test.ts
+ * ```
+ */
+
+const SKIP_E2E = !Deno.env.get("CISTERN_HANDLE") ||
+  !Deno.env.get("CISTERN_APP_PASSWORD");
+
+Deno.test({
+  name: "E2E: Full encryption workflow",
+  ignore: SKIP_E2E,
+  async fn(t) {
+    const handle = Deno.env.get("CISTERN_HANDLE") as Handle;
+    const appPassword = Deno.env.get("CISTERN_APP_PASSWORD")!;
+
+    let consumer: Awaited<ReturnType<typeof createConsumer>>;
+    let producer: Awaited<ReturnType<typeof createProducer>>;
+    let keypair: Awaited<ReturnType<typeof consumer.generateKeyPair>>;
+    let itemUri: string;
+    let testMessage: string;
+
+    await t.step("Create consumer", async () => {
+      consumer = await createConsumer({
+        handle,
+        appPassword,
+      });
+
+      expect(consumer.did).toBeDefined();
+      expect(consumer.rpc).toBeDefined();
+    });
+
+    await t.step("Generate keypair", async () => {
+      keypair = await consumer.generateKeyPair();
+
+      expect(keypair.privateKey).toBeInstanceOf(Uint8Array);
+      expect(keypair.publicKey).toBeDefined();
+      expect(keypair.publicKey).toContain("app.cistern.lexicon.pubkey");
+    });
+
+    try {
+      await t.step("Create producer with public key", async () => {
+        const publicKeyRkey = keypair.publicKey.split("/").pop()!;
+        producer = await createProducer({
+          handle,
+          appPassword,
+          publicKey: publicKeyRkey,
+        });
+
+        expect(producer.publicKey).toBeDefined();
+        expect(producer.publicKey?.uri).toEqual(keypair.publicKey);
+      });
+
+      await t.step("Create encrypted item", async () => {
+        testMessage = `E2E Test - ${new Date().toISOString()}`;
+        itemUri = await producer.createItem(testMessage);
+
+        expect(itemUri).toBeDefined();
+        expect(itemUri).toContain("app.cistern.lexicon.item");
+      });
+
+      await t.step("List and decrypt items", async () => {
+        const items = [];
+        for await (const item of consumer.listItems()) {
+          items.push(item);
+        }
+
+        expect(items.length).toBeGreaterThan(0);
+
+        const ourItem = items.find((item) => item.text === testMessage);
+        expect(ourItem).toBeDefined();
+        expect(ourItem!.text).toEqual(testMessage);
+      });
+
+      await t.step("Delete item", async () => {
+        const itemRkey = itemUri.split("/").pop()!;
+        await consumer.deleteItem(itemRkey);
+
+        // Verify deletion
+        const itemsAfterDelete = [];
+        for await (const item of consumer.listItems()) {
+          itemsAfterDelete.push(item);
+        }
+
+        const deletedItem = itemsAfterDelete.find(
+          (item) => item.text === testMessage,
+        );
+        expect(deletedItem).toBeUndefined();
+      });
+
+      await t.step("List public keys", async () => {
+        const keys = [];
+        for await (const key of producer.listPublicKeys()) {
+          keys.push(key);
+        }
+
+        expect(keys.length).toBeGreaterThan(0);
+
+        const ourKey = keys.find((key) => key.uri === keypair.publicKey);
+        expect(ourKey).toBeDefined();
+        expect(ourKey!.uri).toEqual(keypair.publicKey);
+      });
+    } finally {
+      await t.step("Cleanup: Delete test keypair", async () => {
+        const publicKeyRkey = keypair.publicKey.split("/").pop()!;
+
+        const res = await consumer.rpc.post("com.atproto.repo.deleteRecord", {
+          input: {
+            collection: "app.cistern.lexicon.pubkey",
+            repo: consumer.did,
+            rkey: publicKeyRkey,
+          },
+        });
+
+        expect(res.ok).toBe(true);
+      });
+    }
+  },
+});
+
+Deno.test({
+  name: "E2E: Multiple items with same keypair",
+  ignore: SKIP_E2E,
+  async fn(t) {
+    const handle = Deno.env.get("CISTERN_HANDLE") as Handle;
+    const appPassword = Deno.env.get("CISTERN_APP_PASSWORD")!;
+
+    let consumer: Awaited<ReturnType<typeof createConsumer>>;
+    let producer: Awaited<ReturnType<typeof createProducer>>;
+    let keypair: Awaited<ReturnType<typeof consumer.generateKeyPair>>;
+    let messages: string[];
+    let itemUris: string[];
+
+    await t.step("Create consumer and generate keypair", async () => {
+      consumer = await createConsumer({
+        handle,
+        appPassword,
+      });
+
+      keypair = await consumer.generateKeyPair();
+
+      expect(keypair.privateKey).toBeInstanceOf(Uint8Array);
+      expect(keypair.publicKey).toBeDefined();
+    });
+
+    try {
+      await t.step("Create producer", async () => {
+        const publicKeyRkey = keypair.publicKey.split("/").pop()!;
+        producer = await createProducer({
+          handle,
+          appPassword,
+          publicKey: publicKeyRkey,
+        });
+
+        expect(producer.publicKey?.uri).toEqual(keypair.publicKey);
+      });
+
+      await t.step("Create multiple encrypted items", async () => {
+        messages = [
+          `E2E Item 1 - ${new Date().toISOString()}`,
+          `E2E Item 2 - ${new Date().toISOString()}`,
+          `E2E Item 3 - ${new Date().toISOString()}`,
+        ];
+
+        itemUris = [];
+        for (const message of messages) {
+          const uri = await producer.createItem(message);
+          itemUris.push(uri);
+        }
+
+        expect(itemUris).toHaveLength(3);
+      });
+
+      await t.step("Decrypt all items", async () => {
+        const items = [];
+        for await (const item of consumer.listItems()) {
+          items.push(item);
+        }
+
+        expect(items.length).toBeGreaterThanOrEqual(3);
+
+        // Verify all test messages are present
+        for (const message of messages) {
+          const item = items.find((i) => i.text === message);
+          expect(item).toBeDefined();
+          expect(item!.text).toEqual(message);
+        }
+      });
+
+      await t.step("Cleanup: Delete test items", async () => {
+        for (const uri of itemUris) {
+          const rkey = uri.split("/").pop()!;
+          await consumer.deleteItem(rkey);
+        }
+
+        // Verify all items deleted
+        const remainingItems = [];
+        for await (const item of consumer.listItems()) {
+          remainingItems.push(item);
+        }
+
+        for (const message of messages) {
+          const item = remainingItems.find((i) => i.text === message);
+          expect(item).toBeUndefined();
+        }
+      });
+    } finally {
+      await t.step("Cleanup: Delete test keypair", async () => {
+        const publicKeyRkey = keypair.publicKey.split("/").pop()!;
+
+        const res = await consumer.rpc.post("com.atproto.repo.deleteRecord", {
+          input: {
+            collection: "app.cistern.lexicon.pubkey",
+            repo: consumer.did,
+            rkey: publicKeyRkey,
+          },
+        });
+
+        expect(res.ok).toBe(true);
+      });
+    }
+  },
+});
+
+if (SKIP_E2E) {
+  console.log(`
+⚠️  E2E tests skipped - missing environment variables
+
+To run E2E tests, set the following environment variables:
+  CISTERN_HANDLE="your.bsky.social"
+  CISTERN_APP_PASSWORD="xxxx-xxxx-xxxx-xxxx"
+
+Then run:
+  deno test --allow-env --allow-net e2e.test.ts
+`);
+}