Merge pull request #8 from luke0408/feat/test-argument-parser

Implementation of `file-specific` unit testing capabilities

Author: kakasoo

package-lock.json

@@ -48,6 +48,7 @@
   "license": "ISC",
   "devDependencies": {
     "@samchon/shopping-api": "^0.14.1",
+    "@types/inquirer": "^9.0.7",
     "@types/node": "^22.10.10",
     "prettier": "^3.4.2",
     "rimraf": "^6.0.1",

package.json

@@ -0,0 +1,128 @@
+import commander from 'commander';
+import * as inquirer from 'inquirer';
+
+/**
+ * A namespace for handling command-line argument parsing and interactive prompts.
+ */
+export namespace ArgumentParser {
+  /**
+   * A type representing an inquirer function that interacts with the user.
+   *
+   * @template T - The type of the options object to be returned.
+   * @param command - The commander command instance.
+   * @param prompt - Function to create a prompt module.
+   * @param action - Function to execute the action.
+   */
+  export type Inquirer<T> = (
+    command: commander.Command,
+    prompt: (opt?: inquirer.SeparatorOptions) => inquirer.PromptModule,
+    action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>,
+  ) => Promise<T>;
+
+  /**
+   * Interface defining the structure of the prompt utility functions.
+   */
+  export interface Prompt {
+    select: (name: string) => (message: string) => <Choice extends string>(choices: Choice[]) => Promise<Choice>;
+    boolean: (name: string) => (message: string) => Promise<boolean>;
+    number: (name: string) => (message: string, init?: number) => Promise<number>;
+  }
+
+  /**
+   * Parses command-line arguments and interacts with the user using prompts.
+   *
+   * @template T - The type of the options object to be returned.
+   * @param inquiry - A function that defines the interaction logic.
+   * @returns A promise resolving to the options object of type T.
+   */
+  export const parse = async <T>(
+    inquiry: (
+      commad: commander.Command,
+      prompt: Prompt,
+      action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>,
+    ) => Promise<T>,
+  ): Promise<T> => {
+    /**
+     * Wraps the action logic in a promise to handle command execution.
+     *
+     * @param closure - A function that processes the options and returns a promise.
+     * @returns A promise resolving to the options object of type T.
+     */
+    const action = (closure: (options: Partial<T>) => Promise<T>) =>
+      new Promise<T>((resolve, reject) => {
+        commander.program.action(async (options) => {
+          try {
+            resolve(await closure(options));
+          } catch (exp) {
+            reject(exp);
+          }
+        });
+        commander.program.parseAsync().catch(reject);
+      });
+
+    /**
+     * Creates a select prompt for choosing from a list of options.
+     *
+     * @param name - The name of the prompt.
+     * @param message - The message to display to the user.
+     * @returns A function that takes choices and returns a promise resolving to the selected choice.
+     */
+    const select =
+      (name: string) =>
+      (message: string) =>
+      async <Choice extends string>(choices: Choice[]) =>
+        (
+          await inquirer.createPromptModule()({
+            type: 'list',
+            name,
+            message,
+            choices,
+          })
+        )[name];
+
+    /**
+     * Creates a boolean prompt for yes/no questions.
+     *
+     * @param name - The name of the prompt.
+     * @returns A function that takes a message and returns a promise resolving to a boolean.
+     */
+    const boolean = (name: string) => async (message: string) =>
+      (
+        await inquirer.createPromptModule()({
+          type: 'confirm',
+          name,
+          message,
+        })
+      )[name] as boolean;
+
+    /**
+     * Creates a number prompt for numeric input.
+     *
+     * @param name - The name of the prompt.
+     * @returns A function that takes a message and an optional initial value, returning a promise resolving to a number.
+     */
+    const number = (name: string) => async (message: string, init?: number) => {
+      const value = Number(
+        (
+          await inquirer.createPromptModule()({
+            type: 'number',
+            name,
+            message,
+          })
+        )[name],
+      );
+      return init !== undefined && isNaN(value) ? init : value;
+    };
+
+    const output: T | Error = await (async () => {
+      try {
+        return await inquiry(commander.program, { select, boolean, number }, action);
+      } catch (error) {
+        return error as Error;
+      }
+    })();
+
+    if (output instanceof Error) throw output;
+    return output;
+  };
+}

test/helpers/ArgumentParser.ts

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+
+export namespace TestFileLoader {
+  export type FilterOption = { exclude?: string[]; include?: string[] };
+
+  const filter = (files: string[], options: FilterOption): string[] => {
+    return files.filter((file) => {
+      if (options.include) return isIncluded();
+      if (options.exclude) return !isExcluded();
+      return true;
+
+      function isExcluded() {
+        return options.exclude?.some((exPath) => file.split(__dirname).at(0)?.includes(exPath));
+      }
+
+      function isIncluded() {
+        return options.include?.some((incPath) => file.split(__dirname).at(0)?.includes(incPath));
+      }
+    });
+  };
+
+  const traverse = (dir: string, files: string[]) => {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (isIgnoredEntry(entry)) continue;
+
+      const fullPath = path.join(dir, entry.name);
+
+      if (isTestDirectory(entry)) {
+        traverse(fullPath, files);
+      } else if (isTestFile(entry)) {
+        files.push(fullPath);
+      }
+
+      function isIgnoredEntry(entry: fs.Dirent): boolean {
+        return entry.name.startsWith('.');
+      }
+
+      function isTestFile(entry: fs.Dirent): boolean {
+        return entry.isFile() && entry.name.endsWith('.js') && !entry.parentPath.endsWith('test');
+      }
+
+      function isTestDirectory(entry: fs.Dirent): boolean {
+        return entry.isDirectory() && entry.name !== 'helpers';
+      }
+    }
+  };
+
+  export const load = (dir: string, options: FilterOption): string[] => {
+    const files: string[] = [];
+    const currentDir = dir;
+    traverse(currentDir, files);
+    return filter(files, options);
+  };
+}

test/helpers/TestFileLoader.ts

@@ -1,27 +1,29 @@
-import fs from 'fs';
-import path from 'path';
+import { ArgumentParser } from './helpers/ArgumentParser';
+import { TestFileLoader } from './helpers/TestFileLoader';
 
-async function main() {
-  /**
-   * test code for types
-   */
-  const types = fs.readdirSync(path.join(__dirname, './types'));
-  for await (const filename of types) {
-    if (filename.endsWith('.js')) {
-      const filePath = path.join(__dirname, 'types', filename);
-      await import(filePath);
-    }
-  }
+interface IOptions {
+  include?: string[];
+  exclude?: string[];
+}
+
+const getOptions = () =>
+  ArgumentParser.parse<IOptions>(async (command, prompt, action) => {
+    command.option('--include <string...>', 'include feature files');
+    command.option('--exclude <string...>', 'exclude feature files');
+
+    prompt;
+
+    return action(async (options) => {
+      return options as IOptions;
+    });
+  });
+
+async function main(): Promise<void> {
+  const options: IOptions = await getOptions();
+  const testSet = TestFileLoader.load(__dirname, options);
 
-  /**
-   * test code for functions
-   */
-  const functions = fs.readdirSync(path.join(__dirname, './functions'));
-  for await (const filename of functions) {
-    if (filename.endsWith('.js')) {
-      const filePath = path.join(__dirname, 'functions', filename);
-      await import(filePath);
-    }
+  for await (const test of testSet) {
+    await import(test);
   }
 }