@adobe/ccweb-add-on-core 0.1.0

package/src/test/utilities/ConsoleLogger.spec.ts

@@ -0,0 +1,165 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2023 Adobe. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ********************************************************************************/
+
+import { assert } from "chai";
+import chalk from "chalk";
+import "mocha";
+import type { SinonSandbox } from "sinon";
+import sinon from "sinon";
+import type { Logger } from "../../utilities/index.js";
+import { ConsoleLogger } from "../../utilities/index.js";
+
+describe("ConsoleLogger", () => {
+    let sandbox: SinonSandbox;
+    let logger: Logger;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+        logger = new ConsoleLogger();
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    describe("message ...", () => {
+        const runs = [{ message: "" }, { message: " " }, { message: "Information Message" }];
+        runs.forEach(run => {
+            it(`should log message: '${run.message}' in console.`, () => {
+                const consoleLogStub = sandbox.stub(console, "log");
+                logger.message(run.message);
+                assert.equal(consoleLogStub.callCount, 1);
+                sinon.assert.calledWith(consoleLogStub, sinon.match(run.message));
+            });
+        });
+    });
+
+    describe("information ...", () => {
+        const runs = [
+            { message: "" },
+            { message: " " },
+            { message: "Information Message" },
+            { message: "Information Message", postfix: "\n" }
+        ];
+        runs.forEach(run => {
+            it(`should log message: '${run.message}' in console.`, () => {
+                const consoleLogStub = sandbox.stub(console, "log");
+
+                logger.information(run.message, { postfix: run.postfix });
+
+                let loggedMessage = run.message;
+                if (run.postfix) {
+                    loggedMessage = `${loggedMessage}${run.postfix}`;
+                }
+
+                assert.equal(consoleLogStub.callCount, 1);
+                sinon.assert.calledWith(consoleLogStub, sinon.match(chalk.cyan.bold(loggedMessage)));
+            });
+        });
+    });
+
+    describe("success ...", () => {
+        const runs = [
+            { message: "" },
+            { message: " " },
+            { message: "Success Message" },
+            { message: "Success Message", prefix: "\n" }
+        ];
+        runs.forEach(run => {
+            it(`should log message: '${run.message}' in console.`, () => {
+                const consoleLogStub = sandbox.stub(console, "log");
+
+                logger.success(run.message, { prefix: run.prefix });
+
+                let loggedMessage = run.message;
+                if (run.prefix) {
+                    loggedMessage = `${run.prefix}${run.message}`;
+                }
+
+                assert.equal(consoleLogStub.callCount, 1);
+                sinon.assert.calledWith(consoleLogStub, sinon.match(chalk.green.bold(loggedMessage)));
+            });
+        });
+    });
+
+    describe("warning ...", () => {
+        const runs = [
+            { message: "" },
+            { message: " " },
+            { message: "Warning Message" },
+            { message: "Warning Message", prefix: "[", postfix: "]" }
+        ];
+        runs.forEach(run => {
+            it(`should log message: '${run.message}' in console.`, () => {
+                const consoleLogStub = sandbox.stub(console, "log");
+
+                logger.warning(run.message, { prefix: run.prefix, postfix: run.postfix });
+
+                let loggedMessage = run.message;
+                if (run.prefix) {
+                    loggedMessage = `${run.prefix}${run.message}`;
+                }
+
+                if (run.postfix) {
+                    loggedMessage = `${loggedMessage}${run.postfix}`;
+                }
+
+                assert.equal(consoleLogStub.callCount, 1);
+                sinon.assert.calledWith(consoleLogStub, sinon.match(chalk.hex("#E59400").bold(loggedMessage)));
+            });
+        });
+    });
+
+    describe("error ...", () => {
+        const runs = [
+            { message: "" },
+            { message: " " },
+            { message: "Error Message" },
+            { message: new Error("Error Message") },
+            { message: new Error("Error Message"), prefix: "\n", postfix: "\n" }
+        ];
+        runs.forEach(run => {
+            it(`should log message: '${run.message}' in console.`, () => {
+                const consoleLogStub = sandbox.stub(console, "log");
+
+                logger.error(run.message, { prefix: run.prefix, postfix: run.postfix });
+
+                let consoleLogStubCount = 1;
+                if (run.prefix) {
+                    consoleLogStubCount++;
+                    sinon.assert.calledWith(consoleLogStub, sinon.match(chalk.red(run.prefix)));
+                }
+
+                sinon.assert.calledWith(consoleLogStub, sinon.match(chalk.red(run.message)));
+
+                if (run.postfix) {
+                    consoleLogStubCount++;
+                    sinon.assert.calledWith(consoleLogStub, sinon.match(chalk.red(run.prefix)));
+                }
+
+                assert.equal(consoleLogStub.callCount, consoleLogStubCount);
+            });
+        });
+    });
+});

