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

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

@@ -0,0 +1,195 @@
+/********************************************************************************
+ * 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 { AnalyticsService } from "@adobe/ccweb-add-on-analytics";
+import { PreferenceJson, type Logger, type Preferences } from "@adobe/ccweb-add-on-core";
+import devcert from "@adobe/ccweb-add-on-devcert";
+import { assert } from "chai";
+import chalk from "chalk";
+import fs from "fs-extra";
+import "mocha";
+import path from "path";
+import prompts from "prompts";
+import type { SinonSandbox } from "sinon";
+import sinon from "sinon";
+import type { StubbedInstance } from "ts-sinon";
+import { stubInterface } from "ts-sinon";
+import { AnalyticsErrorMarkers, AnalyticsSuccessMarkers } from "../../AnalyticsMarkers.js";
+import type { CommandExecutor } from "../../app/index.js";
+import { PurgeCommandExecutor } from "../../app/index.js";
+import { SSLRemoveOption } from "../../models/index.js";
+
+describe("PurgeCommandExecutor", () => {
+    describe("execute", () => {
+        let sandbox: SinonSandbox;
+
+        let preferences: StubbedInstance<Preferences>;
+        let analyticsService: StubbedInstance<AnalyticsService>;
+        let logger: StubbedInstance<Logger>;
+
+        let commandExecutor: CommandExecutor;
+
+        beforeEach(() => {
+            sandbox = sinon.createSandbox();
+
+            preferences = stubInterface();
+            analyticsService = stubInterface();
+            logger = stubInterface();
+
+            commandExecutor = new PurgeCommandExecutor(preferences, analyticsService, logger);
+        });
+
+        afterEach(() => {
+            sandbox.restore();
+        });
+
+        const shouldPurgePrompt = {
+            type: "select",
+            name: "purgeConfirmation",
+            message: promptMessage("Are you sure you want to remove all SSL artifacts from your system"),
+            choices: [
+                { title: promptMessageOption("No, keep existing SSL artifacts"), value: SSLRemoveOption.Keep },
+                { title: promptMessageOption("Yes, remove all SSL artifacts"), value: SSLRemoveOption.Remove }
+            ],
+            initial: 0
+        };
+
+        it("should prompt on whether to remove SSL artifacts and log warning and exit when user does not select any option.", async () => {
+            const promptStub = sandbox.stub(prompts, "prompt");
+            promptStub.withArgs(shouldPurgePrompt).resolves({ purgeConfirmation: undefined });
+
+            analyticsService.postEvent.resolves();
+
+            await commandExecutor.execute();
+
+            assert.equal(
+                analyticsService.postEvent.calledOnceWith(
+                    AnalyticsErrorMarkers.ERROR_SSL_PURGE,
+                    "SSL purge option is not specified.",
+                    false
+                ),
+                true
+            );
+        });
+
+        it("should prompt on whether to remove SSL artifacts and exit when user chooses to keep the existing.", async () => {
+            const promptStub = sandbox.stub(prompts, "prompt");
+            promptStub.withArgs(shouldPurgePrompt).resolves({ purgeConfirmation: SSLRemoveOption.Keep });
+
+            await commandExecutor.execute();
+
+            assert.equal(analyticsService.postEvent.notCalled, true);
+            assert.equal(logger.information.notCalled, true);
+        });
+
+        it("should prompt on whether to remove SSL artifacts and remove both custom and WXP SSL artifacts when user chooses to remove.", async () => {
+            const promptStub = sandbox.stub(prompts, "prompt");
+            promptStub.withArgs(shouldPurgePrompt).resolves({ purgeConfirmation: SSLRemoveOption.Remove });
+
+            const preferenceJson = new PreferenceJson({
+                ssl: [
+                    [
+                        "localhost",
+                        {
+                            certificatePath: path.join("custom", "localhost", "certificate.cert"),
+                            keyPath: path.join("custom", "localhost", "private-key.key")
+                        }
+                    ],
+                    [
+                        "localhost.adobe.com",
+                        {
+                            certificatePath: path.join("custom", "localhost.adobe.com", "certificate.cert"),
+                            keyPath: path.join("custom", "localhost.adobe.com", "private-key.key")
+                        }
+                    ]
+                ]
+            });
+            preferences.get.returns(preferenceJson);
+
+            const wxpSSLLocation = path.join("wxp", "devcert");
+            sandbox.stub(devcert, "location").returns(wxpSSLLocation);
+
+            const existsStub = sandbox.stub(fs, "existsSync");
+            existsStub.withArgs(wxpSSLLocation).returns(true);
+
+            const removeAllStub = sandbox.stub(devcert, "removeAll");
+            removeAllStub.returns();
+
+            await commandExecutor.execute();
+
+            assert.equal(
+                logger.information.calledOnceWith("Removing and invalidating all SSL artifacts from your system ...", {
+                    prefix: "\n"
+                }),
+                true
+            );
+            assert.equal(
+                logger.message.getCall(0).calledWith("This may require you to enter your system's password,"),
+                true
+            );
+            assert.equal(
+                logger.message
+                    .getCall(1)
+                    .calledWith(
+                        "so that the SSL certificate can be removed from your system's trusted certificate path."
+                    ),
+                true
+            );
+            assert.equal(
+                logger.message.getCall(2).calledWith("[If this takes longer than expected, please break and retry]"),
+                true
+            );
+
+            preferenceJson.ssl = undefined;
+            assert.equal(preferences.set.calledOnceWith(preferenceJson), true);
+            assert.equal(
+                analyticsService.postEvent
+                    .getCall(0)
+                    .calledWith(AnalyticsSuccessMarkers.SUCCESSFUL_SSL_MANUAL_PURGE, "", true),
+                true
+            );
+
+            assert.equal(removeAllStub.calledOnce, true);
+            assert.equal(
+                analyticsService.postEvent
+                    .getCall(1)
+                    .calledWith(AnalyticsSuccessMarkers.SUCCESSFUL_SSL_AUTOMATIC_PURGE, "", true),
+                true
+            );
+
+            assert.equal(
+                logger.success.calledWith("Removed all SSL artifacts.", { prefix: "\n", postfix: "\n" }),
+                true
+            );
+        });
+    });
+});
+
+function promptMessage(message: string): string {
+    return chalk.hex("#E59400")(message);
+}
+
+function promptMessageOption(message: string): string {
+    return chalk.green.bold(message);
+}

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

@@ -25,10 +25,10 @@
 import type { AnalyticsService } from "@adobe/ccweb-add-on-analytics";
 import type { Logger, Preferences } from "@adobe/ccweb-add-on-core";
 import { ADD_ON_PREFERENCES_FILE, PreferenceJson } from "@adobe/ccweb-add-on-core";
+import devcert from "@adobe/ccweb-add-on-devcert";
 import chai, { assert, expect } from "chai";
 import chaiAsPromised from "chai-as-promised";
 import chalk from "chalk";
-import devcert from "@adobe/ccweb-add-on-devcert";
 import type { Stats } from "fs-extra";
 import fs from "fs-extra";
 import "mocha";
@@ -47,7 +47,7 @@ import { SSLRemoveOption, SSLSetupOption, SetupCommandOptions } from "../../mode
 
 chai.use(chaiAsPromised);
 
-describe("SSLSetupCommandExecutor", () => {
+describe("SetupCommandExecutor", () => {
     let sandbox: SinonSandbox;
 
     let preferences: StubbedInstance<Preferences>;
@@ -140,8 +140,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
-
                 const processExitStub = sandbox.stub(process, "exit");
 
                 const options = new SetupCommandOptions(hostname, true, false);
@@ -191,7 +189,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
                 logger.error.returns();
 
                 const processExitStub = sandbox.stub(process, "exit");
@@ -280,7 +277,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
                 logger.error.returns();
 
                 const processExitStub = sandbox.stub(process, "exit");
@@ -355,9 +351,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
-                logger.success.returns();
-
                 const existsStub = sandbox.stub(fs, "existsSync");
                 existsStub.withArgs(certificatePath).returns(true);
                 existsStub.withArgs(keyPath).returns(true);
@@ -422,10 +415,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
-                logger.success.returns();
-                logger.message.returns();
-
                 const options = new SetupCommandOptions(hostname, true, false);
                 await commandExecutor.execute(options);
 
@@ -444,7 +433,9 @@ describe("SSLSetupCommandExecutor", () => {
                 assert.equal(
                     logger.message
                         .getCall(0)
-                        .calledWith("This is only a one time step and may require you to enter your system's password"),
+                        .calledWith(
+                            "This is only a one time step and may require you to enter your system's password,"
+                        ),
                     true
                 );
                 assert.equal(
@@ -505,7 +496,7 @@ describe("SSLSetupCommandExecutor", () => {
                 initial: 0
             };
 
-            it("should prompt on whether to remove existing SSL and log warning and exit when user does not select any option.", async () => {
+            it("should prompt on whether to remove existing SSL and exit when user does not select any option.", async () => {
                 const hostname = "localhost";
                 sslReader.isCustomSSL.withArgs(hostname).returns(true);
                 sslReader.isWxpSSL.withArgs(hostname).returns(false);
@@ -515,8 +506,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
-
                 const processExitStub = sandbox.stub(process, "exit");
 
                 const exitError = new Error("Process exit.");
@@ -562,8 +551,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
-
                 const options = new SetupCommandOptions(hostname, false, false);
                 await commandExecutor.execute(options);
 
@@ -597,8 +584,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
-
                 preferences.get.onCall(0).returns(
                     new PreferenceJson({
                         ssl: {
@@ -620,9 +605,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
-                logger.success.returns();
-
                 const existsStub = sandbox.stub(fs, "existsSync");
                 existsStub.withArgs(certificatePath).returns(true);
                 existsStub.withArgs(keyPath).returns(true);
@@ -657,7 +639,12 @@ describe("SSLSetupCommandExecutor", () => {
                     true
                 );
 
-                assert.equal(logger.success.getCall(0).calledWith("Removed.", { postfix: "\n" }), true);
+                assert.equal(
+                    logger.success
+                        .getCall(0)
+                        .calledWith("Removed existing SSL certificate.", { prefix: "\n", postfix: "\n" }),
+                    true
+                );
 
                 assert.equal(
                     logger.success
@@ -674,7 +661,7 @@ describe("SSLSetupCommandExecutor", () => {
                 );
             });
 
-            it("should remove existing and create a new one when user chooses to remove an automatically set up SSL.", async () => {
+            it("should re-create an SSL certificate when user chooses to remove a valid, automatically set up SSL.", async () => {
                 const hostname = "localhost";
 
                 // SSL remove.
@@ -686,8 +673,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
-
                 // SSL setup.
                 promptStub.withArgs(sslSetupTypePrompt).resolves({
                     sslSetupType: SSLSetupOption.Automatically
@@ -705,6 +690,8 @@ describe("SSLSetupCommandExecutor", () => {
                     // @ts-ignore -- IReturnData mock response
                     .resolves({ cert: <Buffer>{}, key: <Buffer>{}, caPath });
 
+                sandbox.stub(devcert, "caExpiryInDays").returns(100);
+
                 const removeDomainStub = sandbox.stub(devcert, "removeDomain");
                 removeDomainStub.withArgs(hostname).resolves();
 
@@ -712,10 +699,6 @@ describe("SSLSetupCommandExecutor", () => {
 
                 analyticsService.postEvent.resolves();
 
-                logger.warning.returns();
-                logger.success.returns();
-                logger.message.returns();
-
                 const options = new SetupCommandOptions(hostname, false, false);
                 await commandExecutor.execute(options);
 
@@ -741,13 +724,137 @@ describe("SSLSetupCommandExecutor", () => {
                     true
                 );
 
-                assert.equal(logger.success.getCall(0).calledWith("Removed.", { postfix: "\n" }), true);
+                assert.equal(
+                    logger.success
+                        .getCall(0)
+                        .calledWith("Removed existing SSL certificate.", { prefix: "\n", postfix: "\n" }),
+                    true
+                );
+                assert.equal(logger.success.getCall(1).calledWith("SSL setup complete!", { prefix: "\n" }), true);
+
+                assert.equal(
+                    logger.message
+                        .getCall(0)
+                        .calledWith(
+                            "This is only a one time step and may require you to enter your system's password,"
+                        ),
+                    true
+                );
+                assert.equal(
+                    logger.message
+                        .getCall(1)
+                        .calledWith(
+                            "so that the SSL certificate can be added to your system's trusted certificate path."
+                        ),
+                    true
+                );
+                assert.equal(
+                    logger.message
+                        .getCall(2)
+                        .calledWith("[If this takes longer than expected, please break and retry]"),
+                    true
+                );
+
+                assert.equal(
+                    logger.information
+                        .getCall(0)
+                        .calledWith("Setting up self-signed SSL certificate ...", { prefix: "\n" }),
+                    true
+                );
+                assert.equal(
+                    logger.information
+                        .getCall(1)
+                        .calledWith(format("You can find the SSL certificate in {sslDirectory}.", { sslDirectory }), {
+                            postfix: "\n"
+                        }),
+                    true
+                );
+
+                assert.equal(
+                    analyticsService.postEvent
+                        .getCall(1)
+                        .calledWith(AnalyticsSuccessMarkers.SUCCESSFUL_SSL_AUTOMATIC_SETUP, options.hostname, true),
+                    true
+                );
+            });
+
+            it("should re-create an SSL certificate when user chooses to remove an expired, automatically set up SSL.", async () => {
+                const hostname = "localhost";
+
+                // SSL remove.
+                sslReader.isCustomSSL.withArgs(hostname).returns(false);
+                sslReader.isWxpSSL.withArgs(hostname).returns(true);
+
+                const promptStub = sandbox.stub(prompts, "prompt");
+                promptStub.withArgs(shouldRemovePrompt).resolves({ shouldRemove: SSLRemoveOption.Remove });
+
+                analyticsService.postEvent.resolves();
+
+                // SSL setup.
+                promptStub.withArgs(sslSetupTypePrompt).resolves({
+                    sslSetupType: SSLSetupOption.Automatically
+                });
+
+                preferences.get.onCall(1).returns(new PreferenceJson({}));
+                preferences.set.returns();
+
+                const caPath = "/some-directory/certificate-authority/certificate.cert";
+                const sslDirectory = `/some-directory/domains/${hostname}`;
+
+                sandbox
+                    .stub(devcert, "certificateFor")
+                    .withArgs(hostname, { getCaPath: true })
+                    // @ts-ignore -- IReturnData mock response
+                    .resolves({ cert: <Buffer>{}, key: <Buffer>{}, caPath });
+
+                sandbox.stub(devcert, "caExpiryInDays").returns(0);
+
+                const removeAllStub = sandbox.stub(devcert, "removeAll");
+                removeAllStub.returns();
+
+                sandbox.stub(path, "resolve").withArgs(caPath, "..", "..", "domains", hostname).returns(sslDirectory);
+
+                analyticsService.postEvent.resolves();
+
+                const options = new SetupCommandOptions(hostname, false, false);
+                await commandExecutor.execute(options);
+
+                assert.equal(removeAllStub.calledOnce, true);
+
+                assert.equal(
+                    logger.warning.calledOnceWith(
+                        format(
+                            "A trusted SSL certificate is already configured for the Add-on to run on https://{hostname}",
+                            { hostname: options.hostname }
+                        ),
+                        {
+                            prefix: "\n"
+                        }
+                    ),
+                    true
+                );
+
+                assert.equal(
+                    analyticsService.postEvent
+                        .getCall(0)
+                        .calledWith(AnalyticsSuccessMarkers.SUCCESSFUL_SSL_AUTOMATIC_REMOVE, options.hostname, true),
+                    true
+                );
+
+                assert.equal(
+                    logger.success
+                        .getCall(0)
+                        .calledWith("Removed existing SSL certificate.", { prefix: "\n", postfix: "\n" }),
+                    true
+                );
                 assert.equal(logger.success.getCall(1).calledWith("SSL setup complete!", { prefix: "\n" }), true);
 
                 assert.equal(
                     logger.message
                         .getCall(0)
-                        .calledWith("This is only a one time step and may require you to enter your system's password"),
+                        .calledWith(
+                            "This is only a one time step and may require you to enter your system's password,"
+                        ),
                     true
                 );
                 assert.equal(