Added vitests for blob options processor

Author: aabmets

vitest/tests/archive.test.ts

@@ -158,6 +158,7 @@ describe("removeAllDecompressedFiles", () => {
 
 describe("decompressArchive", () => {
    afterEach(vi.clearAllMocks);
+
    const option: t.RemoteBlobOption = { url: "", dest: "" };
    const details: t.DestDetails = {
       fileName: "",

vitest/tests/processor.test.ts

@@ -0,0 +1,63 @@
+/*
+ *   MIT License
+ *
+ *   Copyright (c) 2024, Mattias Aabmets
+ *
+ *   The contents of this file are subject to the terms and conditions defined in the License.
+ *   You may not use, modify, or distribute this file except in compliance with the License.
+ *
+ *   SPDX-License-Identifier: Apache-2.0
+ */
+
+import { processBlobOption } from "@src/processor";
+import * as u from "@testutils";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+describe("processBlobOption", () => {
+   afterEach(vi.restoreAllMocks);
+
+   it("should download when historical entry does not exist", async () => {
+      const [option] = u.setupProcessorTest();
+      const procRet = await processBlobOption({ contents: {}, option });
+      expect(procRet.skipDownload).toEqual(false);
+   });
+
+   it("should download when historical entry exists and alwaysPull is true", async () => {
+      const [option, contents] = u.setupProcessorTest({ alwaysPull: true });
+      const procRet = await processBlobOption({ contents, option });
+      expect(procRet.skipDownload).toEqual(false);
+   });
+
+   it("should skip download when all decompressed files exist", async () => {
+      const [option, contents] = u.setupProcessorTest({
+         decompress: true,
+         decompFilesExist: true,
+         filesList: ["asdfg.txt"],
+      });
+      const procRet = await processBlobOption({ contents, option });
+      expect(procRet.skipDownload).toEqual(true);
+   });
+
+   it("should download when all decompressed files do not exist", async () => {
+      const [option, contents] = u.setupProcessorTest({
+         decompress: true,
+         decompFilesExist: false,
+         filesList: ["asdfg.txt"],
+      });
+      const procRet = await processBlobOption({ contents, option });
+      expect(procRet.skipDownload).toEqual(false);
+   });
+
+   it("should skip download when option file file exists", async () => {
+      const [option, contents] = u.setupProcessorTest({ newFileExists: true });
+      const procRet = await processBlobOption({ contents, option });
+      expect(procRet.skipDownload).toEqual(true);
+   });
+
+   it("should download when historical file exists and option file does not", async () => {
+      const [option, contents, unlinkMock] = u.setupProcessorTest({ oldFileExists: true });
+      const procRet = await processBlobOption({ contents, option });
+      expect(procRet.skipDownload).toEqual(false);
+      expect(unlinkMock).toHaveBeenCalledOnce();
+   });
+});

vitest/testutils/index.ts

@@ -10,12 +10,16 @@
  */
 
 import crypto from "node:crypto";
+import fsp from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
+import archive from "@src/archive";
+import utils from "@src/utils";
 import type * as t from "@types";
+import { type MockInstance, vi } from "vitest";
 
 export function getTempDirPath() {
-   const randString = crypto.randomBytes(8).toString("hex");
+   const randString = crypto.randomBytes(16).toString("hex");
    return path.join(tmpdir(), "vitest", randString);
 }
 
@@ -51,3 +55,54 @@ export function getMustDownload(prettyName1?: string, prettyName2?: string): t.P
       } as t.ProcessorReturn,
    ];
 }
+
+export interface SetupArgs {
+   newFileExists?: boolean;
+   oldFileExists?: boolean;
+   alwaysPull?: boolean;
+   decompress?: boolean | t.DecompressionOptions;
+   decompFilesExist?: boolean;
+   filesList?: string[];
+}
+
+export type SetupReturn = [t.RemoteBlobOption, t.HistoryFileContents, MockInstance];
+
+export function setupProcessorTest(args?: SetupArgs): SetupReturn {
+   const option: t.RemoteBlobOption = {
+      url: "https://example.com/file.zip",
+      dest: "some/path/testFile.zip",
+      alwaysPull: args?.alwaysPull ?? false,
+      decompress: args?.decompress ?? false,
+   };
+   const blobDigest = utils.digestRemoteBlobOption(option);
+   const decompDigest = archive.digestDecompressionOptions(option.decompress);
+   const contents: t.HistoryFileContents = {
+      [blobDigest]: {
+         url: "https://example.com/file.zip",
+         dest: "/some/path/testFile.zip",
+         blobOptionsDigest: blobDigest,
+         decompression: {
+            optionsDigest: decompDigest,
+            filesList: args?.filesList ?? [],
+         },
+      },
+   };
+   const getDestDetails = (exists?: boolean) => {
+      return {
+         filePath: "/some/path/testFile.zip",
+         fileExists: !!exists,
+         dirPath: "/some/path",
+         dirExists: !!exists,
+         fileName: "testFile.zip",
+      };
+   };
+   vi.spyOn(utils, "getDestDetails")
+      .mockImplementationOnce(() => getDestDetails(args?.newFileExists))
+      .mockImplementationOnce(() => getDestDetails(args?.oldFileExists));
+   if (args?.decompress) {
+      vi.spyOn(archive, "allDecompressedFilesExist").mockResolvedValue(!!args?.decompFilesExist);
+      vi.spyOn(archive, "removeAllDecompressedFiles").mockImplementation(() => Promise.resolve());
+   }
+   const unlinkMock = vi.spyOn(fsp, "unlink").mockResolvedValue();
+   return [option, contents, unlinkMock];
+}