@simplysm/solid 13.0.69 → 13.0.71

package/tests/hooks/useSyncConfig.spec.tsx

@@ -0,0 +1,304 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { render, cleanup } from "@solidjs/testing-library";
+import { useSyncConfig } from "../../src/hooks/useSyncConfig";
+import { ConfigProvider } from "../../src/providers/ConfigContext";
+import {
+  SyncStorageProvider,
+  useSyncStorage,
+  type StorageAdapter,
+} from "../../src/providers/SyncStorageContext";
+
+/** Helper to configure adapter within SyncStorageProvider and render children */
+function ConfigureStorage(props: { storage: StorageAdapter; children: any }) {
+  useSyncStorage()!.configure(() => props.storage);
+  return <>{props.children}</>;
+}
+
+describe("useSyncConfig", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    cleanup();
+    localStorage.clear();
+  });
+
+  it("should initialize with default value when no stored value exists", () => {
+    let value!: () => string;
+
+    function TestComponent() {
+      [value] = useSyncConfig("test-key", "default");
+      return <div>{value()}</div>;
+    }
+
+    render(() => (
+      <ConfigProvider clientName="testApp">
+        <TestComponent />
+      </ConfigProvider>
+    ));
+
+    expect(value()).toBe("default");
+  });
+
+  it("should load value from localStorage when no SyncStorageProvider", () => {
+    localStorage.setItem("testApp.test-key", JSON.stringify("stored"));
+
+    let value!: () => string;
+
+    function TestComponent() {
+      [value] = useSyncConfig("test-key", "default");
+      return <div>{value()}</div>;
+    }
+
+    render(() => (
+      <ConfigProvider clientName="testApp">
+        <TestComponent />
+      </ConfigProvider>
+    ));
+
+    expect(value()).toBe("stored");
+  });
+
+  it("should save value to localStorage when updated", () => {
+    let setValue!: (v: string) => void;
+
+    function TestComponent() {
+      const [, setVal] = useSyncConfig("test-key", "default");
+      setValue = setVal;
+      return <div />;
+    }
+
+    render(() => (
+      <ConfigProvider clientName="testApp">
+        <TestComponent />
+      </ConfigProvider>
+    ));
+
+    setValue("new-value");
+    expect(localStorage.getItem("testApp.test-key")).toBe(JSON.stringify("new-value"));
+  });
+
+  it("should return ready=true when using localStorage (sync initialization)", () => {
+    let ready!: () => boolean;
+
+    function TestComponent() {
+      [, , ready] = useSyncConfig("test-key", "default");
+      return <div />;
+    }
+
+    render(() => (
+      <ConfigProvider clientName="testApp">
+        <TestComponent />
+      </ConfigProvider>
+    ));
+
+    expect(ready()).toBe(true);
+  });
+
+  it("should use syncStorage when configured via configure()", async () => {
+    const mockSyncStorage: StorageAdapter = {
+      getItem: vi.fn().mockResolvedValue(JSON.stringify("synced-value")),
+      setItem: vi.fn().mockResolvedValue(undefined),
+      removeItem: vi.fn(),
+    };
+
+    let value!: () => string;
+    let setValue!: (v: string) => void;
+    let ready!: () => boolean;
+
+    function TestComponent() {
+      [value, setValue, ready] = useSyncConfig("test-key", "default");
+      return <div>{value()}</div>;
+    }
+
+    render(() => (
+      <ConfigProvider clientName="testApp">
+        <SyncStorageProvider>
+          <ConfigureStorage storage={mockSyncStorage}>
+            <TestComponent />
+          </ConfigureStorage>
+        </SyncStorageProvider>
+      </ConfigProvider>
+    ));
+
+    await vi.waitFor(() => {
+      expect(ready()).toBe(true);
+    });
+
+    expect(value()).toBe("synced-value");
+    expect(mockSyncStorage.getItem).toHaveBeenCalledWith("testApp.test-key");
+
+    setValue("new-synced");
+    expect(value()).toBe("new-synced");
+    await vi.waitFor(() => {
+      expect(mockSyncStorage.setItem).toHaveBeenCalledWith(
+        "testApp.test-key",
+        JSON.stringify("new-synced"),
+      );
+    });
+  });
+
+  it("should handle syncStorage.getItem returning null", async () => {
+    const mockSyncStorage: StorageAdapter = {
+      getItem: vi.fn().mockResolvedValue(null),
+      setItem: vi.fn().mockResolvedValue(undefined),
+      removeItem: vi.fn(),
+    };
+
+    let value!: () => string;
+    let ready!: () => boolean;
+
+    function TestComponent() {
+      [value, , ready] = useSyncConfig("test-key", "default");
+      return <div>{value()}</div>;
+    }
+
+    render(() => (
+      <ConfigProvider clientName="testApp">
+        <SyncStorageProvider>
+          <ConfigureStorage storage={mockSyncStorage}>
+            <TestComponent />
+          </ConfigureStorage>
+        </SyncStorageProvider>
+      </ConfigProvider>
+    ));
+
+    await vi.waitFor(() => {
+      expect(ready()).toBe(true);
+    });
+
+    expect(value()).toBe("default");
+  });
+
+  it("should handle syncStorage errors gracefully and fall back to localStorage", async () => {
+    const mockSyncStorage: StorageAdapter = {
+      getItem: vi.fn().mockRejectedValue(new Error("Network error")),
+      setItem: vi.fn().mockRejectedValue(new Error("Network error")),
+      removeItem: vi.fn(),
+    };
+
+    localStorage.setItem("testApp.test-key", JSON.stringify("local-fallback"));
+
+    let value!: () => string;
+    let setValue!: (v: string) => void;
+    let ready!: () => boolean;
+
+    function TestComponent() {
+      [value, setValue, ready] = useSyncConfig("test-key", "default");
+      return <div>{value()}</div>;
+    }
+
+    render(() => (
+      <ConfigProvider clientName="testApp">
+        <SyncStorageProvider>
+          <ConfigureStorage storage={mockSyncStorage}>
+            <TestComponent />
+          </ConfigureStorage>
+        </SyncStorageProvider>
+      </ConfigProvider>
+    ));
+
+    await vi.waitFor(() => {
+      expect(ready()).toBe(true);
+    });
+
+    expect(value()).toBe("local-fallback");
+
+    setValue("new-local");
+    expect(value()).toBe("new-local");
+    await vi.waitFor(() => {
+      expect(localStorage.getItem("testApp.test-key")).toBe(JSON.stringify("new-local"));
+    });
+  });
+
+  it("should handle non-JSON values in storage", () => {
+    localStorage.setItem("testApp.test-key", "not-json");
+
+    let value!: () => string;
+
+    function TestComponent() {
+      [value] = useSyncConfig("test-key", "default");
+      return <div>{value()}</div>;
+    }
+
+    render(() => (
+      <ConfigProvider clientName="testApp">
+        <TestComponent />
+      </ConfigProvider>
+    ));
+
+    expect(value()).toBe("default");
+  });
+
+  it("should support complex objects", () => {
+    const defaultObj = { theme: "light", fontSize: 14 };
+
+    let value!: () => { theme: string; fontSize: number };
+    let setValue!: (v: { theme: string; fontSize: number }) => void;
+
+    function TestComponent() {
+      [value, setValue] = useSyncConfig("test-key", defaultObj);
+      return <div />;
+    }
+
+    render(() => (
+      <ConfigProvider clientName="testApp">
+        <TestComponent />
+      </ConfigProvider>
+    ));
+
+    expect(value()).toEqual(defaultObj);
+
+    const newObj = { theme: "dark", fontSize: 16 };
+    setValue(newObj);
+
+    expect(value()).toEqual(newObj);
+    expect(JSON.parse(localStorage.getItem("testApp.test-key")!)).toEqual(newObj);
+  });
+
+  it("should re-read from new adapter when configure() is called mid-session", async () => {
+    const mockSyncStorage: StorageAdapter = {
+      getItem: vi.fn().mockResolvedValue(JSON.stringify("server-theme")),
+      setItem: vi.fn().mockResolvedValue(undefined),
+      removeItem: vi.fn(),
+    };
+
+    let value!: () => string;
+    let ready!: () => boolean;
+    let doConfiguration!: () => void;
+
+    function TestComponent() {
+      [value, , ready] = useSyncConfig("test-key", "default");
+      const syncStorage = useSyncStorage()!;
+      doConfiguration = () => syncStorage.configure(() => mockSyncStorage);
+      return <div>{value()}</div>;
+    }
+
+    render(() => (
+      <ConfigProvider clientName="testApp">
+        <SyncStorageProvider>
+          <TestComponent />
+        </SyncStorageProvider>
+      </ConfigProvider>
+    ));
+
+    // Initially: default adapter (localStorage-based), wait for async read
+    await vi.waitFor(() => {
+      expect(ready()).toBe(true);
+    });
+    expect(value()).toBe("default");
+
+    // Configure mid-session
+    doConfiguration();
+
+    // ready becomes false, then true after async read
+    await vi.waitFor(() => {
+      expect(ready()).toBe(true);
+    });
+
+    expect(value()).toBe("server-theme");
+    expect(mockSyncStorage.getItem).toHaveBeenCalledWith("testApp.test-key");
+  });
+});

