Add template builder unit tests

Author: gsingh04

deployment/cdk-solution-helper/asset-packager/__tests__/handler.test.ts

@@ -8,52 +8,67 @@ import { existsSync } from "fs";
 import { mkdir, writeFile, rm } from "node:fs/promises";
 import { handler } from "../index";
 
-const mockAssetDirectoryPath = path.join(__dirname, "mock-dir");
-const mockOutputPath = path.join(__dirname, "mock-dir-output");
+const __assetDirectoryPath = path.join(__dirname, "mock-dir");
+const __outputPath = path.join(__dirname, "mock-dir-output");
 describe("Handler", () => {
   beforeAll(async function Arrange() {
-    await rm(mockAssetDirectoryPath, { recursive: true, force: true });
-    await rm(mockOutputPath, { recursive: true, force: true });
-    await mkdir(mockAssetDirectoryPath);
-    await mkdir(mockOutputPath);
+    await rm(__assetDirectoryPath, { recursive: true, force: true });
+    await rm(__outputPath, { recursive: true, force: true });
+    await mkdir(__assetDirectoryPath);
+    await mkdir(__outputPath);
   });
 
   it("should fail in absence of path inputs ", async function () {
     expect.assertions(2);
     await expect(handler("", "")).rejects.toThrowError("undefined input path");
-    await expect(handler(undefined, undefined)).rejects.toThrowError("undefined input path");
+    await expect(handler(undefined, undefined)).rejects.toThrowError(
+      "undefined input path"
+    );
   });
 
   it("should fail for invalid cdk asset path", async function () {
     expect.assertions(1);
-    await expect(handler("invalidPath", mockOutputPath)).rejects.toThrowError(/(ENOENT).+(invalidPath)/g);
+    await expect(handler("invalidPath", __outputPath)).rejects.toThrowError(
+      /(ENOENT).+(invalidPath)/g
+    );
   });
 
   it("should succeed if cdk assets not found", async function () {
-    await expect(handler(mockAssetDirectoryPath, "invalidPath")).resolves.toBeUndefined();
+    await expect(
+      handler(__assetDirectoryPath, "invalidPath")
+    ).resolves.toBeUndefined();
   });
 
   it("should fail for invalid output path", async function () {
     // Arrange
     expect.assertions(1);
-    const mockAssetPath = path.join(mockAssetDirectoryPath, "./asset.cdkAsset.zip");
+    const mockAssetPath = path.join(
+      __assetDirectoryPath,
+      "./asset.cdkAsset.zip"
+    );
     await writeFile(mockAssetPath, "NoOp");
     // Act, Assert
-    await expect(handler(mockAssetDirectoryPath, "invalidPath")).rejects.toThrowError(/(ENOENT).+(invalidPath)/g);
+    await expect(
+      handler(__assetDirectoryPath, "invalidPath")
+    ).rejects.toThrowError(/(ENOENT).+(invalidPath)/g);
     // Cleanup
     await rm(mockAssetPath);
   });
 
   it("should successfully stage zip for valid paths", async function () {
     const zipName = "asset.cdkAsset.zip";
-    const mockAssetPath = path.join(mockAssetDirectoryPath, zipName);
+    const mockAssetPath = path.join(__assetDirectoryPath, zipName);
     await writeFile(mockAssetPath, "NoOp");
-    await expect(handler(mockAssetDirectoryPath, mockOutputPath)).resolves.toBeUndefined();
-    expect(existsSync(path.join(mockOutputPath, zipName.split("asset.").pop()!))).toBe(true);
+    await expect(
+      handler(__assetDirectoryPath, __outputPath)
+    ).resolves.toBeUndefined();
+    expect(
+      existsSync(path.join(__outputPath, zipName.split("asset.").pop()!))
+    ).toBe(true);
   });
 
   afterAll(async function Cleanup() {
-    await rm(mockAssetDirectoryPath, { recursive: true, force: true });
-    await rm(mockOutputPath, { recursive: true, force: true });
+    await rm(__assetDirectoryPath, { recursive: true, force: true });
+    await rm(__outputPath, { recursive: true, force: true });
   });
 });

