@uploadista/client-browser 0.0.20 → 0.1.0-beta.5

package/src/services/platform-service.test.ts

@@ -0,0 +1,169 @@
+import { describe, expect, it, vi } from "vitest";
+import { createBrowserPlatformService } from "./platform-service";
+
+describe("createBrowserPlatformService", () => {
+  it("should create a platform service", () => {
+    const service = createBrowserPlatformService();
+    expect(service).toBeDefined();
+    expect(service.setTimeout).toBeDefined();
+    expect(service.clearTimeout).toBeDefined();
+    expect(service.isBrowser).toBeDefined();
+    expect(service.isOnline).toBeDefined();
+    expect(service.isFileLike).toBeDefined();
+    expect(service.getFileName).toBeDefined();
+    expect(service.getFileType).toBeDefined();
+    expect(service.getFileSize).toBeDefined();
+    expect(service.getFileLastModified).toBeDefined();
+  });
+
+  describe("setTimeout", () => {
+    it("should schedule a callback", async () => {
+      const service = createBrowserPlatformService();
+      const callback = vi.fn();
+
+      service.setTimeout(callback, 10);
+
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(callback).toHaveBeenCalled();
+    });
+
+    it("should return a timeout ID", () => {
+      const service = createBrowserPlatformService();
+      const callback = vi.fn();
+
+      const id = service.setTimeout(callback, 1000);
+      expect(id).toBeDefined();
+
+      // Clean up
+      service.clearTimeout(id);
+    });
+  });
+
+  describe("clearTimeout", () => {
+    it("should cancel a scheduled callback", async () => {
+      const service = createBrowserPlatformService();
+      const callback = vi.fn();
+
+      const id = service.setTimeout(callback, 50);
+      service.clearTimeout(id);
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(callback).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("isBrowser", () => {
+    it("should return true in browser environment", () => {
+      const service = createBrowserPlatformService();
+      // In happy-dom test environment, window should be defined
+      expect(service.isBrowser()).toBe(true);
+    });
+  });
+
+  describe("isOnline", () => {
+    it("should return online status", () => {
+      const service = createBrowserPlatformService();
+      // In happy-dom, navigator.onLine should be available
+      const result = service.isOnline();
+      expect(typeof result).toBe("boolean");
+    });
+  });
+
+  describe("isFileLike", () => {
+    it("should return true for File objects", () => {
+      const service = createBrowserPlatformService();
+      const file = new File(["content"], "test.txt", { type: "text/plain" });
+
+      expect(service.isFileLike(file)).toBe(true);
+    });
+
+    it("should return false for Blob objects", () => {
+      const service = createBrowserPlatformService();
+      const blob = new Blob(["content"], { type: "text/plain" });
+
+      expect(service.isFileLike(blob)).toBe(false);
+    });
+
+    it("should return false for non-file values", () => {
+      const service = createBrowserPlatformService();
+
+      expect(service.isFileLike("string")).toBe(false);
+      expect(service.isFileLike(123)).toBe(false);
+      expect(service.isFileLike(null)).toBe(false);
+      expect(service.isFileLike(undefined)).toBe(false);
+      expect(service.isFileLike({})).toBe(false);
+    });
+  });
+
+  describe("getFileName", () => {
+    it("should return file name for File objects", () => {
+      const service = createBrowserPlatformService();
+      const file = new File(["content"], "test.txt", { type: "text/plain" });
+
+      expect(service.getFileName(file)).toBe("test.txt");
+    });
+
+    it("should return undefined for non-File objects", () => {
+      const service = createBrowserPlatformService();
+      const blob = new Blob(["content"], { type: "text/plain" });
+
+      expect(service.getFileName(blob)).toBeUndefined();
+      expect(service.getFileName("string")).toBeUndefined();
+      expect(service.getFileName(null)).toBeUndefined();
+    });
+  });
+
+  describe("getFileType", () => {
+    it("should return file type for File objects", () => {
+      const service = createBrowserPlatformService();
+      const file = new File(["content"], "test.txt", { type: "text/plain" });
+
+      expect(service.getFileType(file)).toBe("text/plain");
+    });
+
+    it("should return undefined for non-File objects", () => {
+      const service = createBrowserPlatformService();
+      const blob = new Blob(["content"], { type: "text/plain" });
+
+      expect(service.getFileType(blob)).toBeUndefined();
+      expect(service.getFileType("string")).toBeUndefined();
+    });
+  });
+
+  describe("getFileSize", () => {
+    it("should return file size for File objects", () => {
+      const service = createBrowserPlatformService();
+      const content = "Hello, World!";
+      const file = new File([content], "test.txt", { type: "text/plain" });
+
+      expect(service.getFileSize(file)).toBe(content.length);
+    });
+
+    it("should return undefined for non-File objects", () => {
+      const service = createBrowserPlatformService();
+      const blob = new Blob(["content"], { type: "text/plain" });
+
+      expect(service.getFileSize(blob)).toBeUndefined();
+      expect(service.getFileSize("string")).toBeUndefined();
+    });
+  });
+
+  describe("getFileLastModified", () => {
+    it("should return last modified for File objects", () => {
+      const service = createBrowserPlatformService();
+      const file = new File(["content"], "test.txt", { type: "text/plain" });
+
+      const lastModified = service.getFileLastModified(file);
+      expect(typeof lastModified).toBe("number");
+      expect(lastModified).toBeGreaterThan(0);
+    });
+
+    it("should return undefined for non-File objects", () => {
+      const service = createBrowserPlatformService();
+      const blob = new Blob(["content"], { type: "text/plain" });
+
+      expect(service.getFileLastModified(blob)).toBeUndefined();
+      expect(service.getFileLastModified("string")).toBeUndefined();
+    });
+  });
+});

package/src/services/storage/local-storage-service.test.ts

@@ -0,0 +1,168 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createLocalStorageService } from "./local-storage-service";
+
+describe("createLocalStorageService", () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  afterEach(() => {
+    localStorage.clear();
+  });
+
+  it("should create a storage service", () => {
+    const service = createLocalStorageService();
+    expect(service).toBeDefined();
+    expect(service.getItem).toBeDefined();
+    expect(service.setItem).toBeDefined();
+    expect(service.removeItem).toBeDefined();
+    expect(service.findAll).toBeDefined();
+    expect(service.find).toBeDefined();
+  });
+
+  describe("setItem", () => {
+    it("should store a value", async () => {
+      const service = createLocalStorageService();
+
+      await service.setItem("key", "value");
+
+      expect(localStorage.getItem("key")).toBe("value");
+    });
+
+    it("should overwrite existing value", async () => {
+      const service = createLocalStorageService();
+
+      await service.setItem("key", "value1");
+      await service.setItem("key", "value2");
+
+      expect(localStorage.getItem("key")).toBe("value2");
+    });
+  });
+
+  describe("getItem", () => {
+    it("should retrieve a stored value", async () => {
+      const service = createLocalStorageService();
+      localStorage.setItem("key", "value");
+
+      const result = await service.getItem("key");
+
+      expect(result).toBe("value");
+    });
+
+    it("should return null for non-existent key", async () => {
+      const service = createLocalStorageService();
+
+      const result = await service.getItem("nonexistent");
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("removeItem", () => {
+    it("should remove a stored value", async () => {
+      const service = createLocalStorageService();
+      localStorage.setItem("key", "value");
+
+      await service.removeItem("key");
+
+      expect(localStorage.getItem("key")).toBeNull();
+    });
+
+    it("should not throw for non-existent key", async () => {
+      const service = createLocalStorageService();
+
+      await expect(service.removeItem("nonexistent")).resolves.not.toThrow();
+    });
+  });
+
+  describe("findAll", () => {
+    it("should return all stored items", async () => {
+      const service = createLocalStorageService();
+      localStorage.setItem("key1", "value1");
+      localStorage.setItem("key2", "value2");
+
+      const result = await service.findAll();
+
+      expect(result).toEqual({
+        key1: "value1",
+        key2: "value2",
+      });
+    });
+
+    it("should return empty object when storage is empty", async () => {
+      const service = createLocalStorageService();
+
+      const result = await service.findAll();
+
+      expect(result).toEqual({});
+    });
+  });
+
+  describe("find", () => {
+    it("should return items matching prefix", async () => {
+      const service = createLocalStorageService();
+      localStorage.setItem("upload:1", "data1");
+      localStorage.setItem("upload:2", "data2");
+      localStorage.setItem("other:1", "other");
+
+      const result = await service.find("upload:");
+
+      expect(result).toEqual({
+        "upload:1": "data1",
+        "upload:2": "data2",
+      });
+    });
+
+    it("should return empty object when no matches", async () => {
+      const service = createLocalStorageService();
+      localStorage.setItem("key", "value");
+
+      const result = await service.find("nonexistent:");
+
+      expect(result).toEqual({});
+    });
+
+    it("should return all items with empty prefix", async () => {
+      const service = createLocalStorageService();
+      localStorage.setItem("key1", "value1");
+      localStorage.setItem("key2", "value2");
+
+      const result = await service.find("");
+
+      expect(result).toEqual({
+        key1: "value1",
+        key2: "value2",
+      });
+    });
+  });
+
+  describe("integration", () => {
+    it("should handle JSON data", async () => {
+      const service = createLocalStorageService();
+      const data = { name: "test", count: 42, items: [1, 2, 3] };
+
+      await service.setItem("json-key", JSON.stringify(data));
+      const retrieved = await service.getItem("json-key");
+
+      expect(JSON.parse(retrieved!)).toEqual(data);
+    });
+
+    it("should handle multiple operations", async () => {
+      const service = createLocalStorageService();
+
+      await service.setItem("a", "1");
+      await service.setItem("b", "2");
+      await service.setItem("c", "3");
+
+      expect(await service.getItem("a")).toBe("1");
+      expect(await service.getItem("b")).toBe("2");
+      expect(await service.getItem("c")).toBe("3");
+
+      await service.removeItem("b");
+
+      const all = await service.findAll();
+      expect(Object.keys(all)).toHaveLength(2);
+      expect(all.b).toBeUndefined();
+    });
+  });
+});

package/src/services/storage/session-storage-service.test.ts

@@ -0,0 +1,168 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createSessionStorageService } from "./session-storage-service";
+
+describe("createSessionStorageService", () => {
+  beforeEach(() => {
+    sessionStorage.clear();
+  });
+
+  afterEach(() => {
+    sessionStorage.clear();
+  });
+
+  it("should create a storage service", () => {
+    const service = createSessionStorageService();
+    expect(service).toBeDefined();
+    expect(service.getItem).toBeDefined();
+    expect(service.setItem).toBeDefined();
+    expect(service.removeItem).toBeDefined();
+    expect(service.findAll).toBeDefined();
+    expect(service.find).toBeDefined();
+  });
+
+  describe("setItem", () => {
+    it("should store a value", async () => {
+      const service = createSessionStorageService();
+
+      await service.setItem("key", "value");
+
+      expect(sessionStorage.getItem("key")).toBe("value");
+    });
+
+    it("should overwrite existing value", async () => {
+      const service = createSessionStorageService();
+
+      await service.setItem("key", "value1");
+      await service.setItem("key", "value2");
+
+      expect(sessionStorage.getItem("key")).toBe("value2");
+    });
+  });
+
+  describe("getItem", () => {
+    it("should retrieve a stored value", async () => {
+      const service = createSessionStorageService();
+      sessionStorage.setItem("key", "value");
+
+      const result = await service.getItem("key");
+
+      expect(result).toBe("value");
+    });
+
+    it("should return null for non-existent key", async () => {
+      const service = createSessionStorageService();
+
+      const result = await service.getItem("nonexistent");
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("removeItem", () => {
+    it("should remove a stored value", async () => {
+      const service = createSessionStorageService();
+      sessionStorage.setItem("key", "value");
+
+      await service.removeItem("key");
+
+      expect(sessionStorage.getItem("key")).toBeNull();
+    });
+
+    it("should not throw for non-existent key", async () => {
+      const service = createSessionStorageService();
+
+      await expect(service.removeItem("nonexistent")).resolves.not.toThrow();
+    });
+  });
+
+  describe("findAll", () => {
+    it("should return all stored items", async () => {
+      const service = createSessionStorageService();
+      sessionStorage.setItem("key1", "value1");
+      sessionStorage.setItem("key2", "value2");
+
+      const result = await service.findAll();
+
+      expect(result).toEqual({
+        key1: "value1",
+        key2: "value2",
+      });
+    });
+
+    it("should return empty object when storage is empty", async () => {
+      const service = createSessionStorageService();
+
+      const result = await service.findAll();
+
+      expect(result).toEqual({});
+    });
+  });
+
+  describe("find", () => {
+    it("should return items matching prefix", async () => {
+      const service = createSessionStorageService();
+      sessionStorage.setItem("temp:1", "data1");
+      sessionStorage.setItem("temp:2", "data2");
+      sessionStorage.setItem("other:1", "other");
+
+      const result = await service.find("temp:");
+
+      expect(result).toEqual({
+        "temp:1": "data1",
+        "temp:2": "data2",
+      });
+    });
+
+    it("should return empty object when no matches", async () => {
+      const service = createSessionStorageService();
+      sessionStorage.setItem("key", "value");
+
+      const result = await service.find("nonexistent:");
+
+      expect(result).toEqual({});
+    });
+
+    it("should return all items with empty prefix", async () => {
+      const service = createSessionStorageService();
+      sessionStorage.setItem("key1", "value1");
+      sessionStorage.setItem("key2", "value2");
+
+      const result = await service.find("");
+
+      expect(result).toEqual({
+        key1: "value1",
+        key2: "value2",
+      });
+    });
+  });
+
+  describe("integration", () => {
+    it("should handle JSON data", async () => {
+      const service = createSessionStorageService();
+      const data = { name: "test", count: 42, items: [1, 2, 3] };
+
+      await service.setItem("json-key", JSON.stringify(data));
+      const retrieved = await service.getItem("json-key");
+
+      expect(JSON.parse(retrieved!)).toEqual(data);
+    });
+
+    it("should handle multiple operations", async () => {
+      const service = createSessionStorageService();
+
+      await service.setItem("a", "1");
+      await service.setItem("b", "2");
+      await service.setItem("c", "3");
+
+      expect(await service.getItem("a")).toBe("1");
+      expect(await service.getItem("b")).toBe("2");
+      expect(await service.getItem("c")).toBe("3");
+
+      await service.removeItem("b");
+
+      const all = await service.findAll();
+      expect(Object.keys(all)).toHaveLength(2);
+      expect(all.b).toBeUndefined();
+    });
+  });
+});