package/tests/providers/ClipboardProvider.spec.tsx

@@ -0,0 +1,20 @@
+import { describe, it, expect } from "vitest";
+import { render, cleanup } from "@solidjs/testing-library";
+import { afterEach } from "vitest";
+import { ClipboardProvider } from "../../src/providers/ClipboardProvider";
+
+describe("ClipboardProvider", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  it("renders children correctly", () => {
+    const { getByText } = render(() => (
+      <ClipboardProvider>
+        <div>child content</div>
+      </ClipboardProvider>
+    ));
+
+    expect(getByText("child content")).toBeDefined();
+  });
+});

package/tests/providers/ConfigContext.spec.tsx

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import { createRoot } from "solid-js";
+import { render, cleanup } from "@solidjs/testing-library";
+import { afterEach } from "vitest";
+import { useConfig, ConfigProvider } from "../../src/providers/ConfigContext";
+
+describe("ConfigContext", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe("useConfig", () => {
+    it("throws error when used without Provider", () => {
+      createRoot((dispose) => {
+        expect(() => useConfig()).toThrow(
+          "useConfig can only be used inside ConfigProvider",
+        );
+        dispose();
+      });
+    });
+  });
+
+  describe("ConfigProvider", () => {
+    it("provides clientName correctly", () => {
+      let receivedClientName: string | undefined;
+
+      function TestComponent() {
+        const config = useConfig();
+        receivedClientName = config.clientName;
+        return <div />;
+      }
+
+      render(() => (
+        <ConfigProvider clientName="myApp">
+          <TestComponent />
+        </ConfigProvider>
+      ));
+
+      expect(receivedClientName).toBe("myApp");
+    });
+  });
+});

