@glivion/square-screen-js-sdk 0.1.0 → 1.0.1

package/src/__tests__/cache/SquareScreenCache.test.ts

@@ -1,375 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { SquareScreenCache } from "../../cache/SquareScreenCache";
-import type { Playlist } from "../../core/types";
-
-// jsdom's `Blob` has no `.stream()`, but Undici `Response(blob)` consumes the body
-// via `blob.stream()`. Patch once so {@link SquareScreenCache.saveMedia} works unchanged.
-const BlobCtor = globalThis.Blob;
-if (typeof BlobCtor.prototype.stream !== "function") {
-  Object.defineProperty(BlobCtor.prototype, "stream", {
-    value(this: Blob) {
-      return new ReadableStream<Uint8Array>({
-        start: (controller) => {
-          void (async () => {
-            controller.enqueue(new Uint8Array(await this.arrayBuffer()));
-            controller.close();
-          })();
-        },
-      });
-    },
-    configurable: true,
-    enumerable: false,
-    writable: true,
-  });
-}
-
-// ---------------------------------------------------------------------------
-// IndexedDB mock (jsdom does not ship IndexedDB)
-// ---------------------------------------------------------------------------
-
-// Two-level map: dbName -> record key -> record value
-const idbStore = new Map<string, Map<string, unknown>>();
-
-vi.mock("idb", () => ({
-  openDB: vi.fn(async (dbName: string) => {
-    if (!idbStore.has(dbName)) idbStore.set(dbName, new Map());
-    const store = idbStore.get(dbName)!;
-    return {
-      get: vi.fn(async (_: string, key: string) => store.get(key)),
-      put: vi.fn(async (_: string, value: unknown) => {
-        const record = value as { uuid: string };
-        store.set(record.uuid, value);
-        return record.uuid;
-      }),
-      close: vi.fn(),
-    };
-  }),
-  deleteDB: vi.fn(async (dbName: string) => {
-    idbStore.delete(dbName);
-  }),
-}));
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-// Each test gets a unique DB name so state never bleeds between cases.
-let dbCounter = 0;
-function nextDb() {
-  return { dbName: `test-db-${++dbCounter}`, cacheName: `test-cache-${dbCounter}` };
-}
-
-function makePlaylist(overrides: Partial<Playlist> = {}): Playlist {
-  return {
-    uuid: "playlist-1",
-    cachedAt: Date.now(),
-    items: [
-      {
-        uuid: "item-1",
-        name: "Item 1",
-        type: "image",
-        url: "https://cdn.example.com/1.jpg",
-        duration: 5,
-      },
-    ],
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Cache API stub (jsdom does not implement the Cache API)
-// ---------------------------------------------------------------------------
-
-let blobStore: Map<string, Blob>;
-
-function buildMockCache() {
-  // Each call to caches.open() returns a handle backed by the same blobStore,
-  // so put() and match() see the same data within a single test.
-  const handle = {
-    match: vi.fn(async (req: RequestInfo) => {
-      const key = typeof req === "string" ? req : (req as Request).url;
-      const blob = blobStore.get(key);
-      // Return a fresh Response each time so the body is never "consumed".
-      return blob ? new Response(blob) : undefined;
-    }),
-    put: vi.fn(async (req: RequestInfo, res: Response) => {
-      const key = typeof req === "string" ? req : (req as Request).url;
-      blobStore.set(key, await res.blob());
-    }),
-    delete: vi.fn(async (req: RequestInfo) => {
-      const key = typeof req === "string" ? req : (req as Request).url;
-      return blobStore.delete(key);
-    }),
-    keys: vi.fn(async () => [...blobStore.keys()].map((k) => new Request(k))),
-  };
-  return { handle, open: vi.fn(async () => handle) };
-}
-
-// ---------------------------------------------------------------------------
-// Setup / teardown
-// ---------------------------------------------------------------------------
-
-let blobUrlCounter = 0;
-
-beforeEach(() => {
-  blobStore = new Map();
-  blobUrlCounter = 0;
-
-  const { open } = buildMockCache();
-  vi.stubGlobal("caches", { open });
-
-  vi.spyOn(URL, "createObjectURL").mockImplementation(
-    () => `blob:mock-${++blobUrlCounter}`,
-  );
-  vi.spyOn(URL, "revokeObjectURL").mockImplementation(() => {});
-});
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-  vi.restoreAllMocks();
-});
-
-// ---------------------------------------------------------------------------
-// getPlaylist
-// ---------------------------------------------------------------------------
-
-describe("getPlaylist", () => {
-  it("returns null when nothing has been stored", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    expect(await cache.getPlaylist("playlist-1")).toBeNull();
-  });
-
-  it("returns the playlist when the record is within its TTL", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    const playlist = makePlaylist();
-    await cache.savePlaylist(playlist, 60_000);
-
-    const result = await cache.getPlaylist("playlist-1");
-    expect(result).not.toBeNull();
-    expect(result!.uuid).toBe("playlist-1");
-    expect(result!.items).toHaveLength(1);
-  });
-
-  it("returns null when the TTL has expired and allowStale is false", async () => {
-    vi.useFakeTimers();
-    const cache = new SquareScreenCache(nextDb());
-    await cache.savePlaylist(makePlaylist(), 1_000);
-
-    vi.advanceTimersByTime(2_000); // skip past the 1 s TTL
-    expect(await cache.getPlaylist("playlist-1")).toBeNull();
-    vi.useRealTimers();
-  });
-
-  it("returns the stale playlist when allowStale is true", async () => {
-    vi.useFakeTimers();
-    const cache = new SquareScreenCache(nextDb());
-    await cache.savePlaylist(makePlaylist(), 1_000);
-
-    vi.advanceTimersByTime(2_000);
-    const result = await cache.getPlaylist("playlist-1", true);
-    expect(result).not.toBeNull();
-    expect(result!.uuid).toBe("playlist-1");
-    vi.useRealTimers();
-  });
-
-  it("does not expose the internal _ttl field to the caller", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    await cache.savePlaylist(makePlaylist(), 60_000);
-
-    const result = await cache.getPlaylist("playlist-1");
-    expect(result).not.toHaveProperty("_ttl");
-  });
-
-  it("returns updated data after savePlaylist overwrites the same UUID", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    await cache.savePlaylist(makePlaylist({ uuid: "playlist-1" }), 60_000);
-    await cache.savePlaylist(
-      makePlaylist({ uuid: "playlist-1", items: [] }),
-      60_000,
-    );
-
-    const result = await cache.getPlaylist("playlist-1");
-    expect(result!.items).toHaveLength(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// savePlaylist
-// ---------------------------------------------------------------------------
-
-describe("savePlaylist", () => {
-  it("persists items inline so getPlaylist returns them", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    const playlist = makePlaylist();
-    await cache.savePlaylist(playlist, 60_000);
-
-    const result = await cache.getPlaylist("playlist-1");
-    expect(result!.items[0].uuid).toBe("item-1");
-    expect(result!.items[0].url).toBe("https://cdn.example.com/1.jpg");
-  });
-
-  it("stores optional strategy and schedule fields", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    const playlist = makePlaylist({
-      strategy: { loop: false, shuffle: true, preloadCount: 2 },
-      schedule: { uuid: "sched-1", name: "Morning", priority: 1 },
-    });
-    await cache.savePlaylist(playlist, 60_000);
-
-    const result = await cache.getPlaylist("playlist-1");
-    expect(result!.strategy).toEqual({ loop: false, shuffle: true, preloadCount: 2 });
-    expect(result!.schedule?.uuid).toBe("sched-1");
-  });
-
-  it("refreshes cachedAt so TTL resets on overwrite", async () => {
-    vi.useFakeTimers();
-    const cache = new SquareScreenCache(nextDb());
-    await cache.savePlaylist(makePlaylist(), 5_000);
-
-    vi.advanceTimersByTime(4_000); // within original TTL
-    // Overwrite — resets the clock
-    await cache.savePlaylist(makePlaylist(), 5_000);
-    vi.advanceTimersByTime(4_000); // 8 s since first save, 4 s since overwrite
-
-    // Should still be fresh because the overwrite reset cachedAt
-    const result = await cache.getPlaylist("playlist-1");
-    expect(result).not.toBeNull();
-    vi.useRealTimers();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// getMediaUrl
-// ---------------------------------------------------------------------------
-
-describe("getMediaUrl", () => {
-  it("returns null when the media has not been downloaded", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    expect(await cache.getMediaUrl("https://cdn.example.com/1.jpg")).toBeNull();
-  });
-
-  it("creates and returns a blob URL when the media is in the Cache API", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    const blob = new Blob(["video"], { type: "video/mp4" });
-    await cache.saveMedia("https://cdn.example.com/1.mp4", blob);
-
-    const url = await cache.getMediaUrl("https://cdn.example.com/1.mp4");
-    expect(url).toMatch(/^blob:mock-/);
-  });
-
-  it("returns the same blob URL on repeated calls without calling createObjectURL again", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    const blob = new Blob(["img"], { type: "image/jpeg" });
-    await cache.saveMedia("https://cdn.example.com/1.jpg", blob);
-
-    const first = await cache.getMediaUrl("https://cdn.example.com/1.jpg");
-    const second = await cache.getMediaUrl("https://cdn.example.com/1.jpg");
-
-    expect(first).toBe(second);
-    // createObjectURL called exactly once: during saveMedia. getMediaUrl reuses it.
-    expect(URL.createObjectURL).toHaveBeenCalledTimes(1);
-  });
-
-  it("creates separate blob URLs for different URLs", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    await cache.saveMedia("https://cdn.example.com/a.jpg", new Blob(["a"]));
-    await cache.saveMedia("https://cdn.example.com/b.jpg", new Blob(["b"]));
-
-    const urlA = await cache.getMediaUrl("https://cdn.example.com/a.jpg");
-    const urlB = await cache.getMediaUrl("https://cdn.example.com/b.jpg");
-    expect(urlA).not.toBe(urlB);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// saveMedia
-// ---------------------------------------------------------------------------
-
-describe("saveMedia", () => {
-  it("returns a blob URL immediately", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    const result = await cache.saveMedia(
-      "https://cdn.example.com/1.jpg",
-      new Blob(["data"], { type: "image/jpeg" }),
-    );
-    expect(result).toMatch(/^blob:mock-/);
-  });
-
-  it("persists to the Cache API so getMediaUrl returns the same URL", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    const saved = await cache.saveMedia(
-      "https://cdn.example.com/1.jpg",
-      new Blob(["data"]),
-    );
-    const fetched = await cache.getMediaUrl("https://cdn.example.com/1.jpg");
-
-    // Both should be the same handle — no second createObjectURL call.
-    expect(fetched).toBe(saved);
-    expect(URL.createObjectURL).toHaveBeenCalledTimes(1);
-  });
-
-  it("overwrites an existing entry when called twice for the same URL", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    await cache.saveMedia("https://cdn.example.com/1.jpg", new Blob(["v1"]));
-    const second = await cache.saveMedia(
-      "https://cdn.example.com/1.jpg",
-      new Blob(["v2"]),
-    );
-
-    // The in-memory map is updated; subsequent getMediaUrl returns the latest handle.
-    const fetched = await cache.getMediaUrl("https://cdn.example.com/1.jpg");
-    expect(fetched).toBe(second);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// clear
-// ---------------------------------------------------------------------------
-
-describe("clear", () => {
-  it("revokes all outstanding blob URLs", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    await cache.saveMedia("https://cdn.example.com/a.jpg", new Blob(["a"]));
-    await cache.saveMedia("https://cdn.example.com/b.jpg", new Blob(["b"]));
-
-    await cache.clear();
-
-    expect(URL.revokeObjectURL).toHaveBeenCalledTimes(2);
-  });
-
-  it("removes all entries from the Cache API", async () => {
-    const opts = nextDb();
-    const cache = new SquareScreenCache(opts);
-    await cache.saveMedia("https://cdn.example.com/1.jpg", new Blob(["data"]));
-
-    await cache.clear();
-
-    // After clear, getMediaUrl must return null (Cache API entries gone and
-    // the in-memory objectUrls map is cleared too).
-    const fresh = new SquareScreenCache(opts);
-    expect(await fresh.getMediaUrl("https://cdn.example.com/1.jpg")).toBeNull();
-  });
-
-  it("makes getPlaylist return null after clearing IndexedDB", async () => {
-    const opts = nextDb();
-    const cache = new SquareScreenCache(opts);
-    await cache.savePlaylist(makePlaylist(), 60_000);
-
-    await cache.clear();
-
-    const fresh = new SquareScreenCache(opts);
-    expect(await fresh.getPlaylist("playlist-1")).toBeNull();
-  });
-
-  it("resets the in-memory blob URL map so getMediaUrl fetches fresh", async () => {
-    const cache = new SquareScreenCache(nextDb());
-    await cache.saveMedia("https://cdn.example.com/1.jpg", new Blob(["data"]));
-
-    await cache.clear();
-
-    // The blob store was also cleared by the mock, so getMediaUrl should return null.
-    const result = await cache.getMediaUrl("https://cdn.example.com/1.jpg");
-    expect(result).toBeNull();
-  });
-});

package/src/__tests__/network/NetworkClient.test.ts

@@ -1,217 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { NetworkClient } from "../../network/NetworkClient";
-import type { ApiPlaylistResponse } from "../../network/apiTypes";
-
-const BASE_URL = "https://api.example.com/v1";
-const DEVICE_ID = "device-123";
-const DEVICE_TOKEN = "token-abc";
-
-function mockJsonResponse(body: unknown, init: ResponseInit = {}): Response {
-  return new Response(JSON.stringify(body), {
-    status: 200,
-    headers: { "Content-Type": "application/json" },
-    ...init,
-  });
-}
-
-describe("NetworkClient", () => {
-  beforeEach(() => {
-    vi.stubGlobal("fetch", vi.fn());
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.restoreAllMocks();
-  });
-
-  it("fetchPlaylist sends auth headers and maps response", async () => {
-    const payload: ApiPlaylistResponse = {
-      playlist: { uuid: "playlist-1", name: "Default" },
-      items: [
-        {
-          uuid: "item-1",
-          name: "Image 1",
-          type: "image",
-          url: "https://cdn.example.com/1.jpg",
-          duration_seconds: 7,
-        },
-      ],
-      strategy: { loop: true, shuffle: false, preload_count: 1 },
-      schedule: { uuid: "s1", name: "schedule", priority: 1 },
-    };
-    vi.mocked(fetch).mockResolvedValueOnce(mockJsonResponse(payload));
-
-    const client = new NetworkClient(BASE_URL, DEVICE_ID, DEVICE_TOKEN);
-    const result = await client.fetchPlaylist();
-
-    expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/screen/now-playing`, {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Device-Id": DEVICE_ID,
-        "X-Device-Token": DEVICE_TOKEN,
-      },
-    });
-    expect(result.success).toBe(true);
-    if (!result.success) return;
-    expect(result.data.uuid).toBe("playlist-1");
-    expect(result.data.items[0]).toMatchObject({
-      uuid: "item-1",
-      duration: 7,
-    });
-    expect(result.data.strategy).toEqual({
-      loop: true,
-      shuffle: false,
-      preloadCount: 1,
-    });
-  });
-
-  it("builds filtered query for fetchVideoPlaylist", async () => {
-    vi.mocked(fetch).mockResolvedValueOnce(
-      mockJsonResponse({
-        playlist: { uuid: "playlist-2", name: "Video" },
-        items: [],
-        strategy: [],
-      }),
-    );
-
-    const client = new NetworkClient(BASE_URL, DEVICE_ID, DEVICE_TOKEN);
-    await client.fetchVideoPlaylist({
-      category: "sports",
-      quality: "hd",
-      limit: 3,
-      tags: ["foo", "bar"],
-    });
-
-    expect(fetch).toHaveBeenCalledWith(
-      `${BASE_URL}/screen/now-playing?type=video&category=sports&quality=hd&limit=3&tags=foo%2Cbar`,
-      expect.any(Object),
-    );
-  });
-
-  it("builds filtered query for fetchImagePlaylist", async () => {
-    vi.mocked(fetch).mockResolvedValueOnce(
-      mockJsonResponse({
-        playlist: { uuid: "playlist-3", name: "Image" },
-        items: [],
-        strategy: [],
-      }),
-    );
-
-    const client = new NetworkClient(BASE_URL, DEVICE_ID, DEVICE_TOKEN);
-    await client.fetchImagePlaylist({
-      category: "news",
-      limit: 2,
-      tags: ["frontpage"],
-    });
-
-    expect(fetch).toHaveBeenCalledWith(
-      `${BASE_URL}/screen/now-playing?type=image&category=news&limit=2&tags=frontpage`,
-      expect.any(Object),
-    );
-  });
-
-  it("returns auth errors for 401 and 403", async () => {
-    vi.mocked(fetch)
-      .mockResolvedValueOnce(new Response("{}", { status: 401 }))
-      .mockResolvedValueOnce(new Response("{}", { status: 403 }));
-    const client = new NetworkClient(BASE_URL, DEVICE_ID, DEVICE_TOKEN);
-
-    const unauthorized = await client.fetchPlaylist();
-    const forbidden = await client.fetchPlaylist();
-
-    expect(unauthorized).toEqual({
-      success: false,
-      error: { kind: "auth", message: "Unauthorized" },
-    });
-    expect(forbidden).toEqual({
-      success: false,
-      error: { kind: "auth", message: "Forbidden" },
-    });
-  });
-
-  it("returns network errors for non-auth HTTP failures", async () => {
-    vi.mocked(fetch).mockResolvedValueOnce(
-      new Response("{}", { status: 500, statusText: "Server Error" }),
-    );
-    const client = new NetworkClient(BASE_URL, DEVICE_ID, DEVICE_TOKEN);
-
-    const result = await client.fetchPlaylist();
-    expect(result).toEqual({
-      success: false,
-      error: { kind: "network", code: 500, message: "Server Error" },
-    });
-  });
-
-  it("returns parse error when JSON parsing fails", async () => {
-    vi.mocked(fetch).mockResolvedValueOnce(
-      new Response("not-json", { status: 200 }),
-    );
-    const client = new NetworkClient(BASE_URL, DEVICE_ID, DEVICE_TOKEN);
-
-    const result = await client.fetchPlaylist();
-    expect(result).toEqual({
-      success: false,
-      error: {
-        kind: "parse",
-        message: "Response could not be parsed as JSON",
-      },
-    });
-  });
-
-  it("returns network error when fetch throws", async () => {
-    vi.mocked(fetch).mockRejectedValueOnce(new Error("offline"));
-    const client = new NetworkClient(BASE_URL, DEVICE_ID, DEVICE_TOKEN);
-
-    const result = await client.fetchPlaylist();
-    expect(result).toEqual({
-      success: false,
-      error: {
-        kind: "network",
-        code: 0,
-        message: "offline",
-      },
-    });
-  });
-
-  it("maps heartbeat request body and response", async () => {
-    vi.mocked(fetch).mockResolvedValueOnce(mockJsonResponse({ received: true }));
-    const client = new NetworkClient(BASE_URL, DEVICE_ID, DEVICE_TOKEN);
-
-    const result = await client.healthCheck({
-      cpuUsage: 1,
-      playerVersion: "2.0.0",
-    });
-
-    expect(fetch).toHaveBeenCalledWith(`${BASE_URL}/screen/heartbeat`, {
-      method: "POST",
-      body: JSON.stringify({
-        cpu_usage: 1,
-        app_version: "2.0.0",
-      }),
-      headers: {
-        "Content-Type": "application/json",
-        "X-Device-Id": DEVICE_ID,
-        "X-Device-Token": DEVICE_TOKEN,
-      },
-    });
-    expect(result).toEqual({ success: true, data: { received: true } });
-  });
-
-  it("maps reportPlaybackEvent success payload", async () => {
-    vi.mocked(fetch).mockResolvedValueOnce(mockJsonResponse({ recorded: true }));
-    const client = new NetworkClient(BASE_URL, DEVICE_ID, DEVICE_TOKEN);
-    const event = {
-      media_uuid: "m1",
-      playlist_uuid: "p1",
-      schedule_uuid: "s1",
-      started_at: "2026-01-01T00:00:00.000Z",
-      ended_at: "2026-01-01T00:00:05.000Z",
-      duration_seconds: 5,
-      completed: true,
-    };
-
-    const result = await client.reportPlaybackEvent(event);
-    expect(result).toEqual({ success: true, data: { recorded: true } });
-  });
-});