dceky 1.2.1-beta-setup-node-events.1 → 1.2.3

package/start/index.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-console */
 /**
- * Checks arguments and environment variables (for PROFILE, BROWSER, and HEADLESS),
- * asks user for missing selections, and launches Cypress
+ * Checks environment variables (for PROFILE, BROWSER, and HEADLESS),
+ * asks the user for missing selections, and launches Cypress
  * @author Gardenia Liu
  * @author Yuen Ler Chow
  */
@@ -9,14 +9,17 @@
 // Import libs
 import fs from 'fs';
 import path from 'path';
+import dotenv from 'dotenv';
+import clear from 'clear';
 
 // Import helpers
 import showChooser from './helpers/showChooser';
 import parseCommaSeparated from './helpers/parseCommaSeparated';
 import findProfilesByNames from './helpers/findProfilesByNames';
 import validateBrowsers from './helpers/validateBrowsers';
-import extractArgValue from './helpers/extractArgValue';
 import getRootPath from './helpers/getRootPath';
+import prompt from './helpers/prompt';
+import print from './helpers/print';
 import executeCypress from './helpers/executeCypress';
 import getCypressDetectedBrowsersForChooser from './helpers/getCypressDetectedBrowsersForChooser';
 import getE2ETestFoldersForChooser from './helpers/getE2ETestFoldersForChooser';
@@ -30,6 +33,9 @@ import ALL_E2E_TESTS_SPEC_PATTERN from './constants/ALL_E2E_TESTS_SPEC_PATTERN';
 // Get the project directory
 const pwd = getRootPath();
 
