@multiplatform.one/frappe 6.0.0

package/dist/cjs/sync/storage.spec.cjs

@@ -0,0 +1,446 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var import_vitest = require("vitest");
+var import_storage = require("./storage.cjs");
+import_vitest.vi.mock("@multiplatform.one/store", () => {
+  const mockStorage = /* @__PURE__ */new Map();
+  return {
+    storage: {
+      getItem: import_vitest.vi.fn(key => mockStorage.get(key) ?? null),
+      setItem: import_vitest.vi.fn((key, value) => mockStorage.set(key, value)),
+      removeItem: import_vitest.vi.fn(key => mockStorage.delete(key))
+    },
+    __mockStorage: mockStorage
+  };
+});
+(0, import_vitest.describe)("PlatformStorageKV", () => {
+  let kv;
+  let mockStorageMap;
+  (0, import_vitest.beforeEach)(async () => {
+    const mod = await import("@multiplatform.one/store");
+    mockStorageMap = mod.__mockStorage;
+    mockStorageMap.clear();
+    import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+    kv = new import_storage.PlatformStorageKV();
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.restoreAllMocks();
+  });
+  (0, import_vitest.it)("should get items from platform storage", async () => {
+    mockStorageMap.set("test-key", "test-value");
+    const result = await kv.getItem("test-key");
+    (0, import_vitest.expect)(result).toBe("test-value");
+  });
+  (0, import_vitest.it)("should return null for missing keys", async () => {
+    const result = await kv.getItem("non-existent");
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("should set items in platform storage", async () => {
+    await kv.setItem("test-key", "test-value");
+    (0, import_vitest.expect)(mockStorageMap.get("test-key")).toBe("test-value");
+  });
+  (0, import_vitest.it)("should remove items from platform storage", async () => {
+    mockStorageMap.set("test-key", "test-value");
+    await kv.removeItem("test-key");
+    (0, import_vitest.expect)(mockStorageMap.has("test-key")).toBe(false);
+  });
+  (0, import_vitest.it)("should handle getItem errors gracefully", async () => {
+    const {
+      storage
+    } = await import("@multiplatform.one/store");
+    import_vitest.vi.mocked(storage.getItem).mockImplementation(() => {
+      throw new Error("Storage error");
+    });
+    const result = await kv.getItem("test-key");
+    (0, import_vitest.expect)(result).toBeNull();
+    (0, import_vitest.expect)(console.warn).toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("should handle setItem errors gracefully", async () => {
+    const {
+      storage
+    } = await import("@multiplatform.one/store");
+    import_vitest.vi.mocked(storage.setItem).mockImplementation(() => {
+      throw new Error("Storage error");
+    });
+    await kv.setItem("test-key", "test-value");
+    (0, import_vitest.expect)(console.warn).toHaveBeenCalled();
+  });
+  (0, import_vitest.it)("should handle removeItem errors gracefully", async () => {
+    const {
+      storage
+    } = await import("@multiplatform.one/store");
+    import_vitest.vi.mocked(storage.removeItem).mockImplementation(() => {
+      throw new Error("Storage error");
+    });
+    await kv.removeItem("test-key");
+    (0, import_vitest.expect)(console.warn).toHaveBeenCalled();
+  });
+});
+(0, import_vitest.describe)("IndexedDBKV", () => {
+  let storage;
+  let mockDatabase;
+  let mockTransaction;
+  let mockObjectStore;
+  let mockRequest;
+  (0, import_vitest.beforeEach)(() => {
+    mockRequest = {
+      result: null,
+      error: null,
+      onsuccess: null,
+      onerror: null
+    };
+    mockObjectStore = {
+      get: import_vitest.vi.fn().mockReturnValue(mockRequest),
+      put: import_vitest.vi.fn().mockReturnValue(mockRequest),
+      delete: import_vitest.vi.fn().mockReturnValue(mockRequest)
+    };
+    mockTransaction = {
+      objectStore: import_vitest.vi.fn().mockReturnValue(mockObjectStore),
+      error: null,
+      onerror: null
+    };
+    mockDatabase = {
+      transaction: import_vitest.vi.fn().mockReturnValue(mockTransaction),
+      objectStoreNames: {
+        contains: import_vitest.vi.fn().mockReturnValue(true)
+      },
+      createObjectStore: import_vitest.vi.fn()
+    };
+    const mockOpenRequest = {
+      result: mockDatabase,
+      error: null,
+      onsuccess: null,
+      onerror: null,
+      onupgradeneeded: null
+    };
+    const mockIndexedDB = {
+      open: import_vitest.vi.fn().mockImplementation(() => {
+        setTimeout(() => {
+          if (mockOpenRequest.onsuccess) {
+            mockOpenRequest.onsuccess(new Event("success"));
+          }
+        }, 0);
+        return mockOpenRequest;
+      })
+    };
+    globalThis.indexedDB = mockIndexedDB;
+    import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.restoreAllMocks();
+    globalThis.indexedDB = void 0;
+  });
+  (0, import_vitest.describe)("initialization", () => {
+    (0, import_vitest.it)("should initialize with default database name", async () => {
+      storage = new import_storage.IndexedDBKV();
+      await new Promise(resolve => setTimeout(resolve, 10));
+      (0, import_vitest.expect)(import_vitest.vi.mocked(globalThis.indexedDB.open)).toHaveBeenCalledWith("frappe-sync", 1);
+    });
+    (0, import_vitest.it)("should initialize with custom database name", async () => {
+      storage = new import_storage.IndexedDBKV("custom-db", "custom-store");
+      await new Promise(resolve => setTimeout(resolve, 10));
+      (0, import_vitest.expect)(import_vitest.vi.mocked(globalThis.indexedDB.open)).toHaveBeenCalledWith("custom-db", 1);
+    });
+    (0, import_vitest.it)("should create object store on upgrade", async () => {
+      const mockOpenRequest = {
+        result: mockDatabase,
+        error: null,
+        onsuccess: null,
+        onerror: null,
+        onupgradeneeded: null
+      };
+      import_vitest.vi.mocked(globalThis.indexedDB.open).mockReturnValue(mockOpenRequest);
+      mockDatabase.objectStoreNames.contains.mockReturnValue(false);
+      storage = new import_storage.IndexedDBKV();
+      if (mockOpenRequest.onupgradeneeded) {
+        mockOpenRequest.onupgradeneeded({
+          type: "upgradeneeded",
+          newVersion: 1,
+          oldVersion: 0
+        });
+      }
+      (0, import_vitest.expect)(mockDatabase.createObjectStore).toHaveBeenCalledWith("kv");
+    });
+    (0, import_vitest.it)("should handle IndexedDB not available", async () => {
+      globalThis.indexedDB = void 0;
+      storage = new import_storage.IndexedDBKV();
+      await (0, import_vitest.expect)(storage.getItem("test")).rejects.toThrow("IndexedDB not available in this environment");
+    });
+    (0, import_vitest.it)("should handle database open errors", async () => {
+      const mockOpenRequest = {
+        result: null,
+        error: new Error("Failed to open"),
+        onsuccess: null,
+        onerror: null,
+        onupgradeneeded: null
+      };
+      import_vitest.vi.mocked(globalThis.indexedDB.open).mockReturnValue(mockOpenRequest);
+      storage = new import_storage.IndexedDBKV();
+      setTimeout(() => {
+        if (mockOpenRequest.onerror) {
+          mockOpenRequest.onerror(new Event("error"));
+        }
+      }, 0);
+      await (0, import_vitest.expect)(storage.getItem("test")).rejects.toThrow("Failed to open");
+    });
+  });
+  (0, import_vitest.describe)("getItem", () => {
+    (0, import_vitest.beforeEach)(async () => {
+      storage = new import_storage.IndexedDBKV();
+      await new Promise(resolve => setTimeout(resolve, 10));
+    });
+    (0, import_vitest.it)("should retrieve existing value", async () => {
+      const testValue = "test-value";
+      mockObjectStore.get.mockImplementation(() => {
+        const request = {
+          result: testValue,
+          error: null,
+          onsuccess: null,
+          onerror: null
+        };
+        setTimeout(() => {
+          if (request.onsuccess) {
+            request.onsuccess(new Event("success"));
+          }
+        }, 0);
+        return request;
+      });
+      const result = await storage.getItem("test-key");
+      (0, import_vitest.expect)(result).toBe(testValue);
+      (0, import_vitest.expect)(mockDatabase.transaction).toHaveBeenCalledWith("kv", "readonly");
+      (0, import_vitest.expect)(mockObjectStore.get).toHaveBeenCalledWith("test-key");
+    });
+    (0, import_vitest.it)("should return null for non-existent key", async () => {
+      mockObjectStore.get.mockImplementation(() => {
+        const request = {
+          result: void 0,
+          error: null,
+          onsuccess: null,
+          onerror: null
+        };
+        setTimeout(() => {
+          if (request.onsuccess) {
+            request.onsuccess(new Event("success"));
+          }
+        }, 0);
+        return request;
+      });
+      const result = await storage.getItem("non-existent");
+      (0, import_vitest.expect)(result).toBeNull();
+    });
+    (0, import_vitest.it)("should handle request errors", async () => {
+      mockObjectStore.get.mockImplementation(() => {
+        const request = {
+          result: null,
+          error: new Error("Get failed"),
+          onsuccess: null,
+          onerror: null
+        };
+        setTimeout(() => {
+          if (request.onerror) {
+            request.onerror(new Event("error"));
+          }
+        }, 0);
+        return request;
+      });
+      await (0, import_vitest.expect)(storage.getItem("test-key")).rejects.toThrow("Get failed");
+    });
+    (0, import_vitest.it)("should handle transaction errors", async () => {
+      mockDatabase.transaction.mockImplementation(() => {
+        const transaction = {
+          objectStore: import_vitest.vi.fn().mockReturnValue(mockObjectStore),
+          error: new Error("Transaction failed"),
+          onerror: null
+        };
+        setTimeout(() => {
+          if (transaction.onerror) {
+            transaction.onerror(new Event("error"));
+          }
+        }, 0);
+        return transaction;
+      });
+      await (0, import_vitest.expect)(storage.getItem("test-key")).rejects.toThrow("Transaction failed");
+    });
+  });
+  (0, import_vitest.describe)("setItem", () => {
+    (0, import_vitest.beforeEach)(async () => {
+      storage = new import_storage.IndexedDBKV();
+      await new Promise(resolve => setTimeout(resolve, 10));
+    });
+    (0, import_vitest.it)("should store value successfully", async () => {
+      mockObjectStore.put.mockImplementation(() => {
+        const request = {
+          result: void 0,
+          error: null,
+          onsuccess: null,
+          onerror: null
+        };
+        setTimeout(() => {
+          if (request.onsuccess) {
+            request.onsuccess(new Event("success"));
+          }
+        }, 0);
+        return request;
+      });
+      await storage.setItem("test-key", "test-value");
+      (0, import_vitest.expect)(mockDatabase.transaction).toHaveBeenCalledWith("kv", "readwrite");
+      (0, import_vitest.expect)(mockObjectStore.put).toHaveBeenCalledWith("test-value", "test-key");
+    });
+    (0, import_vitest.it)("should handle put errors", async () => {
+      mockObjectStore.put.mockImplementation(() => {
+        const request = {
+          result: null,
+          error: new Error("Put failed"),
+          onsuccess: null,
+          onerror: null
+        };
+        setTimeout(() => {
+          if (request.onerror) {
+            request.onerror(new Event("error"));
+          }
+        }, 0);
+        return request;
+      });
+      await (0, import_vitest.expect)(storage.setItem("test-key", "test-value")).rejects.toThrow("Put failed");
+    });
+    (0, import_vitest.it)("should handle large values", async () => {
+      const largeValue = "x".repeat(1024 * 1024);
+      mockObjectStore.put.mockImplementation(() => {
+        const request = {
+          result: void 0,
+          error: null,
+          onsuccess: null,
+          onerror: null
+        };
+        setTimeout(() => {
+          if (request.onsuccess) {
+            request.onsuccess(new Event("success"));
+          }
+        }, 0);
+        return request;
+      });
+      await storage.setItem("large-key", largeValue);
+      (0, import_vitest.expect)(mockObjectStore.put).toHaveBeenCalledWith(largeValue, "large-key");
+    });
+  });
+  (0, import_vitest.describe)("removeItem", () => {
+    (0, import_vitest.beforeEach)(async () => {
+      storage = new import_storage.IndexedDBKV();
+      await new Promise(resolve => setTimeout(resolve, 10));
+    });
+    (0, import_vitest.it)("should delete value successfully", async () => {
+      mockObjectStore.delete.mockImplementation(() => {
+        const request = {
+          result: void 0,
+          error: null,
+          onsuccess: null,
+          onerror: null
+        };
+        setTimeout(() => {
+          if (request.onsuccess) {
+            request.onsuccess(new Event("success"));
+          }
+        }, 0);
+        return request;
+      });
+      await storage.removeItem("test-key");
+      (0, import_vitest.expect)(mockDatabase.transaction).toHaveBeenCalledWith("kv", "readwrite");
+      (0, import_vitest.expect)(mockObjectStore.delete).toHaveBeenCalledWith("test-key");
+    });
+    (0, import_vitest.it)("should handle delete errors gracefully", async () => {
+      mockObjectStore.delete.mockImplementation(() => {
+        const request = {
+          result: null,
+          error: new Error("Delete failed"),
+          onsuccess: null,
+          onerror: null
+        };
+        setTimeout(() => {
+          if (request.onerror) {
+            request.onerror(new Event("error"));
+          }
+        }, 0);
+        return request;
+      });
+      await storage.removeItem("test-key");
+      (0, import_vitest.expect)(console.warn).toHaveBeenCalledWith(import_vitest.expect.stringContaining("IndexedDB removeItem failed"), import_vitest.expect.any(Error));
+    });
+    (0, import_vitest.it)("should handle transaction errors gracefully", async () => {
+      mockDatabase.transaction.mockImplementation(() => {
+        const transaction = {
+          objectStore: import_vitest.vi.fn().mockReturnValue(mockObjectStore),
+          error: new Error("Transaction failed"),
+          onerror: null
+        };
+        setTimeout(() => {
+          if (transaction.onerror) {
+            transaction.onerror(new Event("error"));
+          }
+        }, 0);
+        return transaction;
+      });
+      await storage.removeItem("test-key");
+      (0, import_vitest.expect)(console.warn).toHaveBeenCalledWith(import_vitest.expect.stringContaining("IndexedDB removeItem failed"), import_vitest.expect.any(Error));
+    });
+  });
+  (0, import_vitest.describe)("concurrent operations", () => {
+    (0, import_vitest.beforeEach)(async () => {
+      storage = new import_storage.IndexedDBKV();
+      await new Promise(resolve => setTimeout(resolve, 10));
+      const createSuccessRequest = () => {
+        const request = {
+          result: "value",
+          error: null,
+          onsuccess: null,
+          onerror: null
+        };
+        setTimeout(() => {
+          if (request.onsuccess) {
+            request.onsuccess(new Event("success"));
+          }
+        }, Math.random() * 10);
+        return request;
+      };
+      mockObjectStore.get.mockImplementation(createSuccessRequest);
+      mockObjectStore.put.mockImplementation(createSuccessRequest);
+      mockObjectStore.delete.mockImplementation(createSuccessRequest);
+    });
+    (0, import_vitest.it)("should handle concurrent reads", async () => {
+      const promises = Array.from({
+        length: 10
+      }, (_, i) => storage.getItem(`key-${i}`));
+      const results = await Promise.all(promises);
+      (0, import_vitest.expect)(results).toHaveLength(10);
+      (0, import_vitest.expect)(mockObjectStore.get).toHaveBeenCalledTimes(10);
+    });
+    (0, import_vitest.it)("should handle mixed concurrent operations", async () => {
+      const promises = [storage.getItem("key1"), storage.setItem("key2", "value2"), storage.removeItem("key3"), storage.getItem("key4"), storage.setItem("key5", "value5")];
+      await Promise.all(promises);
+      (0, import_vitest.expect)(mockObjectStore.get).toHaveBeenCalledTimes(2);
+      (0, import_vitest.expect)(mockObjectStore.put).toHaveBeenCalledTimes(2);
+      (0, import_vitest.expect)(mockObjectStore.delete).toHaveBeenCalledTimes(1);
+    });
+  });
+});