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

package/src/app/TemplateSelector.ts

@@ -22,17 +22,169 @@
  * SOFTWARE.
  ********************************************************************************/
 
+import type { AnalyticsService } from "@adobe/ccweb-add-on-analytics";
+import { ITypes as IAnalyticsTypes } from "@adobe/ccweb-add-on-analytics";
+import type { Logger } from "@adobe/ccweb-add-on-core";
+import { ITypes as ICoreTypes, isNullOrWhiteSpace } from "@adobe/ccweb-add-on-core";
+import { EntrypointType } from "@adobe/ccweb-add-on-manifest";
+import chalk from "chalk";
+import { inject, injectable } from "inversify";
+import prompts from "prompts";
+import "reflect-metadata";
+import format from "string-template";
+import { AnalyticsErrorMarkers } from "../AnalyticsMarkers.js";
+import { ADD_ON_TEMPLATES, AVAILABLE_ADD_ON_TEMPLATES, PROGRAM_NAME, WITH_DOCUMENT_SANDBOX } from "../constants.js";
 import type { CLIOptions } from "../models/CLIOptions.js";
 
-/**
- * Template Selector interface.
- */
-export interface TemplateSelector {
+@injectable()
+export class TemplateSelector {
+    private readonly _logger: Logger;
+    private readonly _analyticsService: AnalyticsService;
+
+    /**
+     * Instantiate {@link TemplateSelector}.
+     * @param logger - {@link Logger} reference.
+     * @param analyticsService - {@link AnalyticsService} reference.
+     * @returns Reference to a new {@link TemplateSelector} instance.
+     */
+    constructor(
+        @inject(ICoreTypes.Logger) logger: Logger,
+        @inject(IAnalyticsTypes.AnalyticsService) analyticsService: AnalyticsService
+    ) {
+        this._logger = logger;
+        this._analyticsService = analyticsService;
+    }
+
     /**
      * Sets up a template, as selected/provided by the user
      * for scaffolding the add-on project.
      * @param options - {@link CLIOptions}.
      * @returns User selected/provided template name.
      */
-    setupTemplate(options: CLIOptions): Promise<string>;
+    async setupTemplate(options: CLIOptions): Promise<string> {
+        await this._validateAddOnEntrypoint(options.entrypointType);
+
+        if (!isNullOrWhiteSpace(options.templateName)) {
+            if (AVAILABLE_ADD_ON_TEMPLATES.includes(options.templateName)) {
+                return options.templateName;
+            } else {
+                this._logger.warning(LOGS.chooseValidTemplate, { prefix: LOGS.newLine });
+            }
+        }
+
+        // Add a line break for better log readability.
+        console.log();
+
+        const templateChoices = [];
+        for (const [templateName, description] of ADD_ON_TEMPLATES.entries()) {
+            templateChoices.push({
+                title: this._promptMessageOption(templateName, description),
+                value: templateName
+            });
+        }
+
+        const templateResponse = await prompts.prompt({
+            type: "select",
+            name: "selectedTemplate",
+            message: this._promptMessage(LOGS.setupTemplate),
+            choices: templateChoices,
+            initial: 0
+        });
+
+        if (!templateResponse || !templateResponse.selectedTemplate) {
+            console.log();
+            return process.exit(0);
+        }
+
+        if (!AVAILABLE_ADD_ON_TEMPLATES.includes(`${templateResponse.selectedTemplate}-${WITH_DOCUMENT_SANDBOX}`)) {
+            return templateResponse.selectedTemplate;
+        }
+
+        const documentSandboxChoices = [
+            {
+                title: this._promptMessageOption(LOGS.no),
+                value: false
+            },
+            {
+                title: this._promptMessageOption(LOGS.yes),
+                value: true
+            }
+        ];
+        const documentSandboxResponse = await prompts.prompt({
+            type: "select",
+            name: "includeDocumentSandbox",
+            message: this._promptMessage(LOGS.includeDocumentSandbox),
+            choices: documentSandboxChoices,
+            initial: 0
+        });
+
+        if (!documentSandboxResponse || documentSandboxResponse.includeDocumentSandbox === undefined) {
+            console.log();
+            return process.exit(0);
+        }
+
+        // Append `with-document-sandbox` to the template name if user wants to include document sandbox
+        return documentSandboxResponse.includeDocumentSandbox
+            ? `${templateResponse.selectedTemplate}-${WITH_DOCUMENT_SANDBOX}`
+            : templateResponse.selectedTemplate;
+    }
+
+    private _promptMessage(message: string): string {
+        return chalk.cyan(message);
+    }
+
+    private _promptMessageOption(option: string, description?: string): string {
+        if (description) {
+            return `${chalk.hex("#E59400").bold(`[${option}]:`)} ${chalk.green(description)}`;
+        }
+        return chalk.green.bold(option);
+    }
+
+    /**
+     * Validate whether entrypointType is valid or not.
+     * @param entrypointType - Add-on entrypoint. For example: panel.
+     */
+    private async _validateAddOnEntrypoint(entrypointType: EntrypointType): Promise<void> {
+        if (entrypointType !== EntrypointType.PANEL) {
+            this._logger.warning(LOGS.chooseValidEntrypointType);
+            this._logger.warning(
+                format(LOGS.executeProgramWithValidEntrypointType, {
+                    PROGRAM_NAME
+                }),
+                {
+                    prefix: LOGS.tab
+                }
+            );
+            this._logger.message(LOGS.forExample, { prefix: LOGS.newLine });
+            this._logger.information(
+                format(LOGS.executeProgramWithValidEntrypointTypeExample, {
+                    PROGRAM_NAME
+                }),
+                {
+                    prefix: LOGS.tab
+                }
+            );
+
+            await this._analyticsService.postEvent(
+                AnalyticsErrorMarkers.ERROR_INVALID_KIND,
+                LOGS.analyticsInvalidEntrypointType,
+                false
+            );
+            return process.exit(0);
+        }
+    }
 }
+const LOGS = {
+    newLine: "\n",
+    tab: "  ",
+    setupTemplate: "Please select a template which you want to scaffold the Add-on project with",
+    chooseValidEntrypointType: "Please choose a valid Add-on entrypoint (valid entrypoint: panel)",
+    executeProgramWithValidEntrypointType: "{PROGRAM_NAME} <add-on-name> --entrypoint <panel>",
+    executeProgramWithValidEntrypointTypeExample: "{PROGRAM_NAME} my-add-on --entrypoint panel",
+    chooseValidTemplate: "You have chosen an invalid template.",
+    forExample: "For example:",
+    analyticsInvalidEntrypointType: "Invalid Add-on entrypoint specified",
+    includeDocumentSandbox: "Do you want to include document sandbox runtime?",
+    yes: "Yes",
+    no: "No"
+};

package/src/app/index.ts

@@ -23,7 +23,5 @@
  ********************************************************************************/
 
 export * from "./AddOnFactory.js";
-export * from "./AddOnPackageManager.js";
-export * from "./AddOnTemplateSelector.js";
+export * from "./PackageManager.js";
 export * from "./TemplateSelector.js";
-export * from "./WxpAddOnFactory.js";

package/src/commands/create.ts

@@ -27,7 +27,7 @@ import { UncaughtExceptionHandler } from "@adobe/ccweb-add-on-core";
 import { EntrypointType } from "@adobe/ccweb-add-on-manifest";
 import type { Config } from "@oclif/core";
 import { Args, Flags } from "@oclif/core";
-import { Arg, CustomOptions, OptionFlag } from "@oclif/core/lib/interfaces/parser.js";
+import type { Arg, CustomOptions, OptionFlag } from "@oclif/core/lib/interfaces/parser.js";
 import "reflect-metadata";
 import { AnalyticsErrorMarkers } from "../AnalyticsMarkers.js";
 import type { AddOnFactory } from "../app/AddOnFactory.js";

package/src/config/inversify.config.ts

@@ -23,22 +23,23 @@
  ********************************************************************************/
 
 import { IContainer as ICoreContainer } from "@adobe/ccweb-add-on-core";
+import type { Container } from "inversify";
 import "reflect-metadata";
-import type { AddOnFactory, TemplateSelector } from "../app/index.js";
-import { AddOnTemplateSelector, WxpAddOnFactory } from "../app/index.js";
-import type { DirectoryValidator, EnvironmentValidator } from "../validators/index.js";
-import { AddOnDirectoryValidator, NodeEnvironmentValidator } from "../validators/index.js";
+import { AddOnFactory } from "../app/AddOnFactory.js";
+import { TemplateSelector } from "../app/TemplateSelector.js";
+import { DirectoryValidator } from "../validators/DirectoryValidator.js";
+import { EnvironmentValidator } from "../validators/EnvironmentValidator.js";
+
 import { ITypes } from "./inversify.types.js";
-import { Container } from "inversify";
 
 const container: Container = ICoreContainer;
 
-container.bind<AddOnFactory>(ITypes.AddOnFactory).to(WxpAddOnFactory).inSingletonScope();
+container.bind<AddOnFactory>(ITypes.AddOnFactory).to(AddOnFactory).inSingletonScope();
 
-container.bind<DirectoryValidator>(ITypes.DirectoryValidator).to(AddOnDirectoryValidator).inSingletonScope();
+container.bind<DirectoryValidator>(ITypes.DirectoryValidator).to(DirectoryValidator).inSingletonScope();
 
-container.bind<EnvironmentValidator>(ITypes.EnvironmentValidator).to(NodeEnvironmentValidator).inSingletonScope();
+container.bind<EnvironmentValidator>(ITypes.EnvironmentValidator).to(EnvironmentValidator).inSingletonScope();
 
-container.bind<TemplateSelector>(ITypes.TemplateSelector).to(AddOnTemplateSelector).inSingletonScope();
+container.bind<TemplateSelector>(ITypes.TemplateSelector).to(TemplateSelector).inSingletonScope();
 
 export { container as IContainer };

package/src/test/app/{WxpAddOnFactory.spec.ts → AddOnFactory.spec.ts}

@@ -38,12 +38,13 @@ import type { StubbedInstance } from "ts-sinon";
 import { stubInterface } from "ts-sinon";
 import url from "url";
 import { AnalyticsErrorMarkers, AnalyticsSuccessMarkers } from "../../AnalyticsMarkers.js";
-import type { AddOnFactory, TemplateSelector } from "../../app/index.js";
-import { WxpAddOnFactory } from "../../app/index.js";
-import { CLIOptions } from "../../models/index.js";
-import type { DirectoryValidator, EnvironmentValidator } from "../../validators/index.js";
+import { AddOnFactory } from "../../app/AddOnFactory.js";
+import type { TemplateSelector } from "../../app/TemplateSelector.js";
+import { CLIOptions } from "../../models/CLIOptions.js";
+import type { DirectoryValidator } from "../../validators/DirectoryValidator.js";
+import type { EnvironmentValidator } from "../../validators/EnvironmentValidator.js";
 
-describe("WxpAddOnFactory", () => {
+describe("AddOnFactory", () => {
     let sandbox: SinonSandbox;
 
     let directoryValidator: StubbedInstance<DirectoryValidator>;
@@ -74,7 +75,7 @@ describe("WxpAddOnFactory", () => {
         analyticsService = stubInterface();
         analyticsService.postEvent.resolves();
 
-        addOnFactory = new WxpAddOnFactory(
+        addOnFactory = new AddOnFactory(
             directoryValidator,
             environmentValidator,
             templateSelector,

package/src/test/app/{AddOnPackageManager.spec.ts → PackageManager.spec.ts}

@@ -26,17 +26,14 @@ import { PackageJson } from "@adobe/ccweb-add-on-core";
 import { EntrypointType } from "@adobe/ccweb-add-on-manifest";
 import { assert } from "chai";
 import "mocha";
-import { AddOnPackageManager } from "../../app/index.js";
+import { PackageManager } from "../../app/PackageManager.js";
 
-describe("AddOnManager", () => {
+describe("PackageManager", () => {
     describe("getPackageJson", () => {
         const runs = [{ entrypointType: EntrypointType.PANEL, addOnName: "test-app" }];
         runs.forEach(run => {
             it("should return package.json.", async () => {
-                const packageJson = AddOnPackageManager.getPackageJson(
-                    run.entrypointType as EntrypointType,
-                    run.addOnName
-                );
+                const packageJson = PackageManager.getPackageJson(run.entrypointType as EntrypointType, run.addOnName);
                 const expectedPackageJson = new PackageJson({
                     name: run.addOnName,
                     version: "1.0.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>;
@@ -79,7 +78,7 @@ describe("AddOnTemplateSelector", () => {
                 false
             );
 
-            const templateSelector: TemplateSelector = new AddOnTemplateSelector(logger, analyticsService);
+            const templateSelector: TemplateSelector = new TemplateSelector(logger, analyticsService);
 
             await templateSelector.setupTemplate(options);
 
@@ -128,7 +127,7 @@ describe("AddOnTemplateSelector", () => {
                 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);
@@ -169,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);
@@ -196,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);
@@ -224,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);
@@ -252,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);
@@ -260,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);
@@ -275,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

@@ -31,7 +31,7 @@ import "mocha";
 import sinon from "sinon";
 import type { StubbedInstance } from "ts-sinon";
 import { stubInterface } from "ts-sinon";
-import { AddOnFactory } from "../../app/AddOnFactory.js";
+import type { AddOnFactory } from "../../app/AddOnFactory.js";
 import { IContainer, ITypes } from "../../config/index.js";
 import { CLIOptions } from "../../models/CLIOptions.js";
 

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

@@ -34,10 +34,10 @@ 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 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);
 

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

@@ -25,7 +25,7 @@
 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", () => {

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);
@@ -239,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(() => {
@@ -66,11 +65,7 @@ describe("NodeEnvironmentValidator", () => {
         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
@@ -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
@@ -150,11 +141,7 @@ describe("NodeEnvironmentValidator", () => {
         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