package/src/test/utilities/Extensions.spec.ts

@@ -0,0 +1,240 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2023 Adobe. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ********************************************************************************/
+
+import { assert } from "chai";
+import type { Stats } from "fs";
+import type { Dirent } from "fs-extra";
+import fs from "fs-extra";
+import "mocha";
+import path from "path";
+import type { SinonSandbox } from "sinon";
+import sinon from "sinon";
+import {
+    getBaseUrl,
+    getJSONString,
+    isFile,
+    isNullOrWhiteSpace,
+    isObject,
+    removeSymbols,
+    traverseDirectory
+} from "../../utilities/Extensions.js";
+
+describe("Extensions", () => {
+    describe("getJSONString", () => {
+        it(`should return stringify-ed PackageJson with properties except for the undefined ones.`, () => {
+            const item = {
+                foo: "bar",
+                baz: "etc"
+            };
+
+            const itemJSONString = getJSONString(item);
+
+            assert.equal(removeSymbols(itemJSONString), removeSymbols(`{    "foo": "bar",    "baz": "etc"}`));
+        });
+    });
+
+    describe("isNullOrWhiteSpace", () => {
+        let runs = [{ value: null }, { value: undefined }, { value: "" }, { value: " " }, { value: "  " }];
+        runs.forEach(run => {
+            it("should return true for a null, undefined or whitespace.", () => {
+                assert.equal(isNullOrWhiteSpace(run.value), true);
+            });
+        });
+
+        runs = [{ value: "foo bar" }, { value: " foo bar " }];
+        runs.forEach(run => {
+            it("should return false for not a null or undefined or whitespace.", () => {
+                assert.equal(isNullOrWhiteSpace(run.value), false);
+            });
+        });
+    });
+
+    describe("isObject", () => {
+        let runs: { value: unknown }[] = [
+            { value: null },
+            { value: undefined },
+            { value: "hello world" },
+            { value: 10 },
+            { value: true }
+        ];
+        runs.forEach(run => {
+            it("should return false for a null, undefined or any primitive type.", () => {
+                assert.equal(isObject(run.value), false);
+            });
+        });
+
+        runs = [
+            { value: { foo: "bar" } },
+            { value: ["hello", "world"] },
+            { value: new Set([1, 2, 3]) },
+            { value: new Map([["foo", "bar"]]) }
+        ];
+        runs.forEach(run => {
+            it("should return true for an object, array or any iterable.", () => {
+                assert.equal(isObject(run.value), true);
+            });
+        });
+    });
+
+    describe("traverseDirectory", () => {
+        let sandbox: SinonSandbox;
+        beforeEach(() => {
+            sandbox = sinon.createSandbox();
+        });
+
+        afterEach(() => {
+            sandbox.restore();
+        });
+
+        it("should traverse through all files recursively in a directory and execute action on each file.", () => {
+            const logStub = sandbox.stub(console, "log");
+            logStub.returns();
+
+            const rootDirectory = "root";
+            const childDirectory = "child";
+            const rootFiles = [
+                { name: "file-1.html" },
+                { name: "file-2.js" },
+                { name: "file-3.css" },
+                { name: childDirectory }
+            ] as Dirent[];
+            const readDirStub = sandbox.stub(fs, "readdirSync");
+            readDirStub.withArgs(rootDirectory, { withFileTypes: true }).returns(rootFiles);
+
+            const directoryStats = <Stats>{
+                isDirectory: () => {
+                    return true;
+                }
+            };
+            const fileStats = <Stats>{
+                isDirectory: () => {
+                    return false;
+                }
+            };
+
+            const lstatStub = sandbox.stub(fs, "lstatSync");
+            rootFiles.forEach(file => {
+                if (file.name === childDirectory) {
+                    lstatStub.withArgs(path.join(rootDirectory, file.name)).returns(directoryStats);
+                } else {
+                    lstatStub.withArgs(path.join(rootDirectory, file.name)).returns(fileStats);
+                }
+            });
+
+            const childFiles = [{ name: "file-4.ts" }, { name: "file-5.tsx" }] as Dirent[];
+            readDirStub.withArgs(path.join(rootDirectory, childDirectory), { withFileTypes: true }).returns(childFiles);
+            childFiles.forEach(file => {
+                lstatStub.withArgs(path.join(rootDirectory, childDirectory, file.name)).returns(fileStats);
+            });
+
+            traverseDirectory(rootDirectory, file => console.log(file));
+
+            assert.equal(logStub.callCount, 5);
+            sinon.assert.calledWith(logStub.getCall(0), sinon.match(path.join(rootDirectory, "file-1.html")));
+            sinon.assert.calledWith(logStub.getCall(1), sinon.match(path.join(rootDirectory, "file-2.js")));
+            sinon.assert.calledWith(logStub.getCall(2), sinon.match(path.join(rootDirectory, "file-3.css")));
+            sinon.assert.calledWith(
+                logStub.getCall(3),
+                sinon.match(path.join(rootDirectory, childDirectory, "file-4.ts"))
+            );
+            sinon.assert.calledWith(
+                logStub.getCall(4),
+                sinon.match(path.join(rootDirectory, childDirectory, "file-5.tsx"))
+            );
+        });
+    });
+
+    describe("getBaseUrl", () => {
+        const runs = [
+            {
+                protocol: "https",
+                host: "localhost:5241",
+                expectedBaseUrl: "https://localhost:5241/"
+            },
+            {
+                protocol: "https",
+                host: "spice.adobe.com",
+                expectedBaseUrl: "https://spice.adobe.com/"
+            },
+            { protocol: "wss", host: "localhost:5241", expectedBaseUrl: "wss://localhost:5241/" },
+            { protocol: "wss", host: "spice.adobe.com", expectedBaseUrl: "wss://spice.adobe.com/" }
+        ];
+        runs.forEach(run => {
+            it("should return the Base URL from protocol and host.", () => {
+                const baseUrl = getBaseUrl(run.protocol, run.host);
+                assert.equal(baseUrl, run.expectedBaseUrl);
+            });
+        });
+    });
+
+    describe("removeSymbols", () => {
+        it("should remove symbols from a string.", () => {
+            const value = "Hello\n\r\tWorld";
+            const expectedValue = "HelloWorld";
+
+            assert.equal(removeSymbols(value), expectedValue);
+        });
+    });
+
+    describe("isFile", () => {
+        let sandbox: SinonSandbox;
+        beforeEach(() => {
+            sandbox = sinon.createSandbox();
+        });
+
+        afterEach(() => {
+            sandbox.restore();
+        });
+
+        it("should return false when the path does not exist.", () => {
+            const path = "foo/bar/";
+
+            sandbox.stub(fs, "existsSync").returns(false);
+
+            assert.equal(isFile(path), false);
+        });
+
+        it("should return false when the path is a directory.", () => {
+            const path = "foo/bar/";
+
+            sandbox.stub(fs, "existsSync").returns(true);
+
+            const directoryStats = <Stats>{ isFile: () => false };
+            sandbox.stub(fs, "lstatSync").returns(directoryStats);
+
+            assert.equal(isFile(path), false);
+        });
+
+        it("should return true when the path is of a file.", () => {
+            const path = "foo/bar/";
+
+            sandbox.stub(fs, "existsSync").returns(true);
+
+            const directoryStats = <Stats>{ isFile: () => true };
+            sandbox.stub(fs, "lstatSync").returns(directoryStats);
+
+            assert.equal(isFile(path), true);
+        });
+    });
+});

