soseki 0.0.1

package/tests/core/_weak-id-registry.test.ts

@@ -0,0 +1,137 @@
+import { describe, test } from "vitest";
+import WeakIdRegistry from "../../src/core/_weak-id-registry.js";
+
+describe("オブジェクトの登録と ID の取得", () => {
+  test("未登録のオブジェクトを set すると、新しい ID が発行される", ({ expect }) => {
+    // Arrange
+    const registry = new WeakIdRegistry<object>();
+    const obj = {};
+
+    // Act
+    const id = registry.set(obj);
+
+    // Assert
+    expect(typeof id).toBe("string");
+    expect(id.length).toBeGreaterThan(0);
+  });
+
+  test("同じオブジェクトを再度 set すると、同じ ID が返される", ({ expect }) => {
+    // Arrange
+    const registry = new WeakIdRegistry<object>();
+    const obj = {};
+    const firstId = registry.set(obj);
+
+    // Act
+    const secondId = registry.set(obj);
+
+    // Assert
+    expect(secondId).toBe(firstId);
+  });
+
+  test("異なるオブジェクトを set すると、それぞれ異なる ID が発行される", ({ expect }) => {
+    // Arrange
+    const registry = new WeakIdRegistry<object>();
+    const obj1 = {};
+    const obj2 = {};
+
+    // Act
+    const id1 = registry.set(obj1);
+    const id2 = registry.set(obj2);
+
+    // Assert
+    expect(id1).not.toBe(id2);
+  });
+});
+
+describe("存在確認と双方向ルックアップ", () => {
+  test("登録済みのオブジェクトに対して has を呼び出すと、true が返る", ({ expect }) => {
+    // Arrange
+    const registry = new WeakIdRegistry<object>();
+    const obj = {};
+    registry.set(obj);
+
+    // Act
+    const result = registry.has(obj);
+
+    // Assert
+    expect(result).toBe(true);
+  });
+
+  test("未登録のオブジェクトに対して has を呼び出すと、false が返る", ({ expect }) => {
+    // Arrange
+    const registry = new WeakIdRegistry<object>();
+    const obj = {};
+
+    // Act
+    const result = registry.has(obj);
+
+    // Assert
+    expect(result).toBe(false);
+  });
+
+  test("オブジェクトから ID を取得すると、登録時に発行された ID と一致する", ({ expect }) => {
+    // Arrange
+    const registry = new WeakIdRegistry<object>();
+    const obj = {};
+    const expectedId = registry.set(obj);
+
+    // Act
+    const actualId = registry.get(obj);
+
+    // Assert
+    expect(actualId).toBe(expectedId);
+  });
+
+  test("ID からオブジェクトを取得すると、元のオブジェクトが返る", ({ expect }) => {
+    // Arrange
+    const registry = new WeakIdRegistry<object>();
+    const obj = {};
+    const id = registry.set(obj);
+
+    // Act
+    const retrievedObj = registry.get(id);
+
+    // Assert
+    expect(retrievedObj).toBe(obj);
+  });
+
+  test("未登録のオブジェクトを get すると、undefined が返る", ({ expect }) => {
+    // Arrange
+    const registry = new WeakIdRegistry<object>();
+    const obj = {};
+
+    // Act
+    const result = registry.get(obj);
+
+    // Assert
+    expect(result).toBeUndefined();
+  });
+
+  test("存在しない ID を get すると、undefined が返る", ({ expect }) => {
+    // Arrange
+    const registry = new WeakIdRegistry<object>();
+
+    // Act
+    const result = registry.get("non-existent-id");
+
+    // Assert
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("ID 発行の仕様", () => {
+  test("複数のオブジェクトを登録したとき、ID は 36 進数のインクリメント形式で発行される", ({ expect }) => {
+    // Arrange
+    const registry = new WeakIdRegistry<object>();
+    const objects = [{}, {}, {}];
+
+    // Act
+    const ids = objects.map((obj) => registry.set(obj));
+
+    // Assert
+    expect(ids.length).toBe(3);
+    expect(ids[0]).toBe("0");
+    expect(ids[1]).toBe("1");
+    expect(ids[2]).toBe("2");
+  });
+});

package/tests/core/deferred-promise.test.ts

@@ -0,0 +1,218 @@
+import { describe, test } from "vitest";
+import DeferredPromise from "../../src/core/deferred-promise.js";
+
+describe("インスタンス化と基本状態", () => {
+  test("新規作成されたとき、ステータスは pending になる", ({ expect }) => {
+    // Arrange & Act
+    const { promise } = DeferredPromise.withResolvers<string>();
+
+    // Assert
+    expect(promise.status).toBe("pending");
+  });
+});
+
+describe("resolve による解決", () => {
+  test("値を指定して resolve すると、ステータスが fulfilled になり、その値が保持される", ({ expect }) => {
+    // Arrange
+    const { promise, resolve } = DeferredPromise.withResolvers<string>();
+    const expectedValue = "成功";
+
+    // Act
+    resolve(expectedValue);
+
+    // Assert
+    expect(promise.status).toBe("fulfilled");
+    if (promise.status === "fulfilled") {
+      expect(promise.value).toBe(expectedValue);
+    }
+  });
+
+  test("PromiseLike な値を resolve すると、その Promise の解決を待ってから自身のステータスを更新する", async ({ expect }) => {
+    // Arrange
+    const { promise, resolve } = DeferredPromise.withResolvers<string>();
+    const innerPromise = Promise.resolve("内部解決");
+
+    // Act
+    resolve(innerPromise);
+
+    // Assert
+    // resolve 直後は pending（マイクロタスクで処理されるため）
+    expect(promise.status).toBe("pending");
+
+    // Promise の解決を待機
+    await innerPromise;
+    // 内部の then が呼ばれるのを待つために少し待機
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(promise.status).toBe("fulfilled");
+    if (promise.status === "fulfilled") {
+      expect(promise.value).toBe("内部解決");
+    }
+  });
+});
+
+describe("reject による拒否", () => {
+  test("理由を指定して reject すると、ステータスが rejected になり、その理由が保持される", ({ expect }) => {
+    // Arrange
+    const { promise, reject } = DeferredPromise.withResolvers<string>();
+    const reason = new Error("失敗");
+
+    // Act
+    reject(reason);
+
+    // Assert
+    expect(promise.status).toBe("rejected");
+    if (promise.status === "rejected") {
+      expect(promise.reason).toBe(reason);
+    }
+  });
+});
+
+describe("静的メソッド", () => {
+  test("DeferredPromise.resolve を使用したとき、即座に解決状態のインスタンスが生成される", ({ expect }) => {
+    // Arrange & Act
+    const value = 100;
+    const promise = DeferredPromise.resolve(value);
+
+    // Assert
+    expect(promise.status).toBe("fulfilled");
+    expect(promise.value).toBe(value);
+  });
+
+  test("DeferredPromise.reject を使用したとき、即座に拒否状態のインスタンスが生成される", ({ expect }) => {
+    // Arrange & Act
+    const reason = "error";
+    const promise = DeferredPromise.reject(reason);
+
+    // Assert
+    expect(promise.status).toBe("rejected");
+    expect(promise.reason).toBe(reason);
+  });
+
+  test("DeferredPromise.try で同期関数を実行したとき、その戻り値で解決される", ({ expect }) => {
+    // Arrange & Act
+    const promise = DeferredPromise.try(() => "sync result");
+
+    // Assert
+    expect(promise.status).toBe("fulfilled");
+    if (promise.status === "fulfilled") {
+      expect(promise.value).toBe("sync result");
+    }
+  });
+
+  test("DeferredPromise.try で例外が発生したとき、その例外を理由として拒否される", ({ expect }) => {
+    // Arrange & Act
+    const error = new Error("throw error");
+    const promise = DeferredPromise.try(() => {
+      throw error;
+    });
+
+    // Assert
+    expect(promise.status).toBe("rejected");
+    if (promise.status === "rejected") {
+      expect(promise.reason).toBe(error);
+    }
+  });
+});
+
+describe("メソッドチェーン (then)", () => {
+  test("解決後に then で登録されたコールバックが実行され、新しい値で解決される", async ({ expect }) => {
+    // Arrange
+    const { promise, resolve } = DeferredPromise.withResolvers<number>();
+    const results: number[] = [];
+
+    // Act
+    promise.then((val) => {
+      const next = val * 2;
+      results.push(next);
+      return next;
+    });
+    resolve(10);
+
+    // Assert
+    // 非同期実行を待機
+    await new Promise<void>((r) => queueMicrotask(r));
+
+    expect(results.length).toBe(1);
+    expect(results[0]!).toBe(20);
+  });
+
+  test("拒否後に then の第二引数（onRejected）が実行され、その戻り値で次の Promise が解決される", async ({ expect }) => {
+    // Arrange
+    const { promise, reject } = DeferredPromise.withResolvers<number>();
+    const error = new Error("fail");
+    let capturedReason: unknown;
+
+    // Act
+    const nextPromise = promise.then(
+      null,
+      (reason) => {
+        capturedReason = reason;
+        return "recovered";
+      },
+    );
+    reject(error);
+
+    // Assert
+    await new Promise<void>((r) => queueMicrotask(r));
+
+    expect(capturedReason).toBe(error);
+    // エラーハンドリングされると、後続は fulfilled になる仕様
+    expect(nextPromise.status).toBe("fulfilled");
+    if (nextPromise.status === "fulfilled") {
+      expect(nextPromise.value).toBe("recovered");
+    }
+  });
+
+  test("コールバック内で例外が発生したとき、後続の Promise が拒否される", async ({ expect }) => {
+    // Arrange
+    const { promise, resolve } = DeferredPromise.withResolvers<string>();
+    const error = new Error("callback error");
+
+    // Act
+    const nextPromise = promise.then(() => {
+      throw error;
+    });
+    resolve("ok");
+
+    // Assert
+    await new Promise<void>((r) => queueMicrotask(r));
+
+    expect(nextPromise.status).toBe("rejected");
+    if (nextPromise.status === "rejected") {
+      expect(nextPromise.reason).toBe(error);
+    }
+  });
+});
+
+describe("不変性", () => {
+  test("一度 fulfilled になった後は、再度 resolve しても値が変化しない", ({ expect }) => {
+    // Arrange
+    const { promise, resolve } = DeferredPromise.withResolvers<string>();
+
+    // Act
+    resolve("first");
+    resolve("second");
+
+    // Assert
+    expect(promise.status).toBe("fulfilled");
+    if (promise.status === "fulfilled") {
+      expect(promise.value).toBe("first");
+    }
+  });
+
+  test("一度 rejected になった後は、resolve してもステータスが変化しない", ({ expect }) => {
+    // Arrange
+    const { promise, resolve, reject } = DeferredPromise.withResolvers<string>();
+
+    // Act
+    reject("error");
+    resolve("success");
+
+    // Assert
+    expect(promise.status).toBe("rejected");
+    if (promise.status === "rejected") {
+      expect(promise.reason).toBe("error");
+    }
+  });
+});

package/tests/core/expect-history-entry.test.ts

@@ -0,0 +1,112 @@
+import { describe, test } from "vitest";
+import { UnexpectedValidationError } from "../../src/core/errors.js";
+import expectHistoryEntry, { type HistoryEntryLike } from "../../src/core/expect-history-entry.js";
+
+describe("有効な入力が与えられた場合", () => {
+  test("すべての項目が正当なとき、バリデーション済みの履歴エントリーを返す", ({ expect }) => {
+    // Arrange
+    const input: HistoryEntryLike = {
+      id: "550e8400-e29b-41d4-a716-446655440000",
+      url: "https://example.com/",
+      index: 0,
+    };
+
+    // Act
+    const result = expectHistoryEntry(input);
+
+    // Assert
+    expect(result).not.toBeNull();
+    expect(result?.id).toBe(input.id);
+    expect(result?.url.href).toBe(input.url);
+    expect(result?.index).toBe(input.index);
+  });
+});
+
+describe("入力値が空または欠損している場合", () => {
+  test("null が与えられたとき、null を返す", ({ expect }) => {
+    // Arrange
+    const input = null;
+
+    // Act
+    const result = expectHistoryEntry(input);
+
+    // Assert
+    expect(result).toBeNull();
+  });
+
+  test("undefined が与えられたとき、null を返す", ({ expect }) => {
+    // Arrange
+    const input = undefined;
+
+    // Act
+    const result = expectHistoryEntry(input);
+
+    // Assert
+    expect(result).toBeNull();
+  });
+
+  test("url が null のとき、null を返す", ({ expect }) => {
+    // Arrange
+    const input: HistoryEntryLike = {
+      id: "550e8400-e29b-41d4-a716-446655440000",
+      url: null,
+      index: 1,
+    };
+
+    // Act
+    const result = expectHistoryEntry(input);
+
+    // Assert
+    expect(result).toBeNull();
+  });
+});
+
+describe("不正な形式のデータが与えられた場合", () => {
+  test("index が負の整数のとき、エラーを投げる", ({ expect }) => {
+    // Arrange
+    const input: HistoryEntryLike = {
+      id: "550e8400-e29b-41d4-a716-446655440000",
+      url: "https://example.com/",
+      index: -1,
+    };
+
+    // Act & Assert
+    expect(() => expectHistoryEntry(input)).toThrow(UnexpectedValidationError);
+  });
+
+  test("id が UUID 形式でないとき、エラーを投げる", ({ expect }) => {
+    // Arrange
+    const input: HistoryEntryLike = {
+      id: "invalid-id",
+      url: "https://example.com/",
+      index: 0,
+    };
+
+    // Act & Assert
+    expect(() => expectHistoryEntry(input)).toThrow(UnexpectedValidationError);
+  });
+
+  test("url が不正形式のとき、エラーを投げる", ({ expect }) => {
+    // Arrange
+    const input: HistoryEntryLike = {
+      id: "550e8400-e29b-41d4-a716-446655440000",
+      url: "invalid-url",
+      index: 0,
+    };
+
+    // Act & Assert
+    expect(() => expectHistoryEntry(input)).toThrow();
+  });
+
+  test("index が整数ではないとき、エラーを投げる", ({ expect }) => {
+    // Arrange
+    const input: HistoryEntryLike = {
+      id: "550e8400-e29b-41d4-a716-446655440000",
+      url: "https://example.com/",
+      index: 1.5,
+    };
+
+    // Act & Assert
+    expect(() => expectHistoryEntry(input)).toThrow(UnexpectedValidationError);
+  });
+});

package/tests/core/init-loaders.test.ts

@@ -0,0 +1,172 @@
+import { test, vi } from "vitest";
+import type { HistoryEntryId } from "../../src/core/history-entry-id-schema.js";
+import initLoaders, { type InitLoadersParams } from "../../src/core/init-loaders.js";
+import RouteRequest from "../../src/core/route-request.js";
+
+test("指定されたルートのローダーがすべて実行され、データストアに保存されるとき、すべての処理が開始されるまで待機する", async ({ expect }) => {
+  // Arrange
+  const entryId = "59b2ba6e-5236-406c-9496-0a6bcd83b1ab" as HistoryEntryId;
+  const entryUrl = new URL("https://example.com/test");
+  const abortController = new AbortController();
+
+  const loader1 = vi.fn().mockResolvedValue("data 1");
+  const loader2 = vi.fn().mockResolvedValue("data 2");
+
+  const routes = [
+    {
+      params: { id: "1" },
+      dataFuncs: [{
+        action: undefined,
+        loader: loader1,
+        shouldAction: () => true,
+        shouldReload: () => true,
+      }],
+    },
+    {
+      params: { id: "2" },
+      dataFuncs: [{
+        action: undefined,
+        loader: loader2,
+        shouldAction: () => true,
+        shouldReload: () => true,
+      }],
+    },
+  ];
+
+  const dataStoreSetMock = vi.fn();
+  const dataStore = {
+    set: dataStoreSetMock,
+  } as any;
+
+  const params: InitLoadersParams = {
+    routes,
+    entry: { id: entryId, url: entryUrl },
+    dataStore,
+    signal: abortController.signal,
+  };
+
+  // Act
+  await initLoaders(params);
+
+  // Assert
+  // データストアへの保存を検証
+  expect(dataStoreSetMock).toHaveBeenCalledTimes(1);
+  const [savedId, dataMap] = dataStoreSetMock.mock.calls[0]!;
+  expect(savedId).toBe(entryId);
+  expect(dataMap.size).toBe(2);
+
+  // 各ローダーに正しい引数が渡されていることを検証
+  expect(loader1).toHaveBeenCalledWith(
+    expect.objectContaining({
+      params: { id: "1" },
+      request: expect.any(RouteRequest),
+    }),
+  );
+  expect(loader2).toHaveBeenCalledWith(
+    expect.objectContaining({
+      params: { id: "2" },
+      request: expect.any(RouteRequest),
+    }),
+  );
+});
+
+test("ローダーが定義されていないルートが含まれるとき、そのルートをスキップして処理を継続する", async ({ expect }) => {
+  // Arrange
+  const entryId = "59b2ba6e-5236-406c-9496-0a6bcd83b1ab" as HistoryEntryId;
+  const entryUrl = new URL("https://example.com/mixed");
+  const loader = vi.fn().mockResolvedValue("data");
+
+  const routes = [
+    {
+      params: {},
+      dataFuncs: [{
+        action: undefined,
+        loader: undefined, // ローダーなし
+        shouldAction: () => true,
+        shouldReload: () => true,
+      }],
+    },
+    {
+      params: { id: "exists" },
+      dataFuncs: [{
+        action: undefined,
+        loader,
+        shouldAction: () => true,
+        shouldReload: () => true,
+      }],
+    },
+  ];
+
+  const dataStoreSetMock = vi.fn();
+  const dataStore = {
+    set: dataStoreSetMock,
+  } as any;
+
+  const params: InitLoadersParams = {
+    routes,
+    entry: { id: entryId, url: entryUrl },
+    dataStore,
+    signal: new AbortController().signal,
+  };
+
+  // Act
+  await initLoaders(params);
+
+  // Assert
+  const [, dataMap] = dataStoreSetMock.mock.calls[0]!;
+  expect(dataMap.size).toBe(1);
+  expect(loader).toHaveBeenCalledTimes(1);
+});
+
+test("ローダーがエラーを返したときでも、他のローダーの処理を妨げず、すべての待機を完了する", async ({ expect }) => {
+  // Arrange
+  const entryId = "59b2ba6e-5236-406c-9496-0a6bcd83b1ab" as HistoryEntryId;
+  const entryUrl = new URL("https://example.com/error");
+
+  // 成功するローダーと失敗するローダーを用意
+  const successLoader = vi.fn().mockResolvedValue("success");
+  const errorLoader = vi.fn().mockRejectedValue(new Error("Loader Failed"));
+
+  const routes = [
+    {
+      params: {},
+      dataFuncs: [{
+        action: undefined,
+        loader: errorLoader,
+        shouldAction: () => true,
+        shouldReload: () => true,
+      }],
+    },
+    {
+      params: {},
+      dataFuncs: [{
+        action: undefined,
+        loader: successLoader,
+        shouldAction: () => true,
+        shouldReload: () => true,
+      }],
+    },
+  ];
+
+  const dataStoreSetMock = vi.fn();
+  const dataStore = {
+    set: dataStoreSetMock,
+  } as any;
+
+  const params: InitLoadersParams = {
+    routes,
+    entry: { id: entryId, url: entryUrl },
+    dataStore,
+    signal: new AbortController().signal,
+  };
+
+  // Act & Assert
+  // Promise.allSettled を使用しているため、個別のエラーで initLoaders 自体は reject されない
+  await expect(initLoaders(params)()).resolves.not.toThrow();
+
+  expect(successLoader).toHaveBeenCalled();
+  expect(errorLoader).toHaveBeenCalled();
+
+  const [, dataMap] = dataStoreSetMock.mock.calls[0]!;
+  expect(dataMap.size).toBe(2);
+});