@simplysm/solid 13.0.0-beta.6

package/tests/providers/ServiceClientContext.spec.tsx

@@ -0,0 +1,83 @@
+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("Provider 없이 사용하면 에러가 발생한다", () => {
+      createRoot((dispose) => {
+        expect(() => useServiceClient()).toThrow(
+          "useServiceClient는 ServiceClientProvider 내부에서만 사용할 수 있습니다",
+        );
+        dispose();
+      });
+    });
+  });
+});
+
+describe("ServiceClientProvider", () => {
+  it("Provider 내에서 useServiceClient가 정상 동작한다", () => {
+    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("연결하지 않은 키로 get 호출 시 에러가 발생한다", () => {
+    let serviceClient: ServiceClientContextValue;
+
+    render(() => (
+      <ConfigContext.Provider value={{ clientName: "testApp" }}>
+        <NotificationProvider>
+          <ServiceClientProvider>
+            {(() => {
+              serviceClient = useServiceClient();
+              return null;
+            })()}
+          </ServiceClientProvider>
+        </NotificationProvider>
+      </ConfigContext.Provider>
+    ));
+
+    expect(() => serviceClient!.get("unknown")).toThrow("연결하지 않은 클라이언트 키입니다. unknown");
+  });
+
+  it("연결하지 않은 키로 isConnected 호출 시 false를 반환한다", () => {
+    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);
+  });
+});

package/tests/providers/shared-data/SharedDataProvider.spec.tsx

@@ -0,0 +1,233 @@
+import { describe, expect, it, vi } from "vitest";
+import { render } from "@solidjs/testing-library";
+import "@simplysm/core-common";
+import {
+  SharedDataProvider,
+  useSharedData,
+  type SharedDataDefinition,
+  ServiceClientContext,
+  type ServiceClientContextValue,
+  NotificationContext,
+  type NotificationContextValue,
+} from "../../../src";
+
+interface TestData {
+  user: { id: number; name: string };
+}
+
+function createMockServiceClient() {
+  const listeners = new Map<string, (data: unknown) => PromiseLike<void>>();
+  let listenerCounter = 0;
+
+  const mockClient = {
+    addEventListener: vi.fn((_type: unknown, _info: unknown, cb: (data: unknown) => PromiseLike<void>) => {
+      const key = String(listenerCounter++);
+      listeners.set(key, cb);
+      return Promise.resolve(key);
+    }),
+    removeEventListener: vi.fn((_key: string) => Promise.resolve()),
+    emitToServer: vi.fn(() => Promise.resolve()),
+  };
+
+  const serviceClientValue: ServiceClientContextValue = {
+    connect: vi.fn(() => Promise.resolve()),
+    close: vi.fn(() => Promise.resolve()),
+    get: () => mockClient as never,
+    isConnected: () => true,
+  };
+
+  return { mockClient, serviceClientValue, listeners };
+}
+
+function createMockNotification(): NotificationContextValue {
+  return {
+    items: () => [],
+    unreadCount: () => 0,
+    latestUnread: () => undefined,
+    info: vi.fn(() => ""),
+    success: vi.fn(() => ""),
+    warning: vi.fn(() => ""),
+    danger: vi.fn(() => ""),
+    update: vi.fn(),
+    remove: vi.fn(),
+    markAsRead: vi.fn(),
+    markAllAsRead: vi.fn(),
+    dismissBanner: vi.fn(),
+    clear: vi.fn(),
+  };
+}
+
+function TestConsumer(props: { onData?: (shared: ReturnType<typeof useSharedData<TestData>>) => void }) {
+  const shared = useSharedData<TestData>();
+  props.onData?.(shared);
+
+  return (
+    <div>
+      <span data-testid="count">{shared.user.items().length}</span>
+      <span data-testid="loading">{shared.loading() ? "true" : "false"}</span>
+    </div>
+  );
+}
+
+describe("SharedDataProvider", () => {
+  it("초기 데이터를 로드하고 items()로 접근할 수 있다", async () => {
+    const { serviceClientValue } = createMockServiceClient();
+    const mockUsers = [
+      { id: 1, name: "Alice" },
+      { id: 2, name: "Bob" },
+    ];
+
+    const definitions: { user: SharedDataDefinition<{ id: number; name: string }> } = {
+      user: {
+        serviceKey: "main",
+        fetch: vi.fn(() => Promise.resolve(mockUsers)),
+        getKey: (item) => item.id,
+        orderBy: [[(item) => item.name, "asc"]],
+      },
+    };
+
+    const result = render(() => (
+      <NotificationContext.Provider value={createMockNotification()}>
+        <ServiceClientContext.Provider value={serviceClientValue}>
+          <SharedDataProvider<TestData> definitions={definitions}>
+            <TestConsumer />
+          </SharedDataProvider>
+        </ServiceClientContext.Provider>
+      </NotificationContext.Provider>
+    ));
+
+    await vi.waitFor(() => {
+      expect(result.getByTestId("count").textContent).toBe("2");
+    });
+
+    result.unmount();
+  });
+
+  it("get()으로 O(1) 단일 항목 조회가 가능하다", async () => {
+    const { serviceClientValue } = createMockServiceClient();
+    const mockUsers = [
+      { id: 1, name: "Alice" },
+      { id: 2, name: "Bob" },
+    ];
+
+    let sharedRef: ReturnType<typeof useSharedData<TestData>> | undefined;
+
+    const definitions: { user: SharedDataDefinition<{ id: number; name: string }> } = {
+      user: {
+        serviceKey: "main",
+        fetch: vi.fn(() => Promise.resolve(mockUsers)),
+        getKey: (item) => item.id,
+        orderBy: [[(item) => item.name, "asc"]],
+      },
+    };
+
+    const result = render(() => (
+      <NotificationContext.Provider value={createMockNotification()}>
+        <ServiceClientContext.Provider value={serviceClientValue}>
+          <SharedDataProvider<TestData> definitions={definitions}>
+            <TestConsumer
+              onData={(s) => {
+                sharedRef = s;
+              }}
+            />
+          </SharedDataProvider>
+        </ServiceClientContext.Provider>
+      </NotificationContext.Provider>
+    ));
+
+    await vi.waitFor(() => {
+      expect(result.getByTestId("count").textContent).toBe("2");
+    });
+
+    expect(sharedRef!.user.get(1)).toEqual({ id: 1, name: "Alice" });
+    expect(sharedRef!.user.get(999)).toBeUndefined();
+    expect(sharedRef!.user.get(undefined)).toBeUndefined();
+
+    result.unmount();
+  });
+
+  it("orderBy에 따라 정렬된 결과를 반환한다", async () => {
+    const { serviceClientValue } = createMockServiceClient();
+    const mockUsers = [
+      { id: 2, name: "Charlie" },
+      { id: 1, name: "Alice" },
+      { id: 3, name: "Bob" },
+    ];
+
+    let sharedRef: ReturnType<typeof useSharedData<TestData>> | undefined;
+
+    const definitions: { user: SharedDataDefinition<{ id: number; name: string }> } = {
+      user: {
+        serviceKey: "main",
+        fetch: vi.fn(() => Promise.resolve(mockUsers)),
+        getKey: (item) => item.id,
+        orderBy: [[(item) => item.name, "asc"]],
+      },
+    };
+
+    const result = render(() => (
+      <NotificationContext.Provider value={createMockNotification()}>
+        <ServiceClientContext.Provider value={serviceClientValue}>
+          <SharedDataProvider<TestData> definitions={definitions}>
+            <TestConsumer
+              onData={(s) => {
+                sharedRef = s;
+              }}
+            />
+          </SharedDataProvider>
+        </ServiceClientContext.Provider>
+      </NotificationContext.Provider>
+    ));
+
+    await vi.waitFor(() => {
+      expect(result.getByTestId("count").textContent).toBe("3");
+    });
+
+    const names = sharedRef!.user.items().map((u) => u.name);
+    expect(names).toEqual(["Alice", "Bob", "Charlie"]);
+
+    result.unmount();
+  });
+
+  it("loading()은 로드 중 true, 완료 후 false", async () => {
+    const { serviceClientValue } = createMockServiceClient();
+
+    let resolveUsers!: (value: { id: number; name: string }[]) => void;
+    const fetchPromise = new Promise<{ id: number; name: string }[]>((resolve) => {
+      resolveUsers = resolve;
+    });
+
+    const definitions: { user: SharedDataDefinition<{ id: number; name: string }> } = {
+      user: {
+        serviceKey: "main",
+        fetch: vi.fn(() => fetchPromise),
+        getKey: (item) => item.id,
+        orderBy: [],
+      },
+    };
+
+    const result = render(() => (
+      <NotificationContext.Provider value={createMockNotification()}>
+        <ServiceClientContext.Provider value={serviceClientValue}>
+          <SharedDataProvider<TestData> definitions={definitions}>
+            <TestConsumer />
+          </SharedDataProvider>
+        </ServiceClientContext.Provider>
+      </NotificationContext.Provider>
+    ));
+
+    // 로딩 중
+    await vi.waitFor(() => {
+      expect(result.getByTestId("loading").textContent).toBe("true");
+    });
+
+    // 로드 완료
+    resolveUsers([{ id: 1, name: "Alice" }]);
+
+    await vi.waitFor(() => {
+      expect(result.getByTestId("loading").textContent).toBe("false");
+    });
+
+    result.unmount();
+  });
+});