@editframe/cli 0.10.0-beta.5 → 0.10.0-beta.7

package/src/operations/syncAssetsDirectory/doAssetSync.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, test, vi } from "vitest";
+import type { SubAssetSync } from "./SubAssetSync.ts";
+import type { SyncStatusInfo } from "./SyncStatus.ts";
+import { doAssetSync } from "./doAssetSync.ts";
+
+const collectAsyncGenerator = async (
+  generator: SubAssetSync<unknown>,
+): Promise<
+  {
+    status: "info" | "success";
+    message: string;
+  }[]
+> => {
+  const result = [];
+  for await (const item of doAssetSync(generator)) {
+    result.push(item);
+  }
+  return result;
+};
+
+const buildFakeSync = (): SubAssetSync<unknown> => {
+  const fakeSyncStatus = {
+    isSynced: vi.fn().mockReturnValue(false),
+  } as unknown as SyncStatusInfo;
+  const fakeSync = {
+    label: "TEST_LABEL",
+    icon: "🧪",
+    path: "TEST_PATH",
+    readInfo: vi.fn().mockReturnValue(Promise.resolve(null)),
+    syncStatus: fakeSyncStatus,
+    markSynced: vi.fn().mockReturnValue(Promise.resolve()),
+    isComplete: vi.fn().mockReturnValue(false),
+    prepare: vi.fn().mockReturnValue(Promise.resolve()),
+    validate: vi.fn().mockReturnValue(Promise.resolve()),
+    create: vi.fn().mockReturnValue(Promise.resolve()),
+    upload: vi.fn().mockReturnValue(Promise.resolve()),
+  } as unknown as SubAssetSync<unknown>;
+  return fakeSync;
+};
+
+describe("doAssetSync", () => {
+  test("Succeeds if all steps are executed without error", async () => {
+    const fakeSync = buildFakeSync();
+    const messages = await collectAsyncGenerator(fakeSync);
+    expect(messages).toEqual([
+      {
+        status: "info",
+        message: "🧪  Syncing TEST_LABEL: TEST_PATH",
+      },
+      {
+        status: "success",
+        message: "Synced TEST_LABEL: TEST_PATH",
+      },
+    ]);
+  });
+
+  test("Succeeds if asset is already synced", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.syncStatus.isSynced = vi.fn().mockReturnValue(true);
+    const messages = await collectAsyncGenerator(fakeSync);
+    expect(messages).toEqual([
+      {
+        status: "info",
+        message: "Sub-asset has already been synced: TEST_PATH",
+      },
+    ]);
+  });
+
+  test("Succeeds if asset is already uploaded", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.isComplete = vi.fn().mockReturnValue(true);
+    const messages = await collectAsyncGenerator(fakeSync);
+    expect(messages).toEqual([
+      {
+        status: "info",
+        message: "🧪  Syncing TEST_LABEL: TEST_PATH",
+      },
+      {
+        status: "success",
+        message: "Synced TEST_LABEL: TEST_PATH",
+      },
+    ]);
+  });
+
+  test("Throws if prepare fails", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.prepare = vi
+      .fn()
+      .mockReturnValue(Promise.reject(new Error("TEST_ERROR")));
+    await expect(collectAsyncGenerator(fakeSync)).rejects.toThrow(
+      "Error validating TEST_LABEL: TEST_ERROR",
+    );
+  });
+
+  test("Throws if validate fails", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.validate = vi
+      .fn()
+      .mockReturnValue(Promise.reject(new Error("TEST_ERROR")));
+    await expect(collectAsyncGenerator(fakeSync)).rejects.toThrow(
+      "Error validating TEST_LABEL: TEST_ERROR",
+    );
+  });
+
+  test("Throws if create fails", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.create = vi
+      .fn()
+      .mockReturnValue(Promise.reject(new Error("TEST_ERROR")));
+    await expect(collectAsyncGenerator(fakeSync)).rejects.toThrow(
+      "Error creating TEST_LABEL: TEST_ERROR",
+    );
+  });
+
+  test("Throws if upload fails", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.upload = vi
+      .fn()
+      .mockReturnValue(Promise.reject(new Error("TEST_ERROR")));
+    await expect(collectAsyncGenerator(fakeSync)).rejects.toThrow(
+      "Error uploading TEST_LABEL: TEST_ERROR",
+    );
+  });
+
+  test("Throws if markSynced fails", async () => {
+    const fakeSync = buildFakeSync();
+    fakeSync.markSynced = vi
+      .fn()
+      .mockReturnValue(Promise.reject(new Error("TEST_ERROR")));
+    await expect(collectAsyncGenerator(fakeSync)).rejects.toThrow(
+      "Error marking TEST_LABEL as synced: TEST_ERROR",
+    );
+  });
+});