package/src/test/utilities/UncaughtExceptionHandler.spec.ts

@@ -0,0 +1,83 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2023 Adobe. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ********************************************************************************/
+
+import { assert } from "chai";
+import "mocha";
+import process from "process";
+import type { SinonSandbox } from "sinon";
+import sinon from "sinon";
+import type { StubbedInstance } from "ts-sinon";
+import { stubInterface } from "ts-sinon";
+import { IContainer, ITypes } from "../../config/index.js";
+import type { Logger } from "../../utilities/Logger.js";
+import { UncaughtExceptionHandler } from "../../utilities/index.js";
+
+describe("UncaughtExceptionHandler", () => {
+    let sandbox: SinonSandbox;
+    let logger: StubbedInstance<Logger>;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+        logger = stubInterface<Logger>();
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    describe("registerExceptionHandler", () => {
+        it("should register a handler for an 'uncaughtException'.", () => {
+            const processOnStub = sandbox.stub(process, "on");
+            processOnStub.resolves();
+
+            const programName = "test-program";
+            UncaughtExceptionHandler.registerExceptionHandler(programName);
+
+            assert.equal(processOnStub.getCall(0).args[0], "uncaughtException");
+        });
+    });
+
+    describe("handleUncaughtException", () => {
+        it("should log error and exit when an uncaught exception is encountered.", async () => {
+            const processExitStub = sandbox.stub(process, "exit");
+            processExitStub.resolves();
+
+            logger.error.returns();
+
+            const coreContainerStub = sandbox.stub(IContainer, "get");
+            coreContainerStub.withArgs(ITypes.Logger).returns(logger);
+
+            const programName = "test-program";
+            const error = new Error("Unexpected error.");
+
+            UncaughtExceptionHandler.handleUncaughtException(programName, error);
+
+            assert.equal(
+                logger.error.calledWith(`${programName} failed. Reason: ${error.message}`, { postfix: "\n" }),
+                true
+            );
+            assert.equal(processExitStub.calledWith(0), true);
+        });
+    });
+});

