@adobe/create-ccweb-add-on 2.5.0 → 3.1.0

package/src/test/app/{AddOnTemplateSelector.spec.ts → TemplateSelector.spec.ts}

@@ -34,12 +34,11 @@ import sinon from "sinon";
 import type { StubbedInstance } from "ts-sinon";
 import { stubInterface } from "ts-sinon";
 import { AnalyticsErrorMarkers } from "../../AnalyticsMarkers.js";
-import { AddOnTemplateSelector } from "../../app/AddOnTemplateSelector.js";
-import type { TemplateSelector } from "../../app/TemplateSelector.js";
+import { TemplateSelector } from "../../app/TemplateSelector.js";
 import { ADD_ON_TEMPLATES, PROGRAM_NAME, WITH_DOCUMENT_SANDBOX } from "../../constants.js";
-import { CLIOptions } from "../../models/index.js";
+import { CLIOptions } from "../../models/CLIOptions.js";
 
-describe("AddOnTemplateSelector", () => {
+describe("TemplateSelector", () => {
     let sandbox: SinonSandbox;
 
     let logger: StubbedInstance<Logger>;
@@ -70,21 +69,30 @@ describe("AddOnTemplateSelector", () => {
             sandbox.restore();
         });
 
-        it("should return error if the Add-on kind is not valid.", async () => {
+        it("should return error if the Add-on entrypoint is not valid.", async () => {
             const processExitStub = sandbox.stub(process, "exit");
-            const options = new CLIOptions("test-add-on-kind" as EntrypointType, "test-add-on", templateName, false);
+            const options = new CLIOptions(
+                "test-add-on-entrypoint" as EntrypointType,
+                "test-add-on",
+                templateName,
+                false
+            );
 
-            const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
+            const templateSelector: TemplateSelector = new TemplateSelector(logger, analyticsService);
 
             await templateSelector.setupTemplate(options);
 
             assert.equal(logger.warning.callCount, 2);
             assert.equal(
-                logger.warning.getCall(0).calledWith("Please choose a valid Add-on kind (valid kind: panel)"),
+                logger.warning
+                    .getCall(0)
+                    .calledWith("Please choose a valid Add-on entrypoint (valid entrypoint: panel)"),
                 true
             );
             assert.equal(
-                logger.warning.getCall(1).calledWith(`${PROGRAM_NAME} <add-on-name> --kind <panel>`, { prefix: "  " }),
+                logger.warning
+                    .getCall(1)
+                    .calledWith(`${PROGRAM_NAME} <add-on-name> --entrypoint <panel>`, { prefix: "  " }),
                 true
             );
 
@@ -93,7 +101,7 @@ describe("AddOnTemplateSelector", () => {
 
             assert.equal(logger.information.callCount, 1);
             assert.equal(
-                logger.information.calledWith(`${PROGRAM_NAME} my-add-on --kind panel`, {
+                logger.information.calledWith(`${PROGRAM_NAME} my-add-on --entrypoint panel`, {
                     prefix: "  "
                 }),
                 true
@@ -102,28 +110,37 @@ describe("AddOnTemplateSelector", () => {
             assert.equal(
                 analyticsService.postEvent.calledWith(
                     AnalyticsErrorMarkers.ERROR_INVALID_KIND,
-                    "Invalid Add-on kind specified"
+                    "Invalid Add-on entrypoint specified"
                 ),
                 true
             );
             assert.equal(processExitStub.calledWith(0), true);
         });
 
-        it("should return error if the app kind is not valid.", async () => {
+        it("should return error if the app entrypoint is not valid.", async () => {
             const processExitStub = sandbox.stub(process, "exit");
 
-            const cliOptions = new CLIOptions("test-add-on-kind" as EntrypointType, "test-add-on", templateName, false);
+            const cliOptions = new CLIOptions(
+                "test-add-on-entrypoint" as EntrypointType,
+                "test-add-on",
+                templateName,
+                false
+            );
 
-            const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
+            const templateSelector: TemplateSelector = new TemplateSelector(logger, analyticsService);
             await templateSelector.setupTemplate(cliOptions);
 
             assert.equal(logger.warning.callCount, 2);
             assert.equal(
-                logger.warning.getCall(0).calledWith("Please choose a valid Add-on kind (valid kind: panel)"),
+                logger.warning
+                    .getCall(0)
+                    .calledWith("Please choose a valid Add-on entrypoint (valid entrypoint: panel)"),
                 true
             );
             assert.equal(
-                logger.warning.getCall(1).calledWith(`${PROGRAM_NAME} <add-on-name> --kind <panel>`, { prefix: "  " }),
+                logger.warning
+                    .getCall(1)
+                    .calledWith(`${PROGRAM_NAME} <add-on-name> --entrypoint <panel>`, { prefix: "  " }),
                 true
             );
 
@@ -132,7 +149,7 @@ describe("AddOnTemplateSelector", () => {
 
             assert.equal(logger.information.callCount, 1);
             assert.equal(
-                logger.information.calledWith(`${PROGRAM_NAME} my-add-on --kind panel`, {
+                logger.information.calledWith(`${PROGRAM_NAME} my-add-on --entrypoint panel`, {
                     prefix: "  "
                 }),
                 true
@@ -141,7 +158,7 @@ describe("AddOnTemplateSelector", () => {
             assert.equal(
                 analyticsService.postEvent.calledWith(
                     AnalyticsErrorMarkers.ERROR_INVALID_KIND,
-                    "Invalid Add-on kind specified"
+                    "Invalid Add-on entrypoint specified"
                 ),
                 true
             );
@@ -151,7 +168,7 @@ describe("AddOnTemplateSelector", () => {
         it("should return the passed template name if present in CLIOptions and is a valid one.", async () => {
             const cliOptions = new CLIOptions(EntrypointType.PANEL, "test-app", templateName, false);
 
-            const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
+            const templateSelector: TemplateSelector = new TemplateSelector(logger, analyticsService);
             const template = await templateSelector.setupTemplate(cliOptions);
 
             assert.equal(analyticsService.postEvent.callCount, 0);
@@ -178,7 +195,7 @@ describe("AddOnTemplateSelector", () => {
 
             const cliOptions = new CLIOptions(EntrypointType.PANEL, "test-app", "incorrect-template", false);
 
-            const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
+            const templateSelector: TemplateSelector = new TemplateSelector(logger, analyticsService);
             const template = await templateSelector.setupTemplate(cliOptions);
 
             assert.equal(template, templateChoices[1].value);
@@ -206,7 +223,7 @@ describe("AddOnTemplateSelector", () => {
             });
 
             const cliOptions = new CLIOptions(EntrypointType.PANEL, "test-app", "", false);
-            const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
+            const templateSelector: TemplateSelector = new TemplateSelector(logger, analyticsService);
             const template = await templateSelector.setupTemplate(cliOptions);
 
             assert.equal(logger.warning.callCount, 0);
@@ -234,7 +251,7 @@ describe("AddOnTemplateSelector", () => {
 
             const cliOptions = new CLIOptions(EntrypointType.PANEL, "test-app", "", false);
 
-            const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
+            const templateSelector: TemplateSelector = new TemplateSelector(logger, analyticsService);
             const template = await templateSelector.setupTemplate(cliOptions);
 
             assert.equal(logger.warning.callCount, 0);
@@ -242,14 +259,28 @@ describe("AddOnTemplateSelector", () => {
             assert.equal(analyticsService.postEvent.callCount, 0);
         });
 
-        it("should exit if user doesnt select any prompted value and template is not passed.", async () => {
+        it("should return the custom template if the variant is not available.", async () => {
+            const customTemplate = "custom-template";
+            const promptsStub = sandbox.stub(prompts, "prompt");
+            promptsStub.resolves({ selectedTemplate: customTemplate });
+
+            const cliOptions = new CLIOptions(EntrypointType.PANEL, "test-app", "", false);
+            const templateSelector: TemplateSelector = new TemplateSelector(logger, analyticsService);
+            const template = await templateSelector.setupTemplate(cliOptions);
+
+            assert.equal(template, customTemplate);
+            assert.equal(logger.warning.callCount, 0);
+            assert.equal(analyticsService.postEvent.callCount, 0);
+        });
+
+        it("should exit if user does not select any prompted value and template is not passed.", async () => {
             const promptsStub = sandbox.stub(prompts, "prompt");
             const exitProcessStub = sandbox.stub(process, "exit");
             promptsStub.resolves({ selectedTemplate: undefined });
 
             const cliOptions = new CLIOptions(EntrypointType.PANEL, "test-app", "", false);
 
-            const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
+            const templateSelector: TemplateSelector = new TemplateSelector(logger, analyticsService);
             await templateSelector.setupTemplate(cliOptions);
 
             assert.equal(logger.warning.callCount, 0);
@@ -257,14 +288,14 @@ describe("AddOnTemplateSelector", () => {
             assert.equal(analyticsService.postEvent.callCount, 0);
         });
 
-        it("should exit if user doesnt select any option in document sandbox prompt.", async () => {
+        it("should exit if user does not select any option in document sandbox prompt.", async () => {
             const promptsStub = sandbox.stub(prompts, "prompt");
             const exitProcessStub = sandbox.stub(process, "exit");
             promptsStub.resolves({ selectedTemplate: templateChoices[1].value, includeDocumentSandbox: undefined });
 
             const cliOptions = new CLIOptions(EntrypointType.PANEL, "test-app", "", false);
 
-            const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
+            const templateSelector: TemplateSelector = new TemplateSelector(logger, analyticsService);
             await templateSelector.setupTemplate(cliOptions);
 
             assert.equal(logger.warning.callCount, 0);

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

@@ -0,0 +1,80 @@
+/********************************************************************************
+ * 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 { EntrypointType } from "@adobe/ccweb-add-on-manifest";
+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 { AddOnFactory } from "../../app/AddOnFactory.js";
+import { IContainer, ITypes } from "../../config/index.js";
+import { CLIOptions } from "../../models/CLIOptions.js";
+
+describe("create-ccweb-add-on", () => {
+    let sandbox: sinon.SinonSandbox;
+
+    let container: sinon.SinonStub;
+
+    let addOnFactory: StubbedInstance<AddOnFactory>;
+
+    let analyticsConsent: StubbedInstance<AnalyticsConsent>;
+    let analyticsService: StubbedInstance<AnalyticsService>;
+
+    beforeEach(() => {
+        sandbox = sinon.createSandbox();
+
+        addOnFactory = stubInterface();
+        addOnFactory.create.resolves();
+
+        analyticsConsent = stubInterface();
+        analyticsService = stubInterface();
+
+        container = sandbox.stub(IContainer, "get");
+        container.withArgs(ITypes.AddOnFactory).returns(addOnFactory);
+
+        container.withArgs(IAnalyticsTypes.AnalyticsConsent).returns(analyticsConsent);
+        container.withArgs(IAnalyticsTypes.AnalyticsService).returns(analyticsService);
+    });
+
+    afterEach(() => {
+        sandbox.restore();
+    });
+
+    describe("create", () => {
+        it("should execute succesfully when correct parameters are passed.", async () => {
+            analyticsConsent.set.resolves();
+
+            await runCommand(["hello-world", "--entrypoint=panel", "--template=react-javascript"], {
+                root: "."
+            });
+
+            const options = new CLIOptions(EntrypointType.PANEL, "hello-world", "react-javascript", false);
+            assert.equal(addOnFactory.create.calledOnceWith(options), true);
+        });
+    });
+});

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

@@ -25,6 +25,7 @@
 import type { AnalyticsConsent, AnalyticsService } from "@adobe/ccweb-add-on-analytics";
 import { ITypes as IAnalyticsTypes } from "@adobe/ccweb-add-on-analytics";
 import { EntrypointType } from "@adobe/ccweb-add-on-manifest";
+import { PROGRAM_NAME } from "@adobe/ccweb-add-on-scaffolder";
 import { Config } from "@oclif/core";
 import chai, { assert, expect } from "chai";
 import chaiAsPromised from "chai-as-promised";
@@ -33,14 +34,14 @@ import sinon from "sinon";
 import type { StubbedInstance } from "ts-sinon";
 import { stubInterface } from "ts-sinon";
 import { AnalyticsErrorMarkers } from "../../AnalyticsMarkers.js";
-import type { AddOnFactory } from "../../app/index.js";
-import { CreateCCWebAddOn } from "../../commands/create.js";
+import type { AddOnFactory } from "../../app/AddOnFactory.js";
+import { Create } from "../../commands/create.js";
 import { IContainer, ITypes } from "../../config/index.js";
-import { CLIOptions } from "../../models/index.js";
+import { CLIOptions } from "../../models/CLIOptions.js";
 
 chai.use(chaiAsPromised);
 
-describe("CreateCCWebAddOn", () => {
+describe("Create", () => {
     let sandbox: sinon.SinonSandbox;
 
     let container: sinon.SinonStub;
@@ -52,6 +53,7 @@ describe("CreateCCWebAddOn", () => {
 
     beforeEach(() => {
         sandbox = sinon.createSandbox();
+        sandbox.stub(console, "log");
 
         addOnFactory = stubInterface();
         addOnFactory.create.resolves();
@@ -74,12 +76,24 @@ describe("CreateCCWebAddOn", () => {
         it("should execute succesfully when correct parameters are passed without analytics.", async () => {
             analyticsConsent.get.resolves(true);
 
-            const createCCWebAddOn = new CreateCCWebAddOn(
-                ["hello-world", "--kind=panel", "--template=react-javascript", "--verbose"],
-                new Config({ root: "." })
+            const create = new Create(
+                ["hello-world", "--entrypoint=panel", "--template=react-javascript", "--verbose"],
+                new Config({ name: PROGRAM_NAME, version: "1.0.0", root: "." })
             );
-
-            await createCCWebAddOn.run();
+            sandbox
+                // @ts-ignore - Sidestep `this.parse()` error when calling `run()` directly.
+                .stub(create, "parse")
+                .resolves({
+                    args: { name: "hello-world" },
+                    flags: {
+                        entrypoint: EntrypointType.PANEL,
+                        template: "react-javascript",
+                        analytics: undefined,
+                        verbose: true
+                    }
+                });
+
+            await create.run();
 
             assert.equal(analyticsConsent.get.callCount, 1);
 
@@ -91,12 +105,24 @@ describe("CreateCCWebAddOn", () => {
             analyticsConsent.get.resolves(true);
             analyticsConsent.set.withArgs(false).resolves();
 
-            const createCCWebAddOn = new CreateCCWebAddOn(
-                ["hello-world", "--kind=panel", "--template=react-javascript", "--analytics=off", "--verbose"],
-                new Config({ root: "." })
+            const create = new Create(
+                ["hello-world", "--entrypoint=panel", "--template=react-javascript", "--analytics=off", "--verbose"],
+                new Config({ name: PROGRAM_NAME, version: "1.0.0", root: "." })
             );
-
-            await createCCWebAddOn.run();
+            sandbox
+                // @ts-ignore - Sidestep `this.parse()` error when calling `run()` directly.
+                .stub(create, "parse")
+                .resolves({
+                    args: { name: "hello-world" },
+                    flags: {
+                        entrypoint: EntrypointType.PANEL,
+                        template: "react-javascript",
+                        analytics: "off",
+                        verbose: true
+                    }
+                });
+
+            await create.run();
 
             assert.equal(analyticsConsent.set.calledOnceWith(false), true);
 
@@ -106,11 +132,11 @@ describe("CreateCCWebAddOn", () => {
     });
 
     describe("catch", () => {
-        it("should fail when incorrect parameters are passed.", async () => {
-            const createCCWebAddOn = new CreateCCWebAddOn(["--incorrect-flag"], new Config({ root: "." }));
+        it("should fail for any errors in command execution.", async () => {
+            const create = new Create([], new Config({ name: PROGRAM_NAME, version: "1.0.0", root: "." }));
 
-            const error = new Error("Nonexistent flag: --incorrect-flag\nSee more help with --help");
-            await expect(createCCWebAddOn.catch(error)).to.be.rejectedWith();
+            const error = new Error("Something went wrong.");
+            await expect(create.catch(error)).to.be.rejectedWith(error);
 
             assert.equal(
                 analyticsService.postEvent.calledOnceWith(

package/src/test/models/CLIOptions.spec.ts

@@ -25,19 +25,19 @@
 import { EntrypointType } from "@adobe/ccweb-add-on-manifest";
 import { assert } from "chai";
 import "mocha";
-import { CLIOptions } from "../../models/index.js";
+import { CLIOptions } from "../../models/CLIOptions.js";
 
 describe("CLIOptions", () => {
     describe("constructor", () => {
         it("should create a new instance of CLIOptions.", () => {
-            const addOnKind = EntrypointType.PANEL;
+            const entrypointType = EntrypointType.PANEL;
             const addOnName = "test-app";
             const templateName = "javascript";
             const verbose = false;
 
-            const cliOptions = new CLIOptions(addOnKind as EntrypointType, addOnName, templateName, verbose);
+            const cliOptions = new CLIOptions(entrypointType as EntrypointType, addOnName, templateName, verbose);
 
-            assert.equal(cliOptions.addOnKind, addOnKind);
+            assert.equal(cliOptions.entrypointType, entrypointType);
             assert.equal(cliOptions.addOnName, addOnName);
             assert.equal(cliOptions.templateName, templateName);
             assert.equal(cliOptions.verbose, verbose);

package/src/test/validators/{AddOnDirectoryValidator.spec.ts → DirectoryValidator.spec.ts}

@@ -37,10 +37,9 @@ import { stubInterface } from "ts-sinon";
 import { AnalyticsErrorMarkers } from "../../AnalyticsMarkers.js";
 import { PROGRAM_NAME } from "../../constants.js";
 import { CLIOptions } from "../../models/CLIOptions.js";
-import type { DirectoryValidator } from "../../validators/index.js";
-import { AddOnDirectoryValidator } from "../../validators/index.js";
+import { DirectoryValidator } from "../../validators/DirectoryValidator.js";
 
-describe("AddOnDirectoryValidator", () => {
+describe("DirectoryValidator", () => {
     let sandbox: SinonSandbox;
 
     let analyticsService: StubbedInstance<AnalyticsService>;
@@ -54,7 +53,7 @@ describe("AddOnDirectoryValidator", () => {
         analyticsService = stubInterface<AnalyticsService>();
         logger = stubInterface<Logger>();
 
-        validator = new AddOnDirectoryValidator(logger, analyticsService);
+        validator = new DirectoryValidator(logger, analyticsService);
     });
 
     afterEach(() => {
@@ -65,7 +64,7 @@ describe("AddOnDirectoryValidator", () => {
         let runs = [{ addOnName: "" }, { addOnName: " " }];
         runs.forEach(run => {
             it(`should exit for empty addOn name: ${run.addOnName}.`, async () => {
-                const validator: DirectoryValidator = new AddOnDirectoryValidator(logger, analyticsService);
+                const validator: DirectoryValidator = new DirectoryValidator(logger, analyticsService);
                 const processExitStub = sandbox.stub(process, "exit");
 
                 await validator.validateAddOnName(run.addOnName);
@@ -76,7 +75,7 @@ describe("AddOnDirectoryValidator", () => {
                 assert.equal(
                     logger.warning
                         .getCall(1)
-                        .calledWith(`${PROGRAM_NAME} <add-on-name> --kind <panel> --template <javascript>`, {
+                        .calledWith(`${PROGRAM_NAME} <add-on-name> --entrypoint <panel> --template <javascript>`, {
                             prefix: "  "
                         }),
                     true
@@ -92,10 +91,13 @@ describe("AddOnDirectoryValidator", () => {
 
                 assert.equal(logger.information.callCount, 1);
                 assert.equal(
-                    logger.information.calledWith(`${PROGRAM_NAME} my-add-on --kind panel --template javascript`, {
-                        prefix: "  ",
-                        postfix: "\n"
-                    }),
+                    logger.information.calledWith(
+                        `${PROGRAM_NAME} my-add-on --entrypoint panel --template javascript`,
+                        {
+                            prefix: "  ",
+                            postfix: "\n"
+                        }
+                    ),
                     true
                 );
                 assert.equal(analyticsService.postEvent.callCount, 1);
@@ -130,7 +132,7 @@ describe("AddOnDirectoryValidator", () => {
                 assert.equal(
                     logger.warning
                         .getCall(1)
-                        .calledWith(`${PROGRAM_NAME} <add-on-name> --kind <panel> --template <javascript>`, {
+                        .calledWith(`${PROGRAM_NAME} <add-on-name> --entrypoint <panel> --template <javascript>`, {
                             prefix: "  "
                         }),
                     true
@@ -146,10 +148,13 @@ describe("AddOnDirectoryValidator", () => {
 
                 assert.equal(logger.information.callCount, 1);
                 assert.equal(
-                    logger.information.calledWith(`${PROGRAM_NAME} my-add-on --kind panel --template javascript`, {
-                        prefix: "  ",
-                        postfix: "\n"
-                    }),
+                    logger.information.calledWith(
+                        `${PROGRAM_NAME} my-add-on --entrypoint panel --template javascript`,
+                        {
+                            prefix: "  ",
+                            postfix: "\n"
+                        }
+                    ),
                     true
                 );
                 assert.equal(analyticsService.postEvent.callCount, 1);
@@ -191,7 +196,7 @@ describe("AddOnDirectoryValidator", () => {
                 assert.equal(
                     logger.warning
                         .getCall(1)
-                        .calledWith(`${PROGRAM_NAME} <add-on-name> --kind <panel> --template <javascript>`, {
+                        .calledWith(`${PROGRAM_NAME} <add-on-name> --entrypoint <panel> --template <javascript>`, {
                             prefix: "  "
                         }),
                     true
@@ -207,10 +212,13 @@ describe("AddOnDirectoryValidator", () => {
 
                 assert.equal(logger.information.callCount, 1);
                 assert.equal(
-                    logger.information.calledWith(`${PROGRAM_NAME} my-add-on --kind panel --template javascript`, {
-                        prefix: "  ",
-                        postfix: "\n"
-                    }),
+                    logger.information.calledWith(
+                        `${PROGRAM_NAME} my-add-on --entrypoint panel --template javascript`,
+                        {
+                            prefix: "  ",
+                            postfix: "\n"
+                        }
+                    ),
                     true
                 );
                 assert.equal(analyticsService.postEvent.callCount, 1);
@@ -230,7 +238,7 @@ describe("AddOnDirectoryValidator", () => {
 
             analyticsService.postEvent.resolves();
 
-            const validator: DirectoryValidator = new AddOnDirectoryValidator(logger, analyticsService);
+            const validator: DirectoryValidator = new DirectoryValidator(logger, analyticsService);
 
             const cliOptions = new CLIOptions(EntrypointType.PANEL, "test-add-on", "javascript", false);
             await validator.validateAddOnName(cliOptions.addOnName);

package/src/test/validators/{NodeEnvironmentValidator.spec.ts → EnvironmentValidator.spec.ts}

@@ -33,10 +33,9 @@ import type { StubbedInstance } from "ts-sinon";
 import { stubInterface } from "ts-sinon";
 import { AnalyticsErrorMarkers } from "../../AnalyticsMarkers.js";
 import { PROGRAM_NAME } from "../../constants.js";
-import type { EnvironmentValidator } from "../../validators/index.js";
-import { NodeEnvironmentValidator } from "../../validators/index.js";
+import { EnvironmentValidator } from "../../validators/EnvironmentValidator.js";
 
-describe("NodeEnvironmentValidator", () => {
+describe("EnvironmentValidator", () => {
     let sandbox: SinonSandbox;
 
     let cliProcess: StubbedInstance<Process>;
@@ -55,7 +54,7 @@ describe("NodeEnvironmentValidator", () => {
 
         logger = stubInterface();
 
-        validator = new NodeEnvironmentValidator(cliProcess, logger, analyticsService);
+        validator = new EnvironmentValidator(cliProcess, logger, analyticsService);
     });
 
     afterEach(() => {
@@ -63,14 +62,10 @@ describe("NodeEnvironmentValidator", () => {
     });
 
     describe("validateNodeVersion", () => {
-        const runs = [{ version: "10.0.0" }, { version: "15.9.9" }];
+        const runs = [{ version: "10.0.0" }, { version: "17.9.9" }];
         runs.forEach(({ version }) => {
             it(`should exit for lower node version: ${version}.`, async () => {
-                const validator: EnvironmentValidator = new NodeEnvironmentValidator(
-                    cliProcess,
-                    logger,
-                    analyticsService
-                );
+                const validator: EnvironmentValidator = new EnvironmentValidator(cliProcess, logger, analyticsService);
                 const processExitStub = sandbox.stub(process, "exit");
 
                 cliProcess.executeSync
@@ -84,7 +79,7 @@ describe("NodeEnvironmentValidator", () => {
 
                 assert.equal(logger.information.callCount, 2);
                 assert.equal(
-                    logger.information.getCall(0).calledWith(`${PROGRAM_NAME} requires node 16.0.0 or higher.`),
+                    logger.information.getCall(0).calledWith(`${PROGRAM_NAME} requires node 18.0.0 or higher.`),
                     true
                 );
                 assert.equal(logger.information.getCall(1).calledWith("Please update your version of node."), true);
@@ -116,11 +111,7 @@ describe("NodeEnvironmentValidator", () => {
         const dataList = [{ data: undefined }, { data: "" }];
         dataList.forEach(({ data }) => {
             it("should exit for no npm version.", async () => {
-                const validator: EnvironmentValidator = new NodeEnvironmentValidator(
-                    cliProcess,
-                    logger,
-                    analyticsService
-                );
+                const validator: EnvironmentValidator = new EnvironmentValidator(cliProcess, logger, analyticsService);
                 const processExitStub = sandbox.stub(process, "exit");
 
                 cliProcess.executeSync
@@ -134,7 +125,7 @@ describe("NodeEnvironmentValidator", () => {
 
                 assert.equal(logger.information.callCount, 2);
                 assert.equal(
-                    logger.information.getCall(0).calledWith(`${PROGRAM_NAME} requires npm 8.0.0 or higher.`),
+                    logger.information.getCall(0).calledWith(`${PROGRAM_NAME} requires npm 10.0.0 or higher.`),
                     true
                 );
                 assert.equal(logger.information.getCall(1).calledWith("Please install npm."), true);
@@ -147,14 +138,10 @@ describe("NodeEnvironmentValidator", () => {
             });
         });
 
-        const runs = [{ version: "3.0.0" }, { version: "7.9.9" }];
+        const runs = [{ version: "3.0.0" }, { version: "9.9.9" }];
         runs.forEach(run => {
             it(`should exit for lower npm version: ${run.version}.`, async () => {
-                const validator: EnvironmentValidator = new NodeEnvironmentValidator(
-                    cliProcess,
-                    logger,
-                    analyticsService
-                );
+                const validator: EnvironmentValidator = new EnvironmentValidator(cliProcess, logger, analyticsService);
                 const processExitStub = sandbox.stub(process, "exit");
 
                 cliProcess.executeSync
@@ -168,7 +155,7 @@ describe("NodeEnvironmentValidator", () => {
 
                 assert.equal(logger.information.callCount, 2);
                 assert.equal(
-                    logger.information.getCall(0).calledWith(`${PROGRAM_NAME} requires npm 8.0.0 or higher.`),
+                    logger.information.getCall(0).calledWith(`${PROGRAM_NAME} requires npm 10.0.0 or higher.`),
                     true
                 );
                 assert.equal(logger.information.getCall(1).calledWith("Please update your version of npm."), true);