package/tests/providers/ErrorLoggerProvider.spec.tsx

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, cleanup } from "@solidjs/testing-library";
+import { ErrorLoggerProvider } from "../../src/providers/ErrorLoggerProvider";
+import { LoggerProvider, type LogAdapter } from "../../src/providers/LoggerContext";
+import { useLogger } from "../../src/hooks/useLogger";
+
+/** Helper to configure adapter within LoggerProvider and render children */
+function ConfigureLogger(props: { adapter: LogAdapter; children: any }) {
+  useLogger().configure(() => props.adapter);
+  return <>{props.children}</>;
+}
+
+describe("ErrorLoggerProvider", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  it("renders children correctly", () => {
+    const { getByText } = render(() => (
+      <ErrorLoggerProvider>
+        <div>child content</div>
+      </ErrorLoggerProvider>
+    ));
+
+    expect(getByText("child content")).toBeDefined();
+  });
+
+  it("captures window error events and calls logger.error", () => {
+    const writeSpy = vi.fn();
+    const adapter: LogAdapter = { write: writeSpy };
+
+    render(() => (
+      <LoggerProvider>
+        <ConfigureLogger adapter={adapter}>
+          <ErrorLoggerProvider>
+            <div />
+          </ErrorLoggerProvider>
+        </ConfigureLogger>
+      </LoggerProvider>
+    ));
+
+    const errorEvent = new ErrorEvent("error", {
+      error: new Error("test error"),
+      message: "test error",
+    });
+    window.dispatchEvent(errorEvent);
+
+    expect(writeSpy).toHaveBeenCalledWith("error", "Uncaught error:", expect.any(Error));
+  });
+
+  it("captures unhandledrejection events and calls logger.error", () => {
+    const writeSpy = vi.fn();
+    const adapter: LogAdapter = { write: writeSpy };
+
+    render(() => (
+      <LoggerProvider>
+        <ConfigureLogger adapter={adapter}>
+          <ErrorLoggerProvider>
+            <div />
+          </ErrorLoggerProvider>
+        </ConfigureLogger>
+      </LoggerProvider>
+    ));
+
+    const rejectionEvent = new PromiseRejectionEvent("unhandledrejection", {
+      promise: Promise.resolve(),
+      reason: "rejection reason",
+    });
+    window.dispatchEvent(rejectionEvent);
+
+    expect(writeSpy).toHaveBeenCalledWith("error", "Unhandled rejection:", "rejection reason");
+  });
+});