deployment/cdk-solution-helper/jest.config.ts

@@ -11,7 +11,12 @@ const config: Config = {
   transform: {
     "^.+\\.(t)sx?$": "ts-jest",
   },
-  collectCoverageFrom: ["**/*.ts", "!**/*.test.ts", "!./jest.config.ts", "!./jest.setup.ts"],
+  collectCoverageFrom: [
+    "**/*.ts",
+    "!**/*.test.ts",
+    "!./jest.config.ts",
+    "!./jest.setup.ts",
+  ],
   coverageReporters: [["lcov", { projectRoot: "../" }], "text"],
 };
 

deployment/cdk-solution-helper/template-builder/__tests__/handler.test.ts

@@ -3,4 +3,56 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// TODO
+import { mkdir, rm } from "node:fs/promises";
+import { handler } from "../index";
+import path from "path";
+
+const __templateDirectoryPath = path.join(__dirname, "myTemplateDir");
+const __solutionName = "sih";
+const __solutionVersion = "myMockVersion";
+const __lambdaAssetBucketName = "mockAssetBucket";
+const __template = {};
+describe("Handler", () => {
+  beforeAll(async function Arrange() {
+    await rm(__templateDirectoryPath, { recursive: true, force: true });
+    await mkdir(__templateDirectoryPath);
+  });
+
+  it("should fail in absence of path inputs ", async function () {
+    expect.assertions(2);
+    await expect(handler("", "", "", "")).rejects.toThrowError(
+      "undefined arguments"
+    );
+    await expect(
+      handler(undefined, undefined, undefined, undefined)
+    ).rejects.toThrowError("undefined arguments");
+  });
+
+  it("should succeed for invalid template directory path", async function () {
+    await expect(
+      handler(
+        "invalidPath",
+        __solutionName,
+        __lambdaAssetBucketName,
+        __solutionVersion
+      )
+    ).resolves.toBeUndefined();
+  });
+
+  it("should succeed if templates not found", async function () {
+    await expect(
+      handler(
+        __templateDirectoryPath,
+        __solutionName,
+        __lambdaAssetBucketName,
+        __solutionVersion
+      )
+    ).resolves.toBeUndefined();
+  });
+
+  xit("should update template resources", function () {});
+
+  afterAll(async function Cleanup() {
+    await rm(__templateDirectoryPath, { recursive: true, force: true });
+  });
+});

deployment/cdk-solution-helper/template-builder/index.ts

@@ -7,17 +7,24 @@ import { writeFile } from "node:fs/promises";
 import { TemplateBuilder } from "./template-builder";
 
 export async function handler(
-  templatePath: string | undefined,
+  templateDirectoryPath: string | undefined,
   solutionName: string | undefined,
   lambdaBucket: string | undefined,
   version: string | undefined
 ) {
-  if (!templatePath || !solutionName || !lambdaBucket || !version) throw new Error("undefined arguments");
-  const CDKHelper = new TemplateBuilder(templatePath, solutionName, lambdaBucket, version);
+  if (!templateDirectoryPath || !solutionName || !lambdaBucket || !version)
+    throw new Error("undefined arguments");
+  const CDKHelper = new TemplateBuilder(
+    templateDirectoryPath,
+    solutionName,
+    lambdaBucket,
+    version
+  );
   const templatePaths = await CDKHelper.getTemplateFilePaths();
   for (const path of templatePaths) {
     const templateContents = await CDKHelper.parseJsonTemplate(path);
-    const templateWithUpdatedLambdaCodeReference = await CDKHelper.updateLambdaAssetReference(templateContents);
+    const templateWithUpdatedLambdaCodeReference =
+      await CDKHelper.updateLambdaAssetReference(templateContents);
     const templateWithUpdatedBucketReference = CDKHelper.updateBucketReference(
       JSON.stringify(templateWithUpdatedLambdaCodeReference, null, 2)
     );