package/src/operations/syncAssetsDirectory/doAssetSync.ts

@@ -0,0 +1,62 @@
+import type { SubAssetSync } from "./SubAssetSync.ts";
+
+export const doAssetSync = async function* (
+  assetSync: SubAssetSync<unknown>,
+): AsyncGenerator<{
+  status: "info" | "success";
+  message: string;
+}> {
+  if (await assetSync.syncStatus.isSynced()) {
+    yield {
+      status: "info",
+      message: `Sub-asset has already been synced: ${assetSync.path}`,
+    };
+    return;
+  }
+
+  try {
+    await assetSync.prepare();
+    await assetSync.validate();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+
+    throw new Error(`Error validating ${assetSync.label}: ${message}`);
+  }
+
+  yield {
+    status: "info",
+    message: `${assetSync.icon}  Syncing ${assetSync.label}: ${assetSync.path}`,
+  };
+
+  try {
+    await assetSync.create();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+
+    throw new Error(`Error creating ${assetSync.label}: ${message}`);
+  }
+
+  if (!assetSync.isComplete()) {
+    try {
+      await assetSync.upload();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+
+      throw new Error(`Error uploading ${assetSync.label}: ${message}`);
+    }
+  }
+
+  try {
+    await assetSync.markSynced();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+
+    throw new Error(`Error marking ${assetSync.label} as synced: ${message}`);
+  }
+
+  yield {
+    status: "success",
+    message: `Synced ${assetSync.label}: ${assetSync.path}`,
+  };
+  return;
+};

package/src/operations/syncAssetsDirectory.test.ts