package/tests/providers/LoggerContext.spec.tsx

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi } from "vitest";
+import { createRoot } from "solid-js";
+import { render, cleanup } from "@solidjs/testing-library";
+import { afterEach } from "vitest";
+import {
+  LoggerContext,
+  LoggerProvider,
+  type LoggerContextValue,
+} from "../../src/providers/LoggerContext";
+import { useContext } from "solid-js";
+
+describe("LoggerContext", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  it("returns undefined when useContext is called without Provider", () => {
+    createRoot((dispose) => {
+      const value = useContext(LoggerContext);
+      expect(value).toBeUndefined();
+      dispose();
+    });
+  });
+
+  it("LoggerProvider provides LoggerContextValue correctly", () => {
+    let received: LoggerContextValue | undefined;
+
+    function TestComponent() {
+      received = useContext(LoggerContext);
+      return <div />;
+    }
+
+    render(() => (
+      <LoggerProvider>
+        <TestComponent />
+      </LoggerProvider>
+    ));
+
+    expect(received).toBeDefined();
+    expect(typeof received!.adapter).toBe("function");
+    expect(typeof received!.configure).toBe("function");
+    expect(received!.adapter()).toBeDefined();
+  });
+
+  it("can configure adapter via decorator function", () => {
+    const writeSpy = vi.fn();
+
+    let received: LoggerContextValue | undefined;
+
+    function TestComponent() {
+      received = useContext(LoggerContext);
+      return <div />;
+    }
+
+    render(() => (
+      <LoggerProvider>
+        <TestComponent />
+      </LoggerProvider>
+    ));
+
+    // Before configure: default adapter exists (consola-based)
+    expect(received!.adapter()).toBeDefined();
+
+    received!.configure((origin) => ({
+      write: (...args) => {
+        writeSpy(...args);
+        void origin.write(...args);
+      },
+    }));
+
+    const adapter = received!.adapter();
+    expect(adapter).toBeDefined();
+    void adapter.write("info", "test");
+    expect(writeSpy).toHaveBeenCalledWith("info", "test");
+  });
+});

