@adobe/ccweb-add-on-ssl 2.4.1 → 3.0.0

package/src/test/app/WxpSSLReader.spec.ts

@@ -22,10 +22,11 @@
  * SOFTWARE.
  ********************************************************************************/
 
-import type { Preferences, Logger } from "@adobe/ccweb-add-on-core";
+import type { Logger, Preferences } from "@adobe/ccweb-add-on-core";
 import { ADD_ON_PREFERENCES_FILE, PreferenceJson } from "@adobe/ccweb-add-on-core";
-import { assert } from "chai";
 import devcert from "@adobe/ccweb-add-on-devcert";
+import chai, { assert, expect } from "chai";
+import chaiAsPromised from "chai-as-promised";
 import type { Stats } from "fs-extra";
 import fs from "fs-extra";
 import "mocha";
@@ -35,6 +36,8 @@ import { stubInterface } from "ts-sinon";
 import type { SSLReader } from "../../app/index.js";
 import { WxpSSLReader } from "../../app/index.js";
 
+chai.use(chaiAsPromised);
+
 describe("WxpSSLReader", () => {
     let sandbox: sinon.SinonSandbox;
 
@@ -42,11 +45,14 @@ describe("WxpSSLReader", () => {
     let logger: StubbedInstance<Logger>;
     let sslReader: SSLReader;
 
+    const hostname = "localhost.adobe.com";
+    const port = 5241;
+
     beforeEach(() => {
         sandbox = sinon.createSandbox();
 
-        preferences = stubInterface<Preferences>();
-        logger = stubInterface<Logger>();
+        preferences = stubInterface();
+        logger = stubInterface();
         sslReader = new WxpSSLReader(preferences, logger);
     });
 
@@ -56,7 +62,6 @@ describe("WxpSSLReader", () => {
 
     describe("isCustomSSL", () => {
         it(`should return false if SSL settings are not present in '${ADD_ON_PREFERENCES_FILE}' for the provided hostname.`, async () => {
-            const hostname = "localhost";
             const userPreference = new PreferenceJson({});
 
             preferences.get.returns(userPreference);
@@ -67,7 +72,6 @@ describe("WxpSSLReader", () => {
         });
 
         it(`should return true if SSL settings are present in '${ADD_ON_PREFERENCES_FILE}' for the provided hostname.`, async () => {
-            const hostname = "localhost";
             const userPreference = new PreferenceJson({
                 ssl: {
                     [hostname]: {
@@ -87,8 +91,6 @@ describe("WxpSSLReader", () => {
 
     describe("isWxpSSL", () => {
         it("should return false if devcert SSL certificate is not present for the provided hostname.", async () => {
-            const hostname = "localhost";
-
             sandbox.stub(devcert, "hasCertificateFor").withArgs(hostname).returns(false);
 
             const isWxpSSL = sslReader.isWxpSSL(hostname);
@@ -97,8 +99,6 @@ describe("WxpSSLReader", () => {
         });
 
         it("should return false if devcert SSL certificate is not present for the provided hostname.", async () => {
-            const hostname = "localhost";
-
             sandbox.stub(devcert, "hasCertificateFor").withArgs(hostname).returns(false);
 
             const isWxpSSL = sslReader.isWxpSSL(hostname);
@@ -109,8 +109,6 @@ describe("WxpSSLReader", () => {
 
     describe("read", async () => {
         it("should log error and exit when SSL certificate path is invalid for manually set up SSL.", async () => {
-            const hostname = "localhost";
-
             const certificatePath = "/some-directory/localhost/ssl/";
             const keyPath = "/some-directory/localhost/ssl/private-key.key";
             const userPreference = new PreferenceJson({
@@ -128,18 +126,15 @@ describe("WxpSSLReader", () => {
             lstatStub.withArgs(certificatePath).returns(certificateStats);
             lstatStub.withArgs(keyPath).returns(keyStats);
 
-            logger.error.returns();
             const exitStub = sandbox.stub(process, "exit");
 
-            await sslReader.read(hostname);
+            await sslReader.read(hostname, port);
 
             assert.equal(logger.error.calledOnceWith("Invalid SSL certificate file path."), true);
             assert.equal(exitStub.calledWith(1), true);
         });
 
         it("should log error and exit when SSL key path is invalid for manually set up SSL.", async () => {
-            const hostname = "localhost";
-
             const certificatePath = "/some-directory/localhost/ssl/certificate.cert";
             const keyPath = "/some-directory/localhost/ssl/";
             const userPreference = new PreferenceJson({
@@ -157,18 +152,15 @@ describe("WxpSSLReader", () => {
             lstatStub.withArgs(certificatePath).returns(certificateStats);
             lstatStub.withArgs(keyPath).returns(keyStats);
 
-            logger.error.returns();
             const exitStub = sandbox.stub(process, "exit");
 
-            await sslReader.read(hostname);
+            await sslReader.read(hostname, port);
 
             assert.equal(logger.error.calledOnceWith("Invalid SSL key file path."), true);
             assert.equal(exitStub.calledWith(1), true);
         });
 
-        it("should read and return SSL certificate and key data for manually set up SSL.", async () => {
-            const hostname = "localhost";
-
+        it("should read and return SSL data for manually set up SSL.", async () => {
             const certificatePath = "/some-directory/localhost/ssl/certificate.cert";
             const keyPath = "/some-directory/localhost/ssl/private-key.key";
             const userPreference = new PreferenceJson({
@@ -191,19 +183,97 @@ describe("WxpSSLReader", () => {
             readFileStub.withArgs(certificatePath).returns(certificateData);
             readFileStub.withArgs(keyPath).returns(keyData);
 
-            const sslData = await sslReader.read(hostname);
+            const sslData = await sslReader.read(hostname, port);
+
+            assert.equal(sslData.cert, certificateData);
+            assert.equal(sslData.key, keyData);
+
+            assert.equal(
+                logger.warning.getCall(0).calledWith("Could not determine the expiry of your SSL certificate."),
+                true
+            );
+            assert.equal(
+                logger.warning
+                    .getCall(1)
+                    .calledWith("If you are unable to sideload your add-on, please check the validity of:"),
+                true
+            );
+            assert.equal(
+                logger.warning.getCall(2).calledWith(`https://${hostname}:${port} certificate in your browser.`),
+                true
+            );
+        });
+
+        it("should read and return SSL data for automatically set up, valid SSL.", async () => {
+            const userPreference = new PreferenceJson({});
+            preferences.get.returns(userPreference);
+
+            sandbox.stub(devcert, "hasCertificateFor").withArgs(hostname).returns(true);
+            sandbox.stub(devcert, "caExpiryInDays").returns(50);
+            sandbox.stub(devcert, "certificateExpiryInDays").returns(100);
+
+            const certificateData = <Buffer>{};
+            const keyData = <Buffer>{};
+
+            const certificateForStub = sandbox.stub(devcert, "certificateFor");
+            // @ts-ignore -- IReturnData mock response
+            certificateForStub.withArgs(hostname).returns({ cert: certificateData, key: keyData });
+
+            const sslData = await sslReader.read(hostname, port);
 
             assert.equal(sslData.cert, certificateData);
             assert.equal(sslData.key, keyData);
         });
 
-        it("should read and return SSL certificate and key data for automatically set up SSL.", async () => {
-            const hostname = "localhost";
+        it("should log error and exit when automatically set up SSL has expired.", async () => {
+            const userPreference = new PreferenceJson({});
+            preferences.get.returns(userPreference);
+
+            sandbox.stub(devcert, "hasCertificateFor").withArgs(hostname).returns(true);
+            sandbox.stub(devcert, "caExpiryInDays").returns(0);
+            sandbox.stub(devcert, "certificateExpiryInDays").returns(100);
+
+            const exitStub = sandbox.stub(process, "exit");
+            exitStub.throws();
+
+            await expect(sslReader.read(hostname, port)).to.be.rejectedWith();
 
+            assert.equal(
+                logger.error.getCall(0).calledWith("Could not locate a valid SSL certificate to host the add-on."),
+                true
+            );
+            assert.equal(logger.error.getCall(1).calledWith("The SSL certificate has expired."), true);
+            assert.equal(
+                logger.warning
+                    .getCall(0)
+                    .calledWith("To re-create the SSL certificate, you may run:", { prefix: "\n" }),
+                true
+            );
+            assert.equal(
+                logger.information
+                    .getCall(0)
+                    .calledWith("npx @adobe/ccweb-add-on-ssl setup --hostname [hostname]", { prefix: "  " }),
+                true
+            );
+            assert.equal(logger.warning.getCall(1).calledWith("Example:", { prefix: "\n" }), true);
+            assert.equal(
+                logger.information.getCall(1).calledWith("npx @adobe/ccweb-add-on-ssl setup --hostname localhost", {
+                    prefix: "  ",
+                    postfix: "\n"
+                }),
+                true
+            );
+
+            assert.equal(exitStub.calledWith(1), true);
+        });
+
+        it("should read and return SSL data for automatically set up, valid SSL nearing expiry.", async () => {
             const userPreference = new PreferenceJson({});
             preferences.get.returns(userPreference);
 
             sandbox.stub(devcert, "hasCertificateFor").withArgs(hostname).returns(true);
+            sandbox.stub(devcert, "caExpiryInDays").returns(5);
+            sandbox.stub(devcert, "certificateExpiryInDays").returns(100);
 
             const certificateData = <Buffer>{};
             const keyData = <Buffer>{};
@@ -212,30 +282,34 @@ describe("WxpSSLReader", () => {
             // @ts-ignore -- IReturnData mock response
             certificateForStub.withArgs(hostname).returns({ cert: certificateData, key: keyData });
 
-            const sslData = await sslReader.read(hostname);
+            const sslData = await sslReader.read(hostname, port);
+
+            assert.equal(logger.warning.calledWith("Your SSL certificate will expire in 5 days."), true);
 
             assert.equal(sslData.cert, certificateData);
             assert.equal(sslData.key, keyData);
         });
 
         it("should log error and exit when SSL is not set up.", async () => {
-            const hostname = "localhost";
-
             const userPreference = new PreferenceJson({});
             preferences.get.returns(userPreference);
 
             sandbox.stub(devcert, "hasCertificateFor").returns(false);
 
-            logger.error.returns();
             const exitStub = sandbox.stub(process, "exit");
 
-            await sslReader.read(hostname);
+            await sslReader.read(hostname, port);
 
             assert.equal(
-                logger.error.calledOnceWith(
-                    "No SSL related certificate or key files were found. Please retry after setting them up.",
-                    { postfix: "\n" }
-                ),
+                logger.error.getCall(0).calledWith("Could not locate a valid SSL certificate to host the add-on."),
+                true
+            );
+            assert.equal(
+                logger.error
+                    .getCall(1)
+                    .calledWith(
+                        "If you had previously set it up, it may have been invalidated due to a version upgrade."
+                    ),
                 true
             );
             assert.equal(exitStub.calledWith(1), true);

package/src/test/commands/command.spec.ts

@@ -0,0 +1,108 @@
+/********************************************************************************
+ * MIT License
+
+ * © Copyright 2025 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 type { AnalyticsConsent, AnalyticsService } from "@adobe/ccweb-add-on-analytics";
+import { ITypes as IAnalyticsTypes } from "@adobe/ccweb-add-on-analytics";
+import { runCommand } from "@oclif/test";
+import { assert } from "chai";
+import "mocha";
+import sinon from "sinon";
+import type { StubbedInstance } from "ts-sinon";
+import { stubInterface } from "ts-sinon";
+import type { PurgeCommandExecutor, SetupCommandExecutor } from "../../app/index.js";
+import { IContainer, ITypes } from "../../config/index.js";
+import { SetupCommandOptions } from "../../models/SetupCommandOptions.js";
+import type { SetupCommandValidator } from "../../validators/SetupCommandValidator.js";
+
+describe("ccweb-add-on-ssl", () => {
+    let sandbox: sinon.SinonSandbox;
+
+    let container: sinon.SinonStub;
+    let namedContainer: sinon.SinonStub;
+
+    let analyticsConsent: StubbedInstance<AnalyticsConsent>;
+    let analyticsService: StubbedInstance<AnalyticsService>;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+
+        namedContainer = sandbox.stub(IContainer, "getNamed");
+
+        analyticsConsent = stubInterface();
+        analyticsService = stubInterface();
+
+        container = sandbox.stub(IContainer, "get");
+        container.withArgs(IAnalyticsTypes.AnalyticsConsent).returns(analyticsConsent);
+        container.withArgs(IAnalyticsTypes.AnalyticsService).returns(analyticsService);
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    describe("setup", () => {
+        let commandExecutor: StubbedInstance<SetupCommandExecutor>;
+        let commandValidator: StubbedInstance<SetupCommandValidator>;
+
+        beforeEach(() => {
+            commandExecutor = stubInterface();
+            commandExecutor.execute.resolves();
+
+            commandValidator = stubInterface();
+            commandValidator.validate.resolves();
+
+            namedContainer.withArgs(ITypes.CommandValidator, "setup").returns(commandValidator);
+            namedContainer.withArgs(ITypes.CommandExecutor, "setup").returns(commandExecutor);
+        });
+
+        it("should execute succesfully when correct parameters are passed.", async () => {
+            analyticsConsent.set.resolves();
+
+            await runCommand(["setup", "--hostname=localhost", "--analytics=on", "--verbose"], { root: "." });
+
+            const options = new SetupCommandOptions("localhost", false, true);
+            assert.equal(commandValidator.validate.calledOnceWith(options), true);
+            assert.equal(commandExecutor.execute.calledOnceWith(options), true);
+        });
+    });
+
+    describe("purge", () => {
+        let commandExecutor: StubbedInstance<PurgeCommandExecutor>;
+
+        beforeEach(() => {
+            commandExecutor = stubInterface();
+            commandExecutor.execute.resolves();
+
+            namedContainer.withArgs(ITypes.CommandExecutor, "purge").returns(commandExecutor);
+        });
+
+        it("should execute succesfully when correct parameters are passed.", async () => {
+            analyticsConsent.set.resolves();
+
+            await runCommand(["purge", "--analytics=on", "--verbose"], { root: "." });
+
+            assert.equal(commandExecutor.execute.calledOnce, true);
+        });
+    });
+});

package/src/test/commands/purge.spec.ts

@@ -0,0 +1,132 @@
+/********************************************************************************
+ * 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 type { AnalyticsConsent, AnalyticsService } from "@adobe/ccweb-add-on-analytics";
+import { ITypes as IAnalyticsTypes } from "@adobe/ccweb-add-on-analytics";
+import { Config } from "@oclif/core";
+import chai, { assert, expect } from "chai";
+import chaiAsPromised from "chai-as-promised";
+import "mocha";
+import sinon from "sinon";
+import type { StubbedInstance } from "ts-sinon";
+import { stubInterface } from "ts-sinon";
+import { AnalyticsErrorMarkers } from "../../AnalyticsMarkers.js";
+import { PurgeCommandExecutor } from "../../app/index.js";
+import { Purge } from "../../commands/purge.js";
+import { IContainer, ITypes } from "../../config/index.js";
+import { PROGRAM_NAME } from "../../constants.js";
+
+chai.use(chaiAsPromised);
+
+describe("Purge", () => {
+    let sandbox: sinon.SinonSandbox;
+
+    let container: sinon.SinonStub;
+    let namedContainer: sinon.SinonStub;
+
+    let commandExecutor: StubbedInstance<PurgeCommandExecutor>;
+
+    let analyticsConsent: StubbedInstance<AnalyticsConsent>;
+    let analyticsService: StubbedInstance<AnalyticsService>;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+
+        commandExecutor = stubInterface();
+        commandExecutor.execute.resolves();
+
+        namedContainer = sandbox.stub(IContainer, "getNamed");
+
+        namedContainer.withArgs(ITypes.CommandExecutor, "purge").returns(commandExecutor);
+
+        analyticsConsent = stubInterface();
+        analyticsService = stubInterface();
+
+        container = sandbox.stub(IContainer, "get");
+        container.withArgs(IAnalyticsTypes.AnalyticsConsent).returns(analyticsConsent);
+        container.withArgs(IAnalyticsTypes.AnalyticsService).returns(analyticsService);
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    describe("run", () => {
+        it("should execute succesfully when correct parameters are passed without analytics.", async () => {
+            analyticsConsent.get.resolves(true);
+
+            const hostname = "localhost";
+            const purge = new Purge(["--verbose"], new Config({ name: PROGRAM_NAME, version: "1.0.0", root: "." }));
+            sandbox
+                // @ts-ignore - Sidestep `this.parse()` error when calling `run()` directly.
+                .stub(purge, "parse")
+                .resolves({
+                    flags: { hostname, useExisting: false, analytics: undefined, verbose: false }
+                });
+
+            await purge.run();
+
+            assert.equal(analyticsConsent.get.callCount, 1);
+
+            assert.equal(commandExecutor.execute.calledOnce, true);
+        });
+
+        it("should execute succesfully when correct parameters are passed with analytics.", async () => {
+            analyticsConsent.get.resolves(true);
+            analyticsConsent.set.withArgs(false).resolves();
+
+            const hostname = "localhost";
+            const purge = new Purge(
+                ["--analytics", "off", "--verbose"],
+                new Config({ name: PROGRAM_NAME, version: "1.0.0", root: "." })
+            );
+            sandbox
+                // @ts-ignore - Sidestep `this.parse()` error when calling `run()` directly.
+                .stub(purge, "parse")
+                .resolves({
+                    flags: { hostname, useExisting: false, analytics: "off", verbose: true }
+                });
+
+            await purge.run();
+
+            assert.equal(analyticsConsent.set.calledOnceWith(false), true);
+
+            assert.equal(commandExecutor.execute.calledOnce, true);
+        });
+    });
+
+    describe("catch", () => {
+        it("should fail for any errors in command execution.", async () => {
+            const purge = new Purge([], new Config({ name: PROGRAM_NAME, version: "1.0.0", root: "." }));
+
+            const error = new Error("Something went wrong.");
+            await expect(purge.catch(error)).to.be.rejectedWith(error);
+
+            assert.equal(
+                analyticsService.postEvent.calledOnceWith(AnalyticsErrorMarkers.ERROR_SSL_PURGE, error.message, false),
+                true
+            );
+        });
+    });
+});

package/src/test/commands/setup.spec.ts

@@ -28,30 +28,27 @@ import { Config } from "@oclif/core";
 import chai, { assert, expect } from "chai";
 import chaiAsPromised from "chai-as-promised";
 import "mocha";
-import { createRequire } from "module";
 import sinon from "sinon";
 import type { StubbedInstance } from "ts-sinon";
 import { stubInterface } from "ts-sinon";
 import { AnalyticsErrorMarkers } from "../../AnalyticsMarkers.js";
-import type { CommandExecutor, SetupCommandExecutor } from "../../app/index.js";
+import type { SetupCommandExecutor } from "../../app/index.js";
 import { Setup } from "../../commands/setup.js";
 import { IContainer, ITypes } from "../../config/index.js";
+import { PROGRAM_NAME } from "../../constants.js";
 import { SetupCommandOptions } from "../../models/SetupCommandOptions.js";
-import type { CommandValidator } from "../../validators/CommandValidator.js";
 import type { SetupCommandValidator } from "../../validators/SetupCommandValidator.js";
 
 chai.use(chaiAsPromised);
 
-const { test } = createRequire(import.meta.url)("@oclif/test");
-
 describe("Setup", () => {
     let sandbox: sinon.SinonSandbox;
 
     let container: sinon.SinonStub;
     let namedContainer: sinon.SinonStub;
 
-    let commandExecutor: StubbedInstance<CommandExecutor>;
-    let commandValidator: StubbedInstance<CommandValidator>;
+    let commandExecutor: StubbedInstance<SetupCommandExecutor>;
+    let commandValidator: StubbedInstance<SetupCommandValidator>;
 
     let analyticsConsent: StubbedInstance<AnalyticsConsent>;
     let analyticsService: StubbedInstance<AnalyticsService>;
@@ -59,10 +56,10 @@ describe("Setup", () => {
     beforeEach(() => {
         sandbox = sinon.createSandbox();
 
-        commandExecutor = stubInterface<SetupCommandExecutor>();
+        commandExecutor = stubInterface();
         commandExecutor.execute.resolves();
 
-        commandValidator = stubInterface<SetupCommandValidator>();
+        commandValidator = stubInterface();
         commandValidator.validate.resolves();
 
         namedContainer = sandbox.stub(IContainer, "getNamed");
@@ -81,30 +78,27 @@ describe("Setup", () => {
         sandbox.restore();
     });
 
-    describe("setup", () => {
-        test.stdout()
-            .command(["setup", "--hostname=localhost", "--analytics=on", "--verbose"])
-            .it("should execute succesfully when correct parameters are passed.", async () => {
-                analyticsConsent.set.resolves();
-
-                const options = new SetupCommandOptions("localhost", false, true);
-                assert.equal(commandValidator.validate.calledOnceWith(options), true);
-                assert.equal(commandExecutor.execute.calledOnceWith(options), true);
-            });
-    });
-
     describe("run", () => {
         it("should execute succesfully when correct parameters are passed without analytics.", async () => {
             analyticsConsent.get.resolves(true);
 
             const hostname = "localhost";
-            const setup = new Setup(["--hostname", hostname, "--verbose"], new Config({ root: "." }));
+            const setup = new Setup(
+                ["--hostname", hostname, "--verbose"],
+                new Config({ name: PROGRAM_NAME, version: "1.0.0", root: "." })
+            );
+            sandbox
+                // @ts-ignore - Sidestep `this.parse()` error when calling `run()` directly.
+                .stub(setup, "parse")
+                .resolves({
+                    flags: { hostname, useExisting: false, analytics: undefined, verbose: false }
+                });
 
             await setup.run();
 
             assert.equal(analyticsConsent.get.callCount, 1);
 
-            const options = new SetupCommandOptions(hostname, false, true);
+            const options = new SetupCommandOptions(hostname, false, false);
             assert.equal(commandValidator.validate.calledOnceWith(options), true);
             assert.equal(commandExecutor.execute.calledOnceWith(options), true);
         });
@@ -116,8 +110,14 @@ describe("Setup", () => {
             const hostname = "localhost";
             const setup = new Setup(
                 ["--hostname", hostname, "--analytics", "off", "--verbose"],
-                new Config({ root: "." })
+                new Config({ name: PROGRAM_NAME, version: "1.0.0", root: "." })
             );
+            sandbox
+                // @ts-ignore - Sidestep `this.parse()` error when calling `run()` directly.
+                .stub(setup, "parse")
+                .resolves({
+                    flags: { hostname, useExisting: false, analytics: "off", verbose: true }
+                });
 
             await setup.run();
 
@@ -130,12 +130,11 @@ describe("Setup", () => {
     });
 
     describe("catch", () => {
-        it("should fail when incorrect parameters are passed.", async () => {
-            const setup = new Setup(["--incorrect-flag"], new Config({ root: "." }));
-
-            const error = new Error("Nonexistent flag: --incorrect-flag\nSee more help with --help");
+        it("should fail for any errors in command execution.", async () => {
+            const setup = new Setup([], new Config({ name: PROGRAM_NAME, version: "1.0.0", root: "." }));
 
-            await expect(setup.catch(error)).to.be.rejectedWith();
+            const error = new Error("Something went wrong.");
+            await expect(setup.catch(error)).to.be.rejectedWith(error);
 
             assert.equal(
                 analyticsService.postEvent.calledOnceWith(AnalyticsErrorMarkers.ERROR_SSL_SETUP, error.message, false),

package/tsconfig.json

@@ -17,11 +17,13 @@
         "outDir": "dist",
         "preserveConstEnums": true,
         "resolveJsonModule": true,
+        "skipLibCheck": true,
         "sourceMap": true,
         "strict": true,
         "target": "ESNext",
         "types": ["reflect-metadata"],
-        "useUnknownInCatchVariables": false
+        "useUnknownInCatchVariables": false,
+        "isolatedDeclarations": true
     },
     "exclude": ["node_modules", "src/test/**/*"],
     "include": ["src/**/*"],