package/src/types/applicationConfigPath.d.ts

@@ -0,0 +1 @@
+declare module "application-config-path";

package/src/utilities/CLIPreferences.ts

@@ -0,0 +1,84 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2023 Adobe. All rights reserved.
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ ********************************************************************************/
+
+import applicationConfigPath from "application-config-path";
+import fs from "fs-extra";
+import hjson from "hjson";
+import { injectable } from "inversify";
+import os from "os";
+import path from "path";
+import "reflect-metadata";
+import { ADD_ON_PREFERENCES_FILE, CCWEB_ADDON_DIRECTORY } from "../constants.js";
+import { PreferenceJson } from "../models/PreferenceJson.js";
+import type { Preferences } from "./Preferences.js";
+
+/**
+ * Implementation class for configuring CCWeb Add-on CLI related preferences.
+ */
+@injectable()
+export class CLIPreferences implements Preferences {
+    private _cachedPreference?: PreferenceJson;
+
+    /**
+     * Get the CCWeb Add-on CLI related user preferences.
+     * @param fromCache - (Optional) Whether to return the cached user preference.
+     * @returns User preference represented as {@link PreferenceJson}.
+     */
+    get(fromCache?: boolean): PreferenceJson {
+        if (fromCache && this._cachedPreference !== undefined) {
+            return this._cachedPreference;
+        }
+
+        try {
+            const preferenceFilePath = this._preferenceFilePath;
+            if (!fs.existsSync(preferenceFilePath)) {
+                fs.ensureFileSync(preferenceFilePath);
+                fs.writeFileSync(preferenceFilePath, JSON.stringify({}, undefined, 4) + os.EOL);
+
+                return new PreferenceJson({});
+            }
+
+            const preferenceData = fs.readFileSync(preferenceFilePath, "utf-8").trim();
+            this._cachedPreference = new PreferenceJson(hjson.parse(preferenceData));
+
+            return this._cachedPreference;
+        } catch {
+            // Do not cache the preference when any error is encountered.
+            return new PreferenceJson({});
+        }
+    }
+
+    /**
+     * Set the CCWeb Add-on CLI related user preferences.
+     * @param preferenceJson - {@link PreferenceJson} reference.
+     */
+    set(preferenceJson: PreferenceJson): void {
+        fs.writeFileSync(this._preferenceFilePath, preferenceJson.toJSON() + os.EOL);
+        this._cachedPreference = preferenceJson;
+    }
+
+    private get _preferenceFilePath(): string {
+        return path.join(applicationConfigPath(CCWEB_ADDON_DIRECTORY), ADD_ON_PREFERENCES_FILE);
+    }
+}