test(encryption): ✅ Added test for chained prefixedStorage and storag…

…e server
unjs · Jan 2, 2024 · 385798a · 385798a
1 parent 9ba000b
commit 385798a
Show file tree

Hide file tree

Showing 2 changed files with 99 additions and 1 deletion.
diff --git a/test/server.test.ts b/test/server.test.ts
@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 import { listen } from "listhen";
 import { $fetch } from "ofetch";
-import { createStorage } from "../src";
+import { createStorage, encryptedStorage } from "../src";
 import { createStorageServer } from "../src/server";
 
 describe("server", () => {
@@ -48,3 +48,51 @@ describe("server", () => {
     await close();
   });
 });
+
+describe("encrypted server", () => {
+  const encryptionKey = 'e9iF+8pS8qAjnj7B1+ZwdzWQ+KXNJGUPW3HdDuMJPgI=';
+
+  it("basic", async () => {
+    const storage = createStorage();
+    const encStorage = encryptedStorage(storage, encryptionKey, true)
+    const storageServer = createStorageServer(encStorage, {
+      authorize(req) {
+        if (req.type === "read" && req.key.startsWith("private:")) {
+          throw new Error("Unauthorized Read");
+        }
+      },
+    });
+    const { close, url: serverURL } = await listen(storageServer.handle, {
+      port: { random: true },
+    });
+
+    const fetchStorage = (url: string, options?: any) =>
+      $fetch(url, { baseURL: serverURL, ...options });
+
+    expect(await fetchStorage("foo/", {})).toMatchObject([]);
+
+    await encStorage.setItem("foo/bar", "bar");
+    await encStorage.setMeta("foo/bar", { mtime: new Date() });
+    expect(await fetchStorage("foo/bar")).toBe("bar");
+
+    expect(
+      await fetchStorage("foo/bar", { method: "PUT", body: "updated" })
+    ).toBe("OK");
+    expect(await fetchStorage("foo/bar")).toBe("updated");
+    expect(await fetchStorage("/")).toMatchObject(["foo/bar"]);
+
+    expect(await fetchStorage("foo/bar", { method: "DELETE" })).toBe("OK");
+    expect(await fetchStorage("foo/bar/", {})).toMatchObject([]);
+
+    await expect(
+      fetchStorage("private/foo/bar", { method: "GET" }).catch((error) => {
+        throw error.data;
+      })
+    ).rejects.toMatchObject({
+      statusCode: 401,
+      statusMessage: "Unauthorized Read",
+    });
+
+    await close();
+  });
+});
diff --git a/test/storage.test.ts b/test/storage.test.ts
@@ -4,6 +4,7 @@ import {
   snapshot,
   restoreSnapshot,
   prefixStorage,
+  encryptedStorage,
 } from "../src";
 import memory from "../src/drivers/memory";
 
@@ -136,6 +137,8 @@ describe("storage", () => {
 });
 
 describe("utils", () => {
+  const encryptionKey = 'e9iF+8pS8qAjnj7B1+ZwdzWQ+KXNJGUPW3HdDuMJPgI=';
+
   it("prefixStorage", async () => {
     const storage = createStorage();
     const pStorage = prefixStorage(storage, "foo");
@@ -155,6 +158,53 @@ describe("utils", () => {
     expect(await mntStorage.getKeys("foo")).toStrictEqual(["foo:x", "foo:y"]);
   });
 
+  it("prefixed encryptedStorage", async () => {
+    const storage = createStorage();
+    const pStorage = prefixStorage(storage, "foo");
+    const encStorage = encryptedStorage(pStorage, encryptionKey, false);
+    await encStorage.setItem("x", "bar");
+    await encStorage.setItem("y", "baz");
+    expect(await encStorage.getItem("x")).toBe("bar");
+    expect(await encStorage.getKeys()).toStrictEqual(["x", "y"]);
+    expect(await storage.getItem("x")).toBeNull();
+    expect(await storage.getItem("foo:x")).toBeTypeOf("object");
+    expect(await storage.getItem("foo:x")).toBeTypeOf("object");
+
+    // Higher order storage
+    const secondStorage = createStorage();
+    secondStorage.mount("/mnt", storage);
+    const mntStorage = prefixStorage(secondStorage, "mnt");
+
+    expect(await mntStorage.getKeys()).toStrictEqual(["foo:x", "foo:y"]);
+    // Get keys from sub-storage
+    expect(await mntStorage.getKeys("foo")).toStrictEqual(["foo:x", "foo:y"]);
+  });
+
+  it("prefixed encryptedStorage with key encryption", async () => {
+    const storage = createStorage();
+    const pStorage = prefixStorage(storage, "foo");
+    const encStorage = encryptedStorage(pStorage, encryptionKey, true);
+    await encStorage.setItem("x", "bar");
+    await encStorage.setItem("y", "baz");
+    expect(await encStorage.getItem("x")).toBe("bar");
+    expect(await encStorage.getKeys()).toStrictEqual(["x", "y"]);
+    expect(await storage.getItem("x")).toBeNull();
+    expect(await storage.getItem("foo:x")).toBeTypeOf("object");
+    expect(await storage.getItem("foo:x")).toBeTypeOf("object");
+
+    // Higher order storage
+    const secondStorage = createStorage();
+    secondStorage.mount("/mnt", storage);
+    const mntStorage = prefixStorage(secondStorage, "mnt");
+
+    for (const key of await mntStorage.getKeys()) {
+      expect(key).toContain("foo:$enc:");
+    }
+    for (const key of await mntStorage.getKeys("foo")) {
+      expect(key).toContain("foo:$enc:");
+    }
+  });
+
   it("stringify", () => {
     const storage = createStorage();
     expect(async () => await storage.setItem("foo", [])).not.toThrow();