package/tests/providers/PwaUpdateProvider.spec.tsx

@@ -0,0 +1,22 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { render, cleanup } from "@solidjs/testing-library";
+import { PwaUpdateProvider } from "../../src/providers/PwaUpdateProvider";
+import { NotificationProvider } from "../../src/components/feedback/notification/NotificationProvider";
+
+describe("PwaUpdateProvider", () => {
+  afterEach(() => {
+    cleanup();
+  });
+
+  it("renders children correctly", () => {
+    const { getByText } = render(() => (
+      <NotificationProvider>
+        <PwaUpdateProvider>
+          <div>child content</div>
+        </PwaUpdateProvider>
+      </NotificationProvider>
+    ));
+
+    expect(getByText("child content")).toBeDefined();
+  });
+});

package/tests/providers/ServiceClientContext.spec.tsx

@@ -0,0 +1,88 @@
+import { describe, it, expect } from "vitest";
+import { createRoot } from "solid-js";
+import { render } from "@solidjs/testing-library";
+import {
+  useServiceClient,
+  type ServiceClientContextValue,
+} from "../../src/providers/ServiceClientContext";
+import { ServiceClientProvider } from "../../src/providers/ServiceClientProvider";
+import { NotificationProvider } from "../../src/components/feedback/notification/NotificationProvider";
+import { ConfigContext } from "../../src/providers/ConfigContext";
+
+describe("ServiceClientContext", () => {
+  describe("useServiceClient", () => {
+    it("throws error when used without Provider", () => {
+      createRoot((dispose) => {
+        expect(() => useServiceClient()).toThrow(
+          "useServiceClient can only be used inside ServiceClientProvider",
+        );
+        dispose();
+      });
+    });
+  });
+});
+
+describe("ServiceClientProvider", () => {
+  it("useServiceClient works correctly inside Provider", () => {
+    let serviceClient: ServiceClientContextValue;
+
+    render(() => (
+      <ConfigContext.Provider value={{ clientName: "testApp" }}>
+        <NotificationProvider>
+          <ServiceClientProvider>
+            {(() => {
+              serviceClient = useServiceClient();
+              return null;
+            })()}
+          </ServiceClientProvider>
+        </NotificationProvider>
+      </ConfigContext.Provider>
+    ));
+
+    expect(serviceClient!).toBeDefined();
+    expect(typeof serviceClient!.connect).toBe("function");
+    expect(typeof serviceClient!.close).toBe("function");
+    expect(typeof serviceClient!.get).toBe("function");
+    expect(typeof serviceClient!.isConnected).toBe("function");
+  });
+
+  it("throws error when get is called with unconnected client key", () => {
+    let serviceClient: ServiceClientContextValue;
+
+    render(() => (
+      <ConfigContext.Provider value={{ clientName: "testApp" }}>
+        <NotificationProvider>
+          <ServiceClientProvider>
+            {(() => {
+              serviceClient = useServiceClient();
+              return null;
+            })()}
+          </ServiceClientProvider>
+        </NotificationProvider>
+      </ConfigContext.Provider>
+    ));
+
+    expect(() => serviceClient!.get("unknown")).toThrow(
+      "Client key not connected: unknown",
+    );
+  });
+
+  it("returns false when isConnected is called with unconnected key", () => {
+    let serviceClient: ServiceClientContextValue;
+
+    render(() => (
+      <ConfigContext.Provider value={{ clientName: "testApp" }}>
+        <NotificationProvider>
+          <ServiceClientProvider>
+            {(() => {
+              serviceClient = useServiceClient();
+              return null;
+            })()}
+          </ServiceClientProvider>
+        </NotificationProvider>
+      </ConfigContext.Provider>
+    ));
+
+    expect(serviceClient!.isConnected("unknown")).toBe(false);
+  });
+});