@@ -0,0 +1,482 @@
+import { describe, it } from "vitest";
+
+import { fixture, withFixtures } from "../../test-fixtures/fixture.ts";
+import {
+  mockCreateImageFile,
+  mockCreateIsobmffFile,
+  mockCreateIsobmffTrack,
+  mockGetUploadImageFile,
+  mockUploadIsobmffFileIndex,
+  useMSW,
+} from "../../test-fixtures/network.ts";
+
+describe("syncAssetsDirectory", () => {
+  const server = useMSW();
+
+  describe("Image sync", () => {
+    it("Syncs assets directory when file is already uploaded", async () => {
+      await withFixtures(
+        [fixture("test.png", "test.png")],
+        async ({
+          files: [testPng],
+          expectCacheFiles,
+          expectInfoFileContent,
+          syncAssetsDirectory,
+          cacheImage,
+        }) => {
+          server.use(
+            mockCreateImageFile({
+              complete: true,
+              id: "123",
+              filename: "test.png",
+              fixture: testPng!,
+            }),
+          );
+          await cacheImage(testPng!);
+          await syncAssetsDirectory();
+          await expectCacheFiles(testPng!, ["test.png", "test.png.info"]);
+
+          await expectInfoFileContent("test.png.info", testPng!, {
+            complete: true,
+            id: "123",
+          });
+        },
+      );
+    });
+
+    it("Syncs assets directory when file is not uploaded", async () => {
+      await withFixtures(
+        [fixture("test.png", "test.png")],
+        async ({
+          files: [testPng],
+          expectCacheFiles,
+          expectInfoFileContent,
+          cacheImage,
+          syncAssetsDirectory,
+        }) => {
+          server.use(
+            mockCreateImageFile({
+              complete: false,
+              id: "123",
+              filename: "test.png",
+              fixture: testPng!,
+            }),
+            mockGetUploadImageFile({
+              complete: true,
+              id: "123",
+              filename: "test.png",
+              fixture: testPng!,
+            }),
+          );
+          await cacheImage(testPng!);
+          await syncAssetsDirectory();
+          await expectCacheFiles(testPng!, ["test.png", "test.png.info"]);
+
+          await expectInfoFileContent("test.png.info", testPng!, {
+            complete: true,
+            id: "123",
+          });
+        },
+      );
+    });
+
+    it("Syncs assets directory when file is present with different name", async () => {
+      await withFixtures(
+        [fixture("test.png", "test.png"), fixture("test.png", "test2.png")],
+        async ({
+          files: [testPng, test2Png],
+          cacheImage,
+          syncAssetsDirectory,
+          expectCacheFiles,
+          expectInfoFileContent,
+        }) => {
+          server.use(
+            mockCreateImageFile({
+              complete: false,
+              id: "123",
+              filename: "test.png",
+              fixture: testPng!,
+            }),
+            mockGetUploadImageFile({
+              complete: true,
+              id: "123",
+              filename: "test.png",
+              fixture: testPng!,
+            }),
+            mockCreateImageFile({
+              complete: false,
+              id: "123",
+              filename: "test.png",
+              fixture: test2Png!,
+            }),
+            mockGetUploadImageFile({
+              complete: true,
+              id: "123",
+              filename: "test.png",
+              fixture: test2Png!,
+            }),
+          );
+
+          await cacheImage(testPng!);
+          await cacheImage(test2Png!);
+          await syncAssetsDirectory();
+          await expectCacheFiles(testPng!, [
+            "test.png",
+            "test.png.info",
+            "test2.png",
+            "test2.png.info",
+          ]);
+
+          await expectInfoFileContent("test.png.info", testPng!, {
+            complete: true,
+            id: "123",
+          });
+
+          await expectInfoFileContent("test2.png.info", testPng!, {
+            complete: true,
+            id: "123",
+          });
+        },
+      );
+    });
+  });
+
+  describe("A/V Sync", () => {
+    it("Syncs assets directory when fragment index is already uploaded", async () => {
+      await withFixtures(
+        [fixture("test.mp4", "test.mp4")],
+        async ({
+          files: [testMp4],
+          generateTrack,
+          generateTrackFragmentIndex,
+          syncAssetsDirectory,
+          expectInfoFileContent,
+          expectCacheFiles,
+        }) => {
+          const creationArgs = {
+            complete: true,
+            id: "123",
+            filename: "test.mp4",
+            fixture: testMp4!,
+          };
+          server.use(
+            mockCreateIsobmffFile(creationArgs),
+
+            mockCreateIsobmffTrack({
+              complete: true,
+              id: "track-1",
+              fileId: "123",
+              filename: "test.mp4",
+              fixture: testMp4!,
+            }),
+
+            mockCreateIsobmffFile(creationArgs),
+            mockCreateIsobmffTrack({
+              complete: true,
+              fileId: "123",
+              id: "track-2",
+              filename: "test.mp4",
+              fixture: testMp4!,
+            }),
+
+            mockCreateIsobmffFile(creationArgs),
+            mockUploadIsobmffFileIndex({
+              id: "123",
+              complete: true,
+            }),
+          );
+          await generateTrack(testMp4!, 1);
+          await generateTrack(testMp4!, 2);
+          await generateTrackFragmentIndex(testMp4!);
+
+          await syncAssetsDirectory();
+
+          await expectCacheFiles(testMp4!, [
+            "isobmff.info",
+            "test.mp4.track-1.mp4",
+            "test.mp4.track-1.mp4.info",
+            "test.mp4.track-2.mp4",
+            "test.mp4.track-2.mp4.info",
+            "test.mp4.tracks.json",
+            "test.mp4.tracks.json.info",
+          ]);
+
+          await expectInfoFileContent("isobmff.info", testMp4!, {
+            complete: true,
+            id: "123",
+            byte_size: 31,
+          });
+
+          await expectInfoFileContent("test.mp4.tracks.json.info", testMp4!, {
+            complete: true,
+            id: "123",
+            byte_size: 31,
+          });
+
+          await expectInfoFileContent("test.mp4.track-1.mp4.info", testMp4!, {
+            complete: true,
+            id: "123:track-1",
+            byte_size: 26434,
+          });
+
+          await expectInfoFileContent("test.mp4.track-2.mp4.info", testMp4!, {
+            complete: true,
+            id: "123:track-2",
+            byte_size: 26434,
+          });
+        },
+      );
+    });
+
+    it("Syncs assets directory when fragment index is not uploaded", async () => {
+      await withFixtures(
+        [fixture("test.mp4", "test.mp4")],
+        async ({
+          files: [testMp4],
+
+          syncAssetsDirectory,
+          expectCacheFiles,
+          expectInfoFileContent,
+          generateTrackFragmentIndex,
+          generateTrack,
+        }) => {
+          const creationArgs = {
+            complete: false,
+            id: "123",
+            filename: "test.mp4",
+            fixture: testMp4!,
+          };
+          server.use(
+            mockCreateIsobmffFile(creationArgs),
+            mockUploadIsobmffFileIndex({
+              id: "123",
+              complete: true,
+            }),
+
+            mockCreateIsobmffFile(creationArgs),
+            mockCreateIsobmffTrack({
+              complete: true,
+              id: "track-1",
+              fileId: "123",
+              filename: "test.mp4",
+              fixture: testMp4!,
+            }),
+
+            mockCreateIsobmffFile(creationArgs),
+            mockCreateIsobmffTrack({
+              complete: true,
+              fileId: "123",
+              id: "track-2",
+              filename: "test.mp4",
+              fixture: testMp4!,
+            }),
+          );
+          await generateTrackFragmentIndex(testMp4!);
+          await generateTrack(testMp4!, 1);
+          await generateTrack(testMp4!, 2);
+
+          await syncAssetsDirectory();
+
+          await expectCacheFiles(testMp4!, [
+            "isobmff.info",
+            "test.mp4.track-1.mp4",
+            "test.mp4.track-1.mp4.info",
+            "test.mp4.track-2.mp4",
+            "test.mp4.track-2.mp4.info",
+            "test.mp4.tracks.json",
+            "test.mp4.tracks.json.info",
+          ]);
+
+          await expectInfoFileContent("isobmff.info", testMp4!, {
+            complete: true,
+            id: "123",
+            byte_size: 31,
+          });
+
+          await expectInfoFileContent("test.mp4.tracks.json.info", testMp4!, {
+            byte_size: 31,
+            complete: true,
+            id: "123",
+          });
+
+          await expectInfoFileContent("test.mp4.track-1.mp4.info", testMp4!, {
+            byte_size: 26434,
+            complete: true,
+            id: "123:track-1",
+          });
+
+          await expectInfoFileContent("test.mp4.track-2.mp4.info", testMp4!, {
+            byte_size: 26434,
+            complete: true,
+            id: "123:track-2",
+          });
+        },
+      );
+    });
+
+    it("Syncs assets when file has already been synced with a different name", async () => {
+      await withFixtures(
+        [fixture("test.mp4", "test.mp4"), fixture("test.mp4", "test2.mp4")],
+        async ({
+          files: [testMp4, test2Mp4],
+          syncAssetsDirectory,
+          generateTrackFragmentIndex,
+          generateTrack,
+          expectInfoFileContent,
+          expectCacheFiles,
+        }) => {
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: testMp4!,
+            }),
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: testMp4!,
+            }),
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: testMp4!,
+            }),
+
+            mockCreateIsobmffTrack({
+              complete: true,
+              id: "track-1",
+              fileId: "123",
+              filename: "test.mp4",
+              fixture: test2Mp4!,
+            }),
+
+            mockCreateIsobmffTrack({
+              complete: true,
+              id: "track-2",
+              fileId: "123",
+              filename: "test.mp4",
+              fixture: test2Mp4!,
+            }),
+
+            mockUploadIsobmffFileIndex({
+              id: "123",
+              complete: true,
+            }),
+          );
+          server.use(
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: testMp4!,
+            }),
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: testMp4!,
+            }),
+            mockCreateIsobmffFile({
+              complete: true,
+              id: "123",
+              filename: "test.mp4",
+              fixture: testMp4!,
+            }),
+
+            mockCreateIsobmffTrack({
+              complete: true,
+              id: "track-1",
+              fileId: "123",
+              filename: "test.mp4",
+              fixture: test2Mp4!,
+            }),
+
+            mockCreateIsobmffTrack({
+              complete: true,
+              id: "track-2",
+              fileId: "123",
+              filename: "test.mp4",
+              fixture: test2Mp4!,
+            }),
+
+            mockUploadIsobmffFileIndex({
+              id: "123",
+              complete: true,
+            }),
+          );
+
+          await generateTrackFragmentIndex(testMp4!);
+          await generateTrack(testMp4!, 1);
+          await generateTrack(testMp4!, 2);
+
+          await generateTrackFragmentIndex(test2Mp4!);
+          await generateTrack(test2Mp4!, 1);
+          await generateTrack(test2Mp4!, 2);
+          await syncAssetsDirectory();
+
+          await expectCacheFiles(test2Mp4!, [
+            "isobmff.info",
+            "test.mp4.track-1.mp4",
+            "test.mp4.track-1.mp4.info",
+            "test.mp4.track-2.mp4",
+            "test.mp4.track-2.mp4.info",
+            "test.mp4.tracks.json",
+
+            "test.mp4.tracks.json.info",
+            "test2.mp4.track-1.mp4",
+            "test2.mp4.track-1.mp4.info",
+            "test2.mp4.track-2.mp4",
+            "test2.mp4.track-2.mp4.info",
+            "test2.mp4.tracks.json",
+            "test2.mp4.tracks.json.info",
+          ]);
+
+          await expectInfoFileContent("isobmff.info", testMp4!, {
+            byte_size: 31,
+            complete: true,
+            id: "123",
+          });
+
+          await expectInfoFileContent("test2.mp4.tracks.json.info", testMp4!, {
+            byte_size: 31,
+            complete: true,
+            id: "123",
+          });
+
+          await expectInfoFileContent("test2.mp4.track-1.mp4.info", testMp4!, {
+            byte_size: 26434,
+            complete: true,
+            id: "123:track-1",
+          });
+
+          await expectInfoFileContent("test2.mp4.track-2.mp4.info", testMp4!, {
+            byte_size: 26434,
+            complete: true,
+            id: "123:track-2",
+          });
+
+          await expectInfoFileContent("test.mp4.tracks.json.info", testMp4!, {
+            byte_size: 31,
+            complete: true,
+            id: "123",
+          });
+
+          await expectInfoFileContent("test.mp4.track-1.mp4.info", testMp4!, {
+            byte_size: 26434,
+            complete: true,
+            id: "123:track-1",
+          });
+
+          await expectInfoFileContent("test.mp4.track-2.mp4.info", testMp4!, {
+            byte_size: 26434,
+            complete: true,
+            id: "123:track-2",
+          });
+        },
+      );
+    });
+  });
+});