+// Load .env vars before reading startup configuration
+dotenv.config({ path: path.join(pwd, '.env') });
+
 // Find available profiles under /cypress/profiles
 const profilesDir = path.join(pwd, 'cypress/profiles');
 if (!fs.existsSync(profilesDir)) {
@@ -58,232 +64,263 @@ if (profiles.length === 0) {
   process.exit(1);
 }
 
-// Parse CLI arguments
-const args = process.argv.slice(2);
-
-// Get selections from environment variables or CLI arguments
+// Get selections from environment variables
 let selectedProfiles: { file: string; profileName: string }[] = [];
 let selectedBrowsers: string[] = [];
 let isHeadless = false;
 let selectedE2ETestFolder = ALL_E2E_TESTS_LABEL;
 let selectedE2ESpecPattern = ALL_E2E_TESTS_SPEC_PATTERN;
 
-// Check for PROFILE (env var or CLI arg)
-const envProfileRaw = process.env.PROFILE;
-const argProfileRaw = extractArgValue(args, '--profile');
-const profileRaw = envProfileRaw || argProfileRaw;
+// Check for PROFILE
+const profileRaw = process.env.PROFILE;
 
 if (profileRaw) {
   const profileNames = parseCommaSeparated(profileRaw);
   selectedProfiles = findProfilesByNames(profileNames, profiles);
 }
 
-// Check for BROWSER (env var or CLI arg)
-const envBrowserRaw = process.env.BROWSER;
-const argBrowserRaw = extractArgValue(args, '--browser');
-const browserRaw = envBrowserRaw || argBrowserRaw;
+// Check for BROWSER
+const browserRaw = process.env.BROWSER;
 
 if (browserRaw) {
   const browserNames = parseCommaSeparated(browserRaw);
   selectedBrowsers = validateBrowsers(browserNames);
 }
 
-// Check for E2E_TEST_FOLDER (env var or CLI arg)
-const envE2ETestFolderRaw = process.env.E2E_TEST_FOLDER;
-const argE2ETestFolderRaw = extractArgValue(args, '--e2eFolder');
-const e2eTestFolderRaw = envE2ETestFolderRaw || argE2ETestFolderRaw;
+// Check for E2E_TEST_FOLDER
+const e2eTestFolderRaw = process.env.E2E_TEST_FOLDER;
 
-// Check for HEADLESS (env var or CLI flag)
+// Check for HEADLESS
 const envHeadlessRaw = process.env.HEADLESS;
-const headlessFlagValue = extractArgValue(args, '--headless');
-const hasHeadlessFlag = headlessFlagValue !== undefined;
-isHeadless = !!(envHeadlessRaw && envHeadlessRaw.toLowerCase() !== 'false') || hasHeadlessFlag;
-
-// Check for THREADS_PER_COMBO (env var or CLI arg)
-const envThreadsRaw = process.env.THREADS_PER_COMBO;
-const argThreadsRaw = extractArgValue(args, '--threadsPerCombo');
-const threadsRaw = envThreadsRaw || argThreadsRaw;
+isHeadless = !!(envHeadlessRaw && envHeadlessRaw.toLowerCase() !== 'false');
+
+// Check for THREADS_PER_COMBO
+const threadsRaw = process.env.THREADS_PER_COMBO;
 let threadsPerCombo = DEFAULT_THREADS_PER_COMBO;
-if (threadsRaw) {
-  const parsed = Number.parseInt(threadsRaw, 10);
-  if (!Number.isNaN(parsed) && parsed > 0) {
-    threadsPerCombo = parsed;
-  } else {
-    console.warn(`⚠️ Invalid THREADS_PER_COMBO value: "${threadsRaw}". Using default (${DEFAULT_THREADS_PER_COMBO}).`);
-  }
-}
 
+const start = async (): Promise<void> => {
 // If headless wasn't specified, ask the user to choose
-if (!envHeadlessRaw && !hasHeadlessFlag) {
-  const choices = showChooser({
-    question: 'Run in headless mode?',
-    options: [
-      { tag: 'Y', description: 'Yes (headless)' },
-      { tag: 'N', description: 'No (interactive)' },
-    ],
-    title: 'Select mode',
-    allowMulti: false,
-  });
-
-  isHeadless = choices[0].tag === 'Y';
-}
-
-// If running headless, optionally narrow tests to one e2e folder
-if (isHeadless) {
-  const choosableE2ETestFolders = getE2ETestFoldersForChooser();
-
-  if (e2eTestFolderRaw) {
-    const e2eSelection = findE2ETestFolderByName(e2eTestFolderRaw, choosableE2ETestFolders);
-    selectedE2ETestFolder = e2eSelection.description;
-    selectedE2ESpecPattern = e2eSelection.specPattern;
-  } else if (choosableE2ETestFolders.length > 0) {
+  if (!envHeadlessRaw) {
     const choices = showChooser({
-      question: 'Choose e2e test folder:',
+      question: 'Run in headless mode?',
       options: [
-        {
-          tag: 'A',
-          description: ALL_E2E_TESTS_LABEL,
-        },
-        ...choosableE2ETestFolders,
+        { tag: 'Y', description: 'Yes (headless)' },
+        { tag: 'N', description: 'No (interactive)' },
       ],
-      title: 'Select E2E Tests',
+      title: 'Select mode',
       allowMulti: false,
     });
 
-    const allTestsChosen = choices.some((choice) => {
-      return choice.tag === 'A';
-    });
-    if (!allTestsChosen) {
-      const selectedFolder = choosableE2ETestFolders.find((folder) => {
-        return folder.tag === choices[0].tag;
-      });
-      if (selectedFolder) {
-        selectedE2ETestFolder = selectedFolder.relativePath;
-        selectedE2ESpecPattern = selectedFolder.specPattern;
+    isHeadless = choices[0].tag === 'Y';
+  }
+
+  // This takes 5+ seconds to run, so start it now while we wait for the user to answer other questions
+  const cypressDetectedBrowsersPromise = (
+    isHeadless && selectedBrowsers.length === 0
+      ? getCypressDetectedBrowsersForChooser()
+      : null
+  );
+
+  if (isHeadless) {
+    if (threadsRaw) {
+      const trimmedThreads = threadsRaw.trim();
+      const parsed = Number.parseInt(trimmedThreads, 10);
+      if (/^\d+$/.test(trimmedThreads) && parsed > 0) {
+        threadsPerCombo = parsed;
+      } else {
+        console.warn(
+          `⚠️ Invalid THREADS_PER_COMBO value: "${threadsRaw}". `
+        + 'Use a positive whole number. '
+        + `Using default (${DEFAULT_THREADS_PER_COMBO}).`,
+        );
+      }
+    } else {
+      let parsedThreads: number | null = null;
+      clear();
+      print.title('Num Test Files in Parallel Per Combo');
+      console.log('');
+      print.subtitle('How many test files should run in parallel per profile/browser combo? (Press Enter for 1)');
+      while (parsedThreads === null) {
+        const response = prompt('> ', true).trim();
+        if (!response) {
+          parsedThreads = DEFAULT_THREADS_PER_COMBO;
+        } else {
+          const parsed = Number.parseInt(response, 10);
+          parsedThreads = /^\d+$/.test(response) && parsed > 0 ? parsed : null;
+        }
+
+        if (parsedThreads === null) {
+          console.log('Please enter a positive whole number, or press Enter for 1.');
+          console.log('');
+        }
       }
+
+      threadsPerCombo = parsedThreads;
     }
   }
-}
 
-// If running headless and no browsers were selected, ask the user to choose
-if (isHeadless && selectedBrowsers.length === 0) {
-  const choosableBrowsers = getCypressDetectedBrowsersForChooser();
-  if (choosableBrowsers.length === 0) {
-    console.error('No browsers detected. Run `npx cypress info`, install a supported browser, and try again.');
-    process.exit(1);
+  // If running headless, optionally narrow tests to one e2e folder
+  if (isHeadless) {
+    const choosableE2ETestFolders = getE2ETestFoldersForChooser();
+
+    if (e2eTestFolderRaw) {
+      const e2eSelection = findE2ETestFolderByName(e2eTestFolderRaw, choosableE2ETestFolders);
+      selectedE2ETestFolder = e2eSelection.description;
+      selectedE2ESpecPattern = e2eSelection.specPattern;
+    } else if (choosableE2ETestFolders.length > 0) {
+      const choices = showChooser({
+        question: 'Choose e2e test folder:',
+        options: [
+          {
+            tag: 'A',
+            description: ALL_E2E_TESTS_LABEL,
+          },
+          ...choosableE2ETestFolders,
+        ],
+        title: 'Select E2E Tests',
+        allowMulti: false,
+      });
+
+      const allTestsChosen = choices.some((choice) => {
+        return choice.tag === 'A';
+      });
+      if (!allTestsChosen) {
+        const selectedFolder = choosableE2ETestFolders.find((folder) => {
+          return folder.tag === choices[0].tag;
+        });
+        if (selectedFolder) {
+          selectedE2ETestFolder = selectedFolder.relativePath;
+          selectedE2ESpecPattern = selectedFolder.specPattern;
+        }
+      }
+    }
   }
-  const options = choosableBrowsers.map(({ tag, name }) => {
-    return {
-      tag,
-      description: name,
-    };
-  });
 
-  // Add "All" option if there are multiple browsers
-  if (choosableBrowsers.length > 1) {
-    options.unshift({
-      tag: 'A',
-      description: 'All browsers',
+  // If running headless and no browsers were selected, ask the user to choose
+  if (isHeadless && selectedBrowsers.length === 0) {
+    const choosableBrowsers = await cypressDetectedBrowsersPromise;
+    if (choosableBrowsers.length === 0) {
+      console.error('No browsers detected. Run `npx cypress info`, install a supported browser, and try again.');
+      process.exit(1);
+    }
+    const options = choosableBrowsers.map(({ tag, name }) => {
+      return {
+        tag,
+        description: name,
+      };
     });
-  }
 
-  const choices = showChooser({
-    question: 'Choose browser(s) (commas for multiple: C,F)',
-    options,
-    title: 'Select Browser(s)',
-    allowMulti: true,
-  });
+    // Add "All" option if there are multiple browsers
+    if (choosableBrowsers.length > 1) {
+      options.unshift({
+        tag: 'A',
+        description: 'All browsers',
+      });
+    }
 
-  const allBrowsersChosen = choices.some((choice) => {
-    return choice.tag === 'A';
-  });
-  if (allBrowsersChosen) {
-    selectedBrowsers = choosableBrowsers.map((b) => {
-      return b.name;
+    const choices = showChooser({
+      question: 'Choose browser(s) (commas for multiple: C,F)',
+      options,
+      title: 'Select Browser(s)',
+      allowMulti: true,
+    });
+
+    const allBrowsersChosen = choices.some((choice) => {
+      return choice.tag === 'A';
     });
-  } else {
-    selectedBrowsers = (
-      choices
-        .map((choice) => {
-          const selectedBrowser = choosableBrowsers.find((browser) => {
-            return browser.tag.toLowerCase() === choice.tag.toLowerCase();
-          });
-          return selectedBrowser?.name ?? null;
-        })
-        .filter((name) => {
-          return name !== null;
-        })
-    );
+    if (allBrowsersChosen) {
+      selectedBrowsers = choosableBrowsers.map((b) => {
+        return b.name;
+      });
+    } else {
+      selectedBrowsers = (
+        choices
+          .map((choice) => {
+            const selectedBrowser = choosableBrowsers.find((browser) => {
+              return browser.tag.toLowerCase() === choice.tag.toLowerCase();
+            });
+            return selectedBrowser?.name ?? null;
+          })
+          .filter((name) => {
+            return name !== null;
+          })
+      );
+    }
   }
-}
 
-// If no profiles were selected, ask the user to choose
-// - In headless mode, allow selecting multiple profiles
-// - In visible mode, only allow selecting a single profile
-// In the case where their environment selected more than one profile, but they are not headless, make them re-choose
-if (
-  selectedProfiles.length === 0
+  // If no profiles were selected, ask the user to choose
+  // - In headless mode, allow selecting multiple profiles
+  // - In visible mode, only allow selecting a single profile
+  // In the case where their environment selected more than one profile, but they are not headless, make them re-choose
+  if (
+    selectedProfiles.length === 0
   || (!isHeadless && selectedProfiles.length > 1)
-) {
+  ) {
   // Filter out "Default" profile from the chooser options
-  const choosableProfiles = profiles.filter((p) => {
-    return p.profileName.toLowerCase() !== 'default';
-  });
+    const choosableProfiles = profiles.filter((p) => {
+      return p.profileName.toLowerCase() !== 'default';
+    });
 
-  const options = choosableProfiles.map((p, idx) => {
-    return {
-      tag: String(idx + 1),
-      description: p.profileName,
-    };
-  });
+    const options = choosableProfiles.map((p, idx) => {
+      return {
+        tag: String(idx + 1),
+        description: p.profileName,
+      };
+    });
 
-  // If there are multiple profiles, add an "All" option for headless mode
-  if (isHeadless && choosableProfiles.length > 1) {
-    options.unshift({
-      tag: 'A',
-      description: 'All profiles',
+    // If there are multiple profiles, add an "All" option for headless mode
+    if (isHeadless && choosableProfiles.length > 1) {
+      options.unshift({
+        tag: 'A',
+        description: 'All profiles',
+      });
+    }
+
+    const choices = showChooser({
+      question: (
+        isHeadless
+          ? 'Choose profile(s) (commas for multiple: 1,2):'
+          : 'Choose profile:'
+      ),
+      options,
+      title: `Choose profile${isHeadless ? 's' : ''}`,
+      allowMulti: isHeadless,
     });
-  }
 
-  const choices = showChooser({
-    question: (
-      isHeadless
-        ? 'Choose profile(s) (commas for multiple: 1,2):'
-        : 'Choose profile:'
-    ),
-    options,
-    title: `Choose profile${isHeadless ? 's' : ''}`,
-    allowMulti: isHeadless,
-  });
+    const allProfilesChosen = choices.some((choice) => {
+      return choice.tag === 'A';
+    });
+    if (allProfilesChosen) {
+      selectedProfiles = choosableProfiles;
+    } else {
+      selectedProfiles = (
+        choices
+          .map((choice) => {
+            const profileIndex = Number.parseInt(choice.tag, 10) - 1;
+            if (Number.isNaN(profileIndex)) {
+              return null;
+            }
+            return choosableProfiles[profileIndex] ?? null;
+          })
+          .filter((profile) => {
+            return profile !== null;
+          })
+      );
+    }
+  }
 
-  const allProfilesChosen = choices.some((choice) => {
-    return choice.tag === 'A';
+  // Execute Cypress with selected configuration
+  await executeCypress({
+    selectedProfiles,
+    selectedBrowsers,
+    isHeadless,
+    threadsPerCombo,
+    e2eTestFolder: selectedE2ETestFolder,
+    e2eSpecPattern: selectedE2ESpecPattern,
   });
-  if (allProfilesChosen) {
-    selectedProfiles = choosableProfiles;
-  } else {
-    selectedProfiles = (
-      choices
-        .map((choice) => {
-          const profileIndex = Number.parseInt(choice.tag, 10) - 1;
-          if (Number.isNaN(profileIndex)) {
-            return null;
-          }
-          return choosableProfiles[profileIndex] ?? null;
-        })
-        .filter((profile) => {
-          return profile !== null;
-        })
-    );
-  }
-}
+};
 
-// Execute Cypress with selected configuration
-executeCypress({
-  selectedProfiles,
-  selectedBrowsers,
-  isHeadless,
-  threadsPerCombo,
-  e2eTestFolder: selectedE2ETestFolder,
-  e2eSpecPattern: selectedE2ESpecPattern,
+start().catch((error) => {
+  console.error(error);
+  process.exit(1);
 });

package/start/helpers/extractArgValue.ts

@@ -1,42 +0,0 @@
-/**
- * Extract CLI argument value or check if flag exists
- * @author Gardenia Liu
- * @author Yuen Ler Chow
- * @param args array of CLI arguments
- * @param argName the argument name to look for (e.g., '--profile' or '--headless')
- * @returns the argument value if found, empty string if flag exists without value, undefined otherwise
- */
-const extractArgValue = (args: string[], argName: string): string | undefined => {
-  let matchedValue: string | undefined;
-  args.some((rawArg, index) => {
-    const normalizedArg = rawArg.toLowerCase();
-
-    // Case 1: flag and value combined, e.g. "--profile=stage"
-    if (normalizedArg.startsWith(`${argName}=`)) {
-      const [, value] = rawArg.split('=');
-      matchedValue = value;
-      return true; // stop scanning
-    }
-
-    // Case 2: flag by itself, possibly followed by a separate value
-    if (normalizedArg === argName) {
-      const nextArg = args[index + 1];
-
-      // If the next token exists and isn't another flag, treat it as the value
-      if (nextArg && !nextArg.startsWith('--')) {
-        matchedValue = nextArg;
-      } else {
-        // Flag exists but no value given (boolean-style flag) (e.g. "--headless")
-        matchedValue = '';
-      }
-
-      return true; // stop scanning
-    }
-
-    return false;
-  });
-
-  return matchedValue;
-};
-
-export default extractArgValue;