@dannysir/js-te 0.3.0 → 0.3.2

package/src/babelPlugins/babelTransformImport.js

@@ -0,0 +1,184 @@
+
+import {findAbsolutePath, shouldTransform} from "./utils/pathHelper.js";
+import {getModuleInfo} from "./utils/getModuleInfo.js";
+import {createNamespaceWrapper, createOriginalDeclaration, createWrapperFunction} from "./utils/wrapperCreator.js";
+import {BABEL, MOCK} from "../constants/babel.js";
+
+export const babelTransformImport = (mockedPaths = null) => {
+  return ({types: t}) => {
+    return {
+      visitor: {
+        Program(path) {
+          const mockStoreDeclaration = t.VariableDeclaration('const', [
+            t.VariableDeclarator(
+              t.Identifier(MOCK.STORE_NAME),
+              t.MemberExpression(
+                t.Identifier('global'),
+                t.Identifier(MOCK.STORE_NAME)
+              )
+            )
+          ]);
+          path.node.body.unshift(mockStoreDeclaration);
+        },
+
+        ImportDeclaration(nodePath, state) {
+          const source = nodePath.node.source.value;
+
+          if (source === MOCK.STORE_PATH) {
+            return;
+          }
+
+          const currentFilePath = state.filename || process.cwd();
+          const absolutePath = findAbsolutePath(source, currentFilePath);
+
+          if (!shouldTransform(absolutePath, mockedPaths)) {
+            return;
+          }
+
+          const specifiers = nodePath.node.specifiers;
+          const originalVarName = nodePath.scope.generateUidIdentifier('original');
+
+          /*
+
+          const _original = await import('./random.js');
+          const random = (...args) => {
+            const module = mockStore.has('/path/to/random.js')
+              ? { ..._original, ...mockStore.get('/path/to/random.js') }
+              : _original;
+            return module.random(...args);
+          };
+          */
+
+          const originalDeclaration = createOriginalDeclaration(
+            t,
+            originalVarName,
+            source,
+            false
+          );
+
+          const wrapperDeclarations = specifiers.map(spec => {
+            if (t.isImportDefaultSpecifier(spec)) {
+              return createWrapperFunction(
+                t,
+                'default',
+                spec.local.name,
+                absolutePath,
+                originalVarName
+              );
+            } else if (t.isImportNamespaceSpecifier(spec)) {
+              return createNamespaceWrapper(
+                t,
+                spec.local.name,
+                absolutePath,
+                originalVarName
+              );
+            } else {
+              return createWrapperFunction(
+                t,
+                spec.imported.name,
+                spec.local.name,
+                absolutePath,
+                originalVarName
+              );
+            }
+          });
+
+          const wrapperDeclaration = t.variableDeclaration(BABEL.CONST, wrapperDeclarations);
+
+          nodePath.replaceWithMultiple([originalDeclaration, wrapperDeclaration]);
+        },
+
+        VariableDeclaration(nodePath, state) {
+          const declarations = nodePath.node.declarations;
+
+          if (!declarations || declarations.length === 0) {
+            return;
+          }
+
+          if (nodePath.node._transformed) {
+            return;
+          }
+
+          const newDeclarations = [];
+          let hasTransformation = false;
+
+          for (const declarator of declarations) {
+            const requireInfo = getModuleInfo(t, declarator);
+
+            if (!requireInfo) {
+              newDeclarations.push(declarator);
+              continue;
+            }
+
+            const {source} = requireInfo;
+            const currentFilePath = state.filename || process.cwd();
+            const absolutePath = findAbsolutePath(source, currentFilePath);
+
+            if (!shouldTransform(absolutePath, mockedPaths)) {
+              newDeclarations.push(declarator);
+              continue;
+            }
+
+            hasTransformation = true;
+            const originalVar = nodePath.scope.generateUidIdentifier('original');
+
+            /*
+
+            const _original = require('./random');
+            const random = (...args) => {
+              const module = mockStore.has('/path/to/random.js')
+                ? { ..._original, ...mockStore.get('/path/to/random.js') }
+                : _original;
+              return module.random(...args);
+            };
+            */
+
+            newDeclarations.push(
+              t.variableDeclarator(
+                originalVar,
+                t.callExpression(
+                  t.identifier('require'),
+                  [t.stringLiteral(source)]
+                )
+              )
+            );
+
+            if (t.isObjectPattern(declarator.id)) {
+              const properties = declarator.id.properties;
+
+              properties.forEach(prop => {
+                const key = prop.key.name;
+                const localName = prop.value.name;
+
+                newDeclarations.push(
+                  createWrapperFunction(
+                    t,
+                    key,
+                    localName,
+                    absolutePath,
+                    originalVar
+                  )
+                );
+              });
+            } else {
+              newDeclarations.push(
+                createWrapperFunction(
+                  t,
+                  'default',
+                  declarator.id.name,
+                  absolutePath,
+                  originalVar
+                )
+              );
+            }
+          }
+
+          if (hasTransformation) {
+            nodePath.node.declarations = newDeclarations;
+            nodePath.node._transformed = true;
+          }
+        }
+      }
+    };
+  }
+};

package/src/babelPlugins/utils/getModuleInfo.js

@@ -0,0 +1,21 @@
+/**
+ * require 호출 정보 추출
+ * @param {Object} t - Babel types
+ * @param {Object} declarator - VariableDeclarator 노드
+ * @returns {Object|null} require 정보 또는 null
+ */
+export const getModuleInfo = (t, declarator) => {
+  const init = declarator.init;
+
+  if (!init ||
+    !t.isCallExpression(init) ||
+    !t.isIdentifier(init.callee, {name: 'require'}) ||
+    !init.arguments[0] ||
+    !t.isStringLiteral(init.arguments[0])) {
+    return null;
+  }
+
+  return {
+    source: init.arguments[0].value
+  };
+};

package/src/babelPlugins/utils/pathHelper.js

@@ -0,0 +1,56 @@
+import path from 'path';
+
+import {BABEL} from "../../constants/babel.js";
+
+/**
+ * 상대/절대 경로를 절대 경로로 변환
+ * @param {string} source - import/require 경로
+ * @param {string} currentFilePath - 현재 파일의 경로
+ * @returns {string} 절대 경로
+ *
+ * @example
+ * // 상대 경로인 경우:
+ * resolveAbsolutePath('./random.js', '/Users/san/project/test.js')
+ * // 반환: '/Users/san/project/random.js'
+ *
+ * // 절대 경로인 경우:
+ * resolveAbsolutePath('/Users/san/lib/utils.js', '/Users/san/project/test.js')
+ * // 반환: '/Users/san/lib/utils.js'
+ */
+export const findAbsolutePath = (source, currentFilePath) => {
+  const currentDir = path.dirname(currentFilePath || process.cwd());
+
+  if (source.startsWith(BABEL.PERIOD)) {
+    return path.resolve(currentDir, source);
+  }
+
+  return source;
+};
+
+/**
+ * 해당 경로가 변환 대상인지 확인
+ * @param {string} absolutePath - 절대 경로
+ * @param {Set<string>|null} mockedPaths - mock된 경로들
+ * @returns {boolean}
+ *
+ * @example
+ * // mockedPaths가 null인 경우:
+ * shouldTransform('/Users/san/project/random.js', null)
+ * // 반환: true (모든 파일 변환)
+ *
+ * // mockedPaths에 포함된 경우:
+ * const mocked = new Set(['/Users/san/project/random.js']);
+ * shouldTransform('/Users/san/project/random.js', mocked)
+ * // 반환: true (변환 대상)
+ *
+ * // mockedPaths에 없는 경우:
+ * shouldTransform('/Users/san/project/game.js', mocked)
+ * // 반환: false (변환하지 않음)
+ */
+export const shouldTransform = (absolutePath, mockedPaths) => {
+  if (!mockedPaths) {
+    return true;
+  }
+
+  return mockedPaths.has(absolutePath);
+};

package/src/babelPlugins/utils/wrapperCreator.js

@@ -0,0 +1,121 @@
+
+import {BABEL, MOCK} from "../../constants/babel.js";
+
+/**
+ * Mock wrapper 함수를 생성하는 헬퍼
+ * @param {Object} t - Babel types
+ * @param {string} importedName - import된 함수명
+ * @param {string} localName - 로컬 변수명
+ * @param {string} absolutePath - 모듈의 절대 경로
+ * @param {Object} originalVarName - 원본 모듈을 가리키는 변수
+ * @returns {Object} 바벨 변수 선언
+ *
+ * @example
+ * // 반환 결과 (코드로 표현하면):
+ * const random = (...args) => {
+ *   const module = mockStore.has('/path/to/random.js')
+ *     ? { ..._original, ...mockStore.get('/path/to/random.js') }
+ *     : _original;
+ *   return module.random(...args);
+ * };
+ */
+export const createWrapperFunction = (t, importedName, localName, absolutePath, originalVarName) => {
+  return t.variableDeclarator(
+    t.identifier(localName),
+    t.arrowFunctionExpression(
+      [t.restElement(t.identifier('args'))],
+      t.blockStatement([
+        t.variableDeclaration(BABEL.CONST, [
+          t.variableDeclarator(
+            t.identifier(BABEL.MODULE),
+            createConditionalModule(t, absolutePath, originalVarName)
+          )
+        ]),
+        t.returnStatement(
+          t.callExpression(
+            t.memberExpression(t.identifier(BABEL.MODULE), t.identifier(importedName)),
+            [t.spreadElement(t.identifier('args'))]
+          )
+        )
+      ])
+    )
+  );
+};
+
+/**
+ * Namespace import용 wrapper 생성
+ * @param {Object} t - Babel types
+ * @param {string} localName - 로컬 변수명
+ * @param {string} absolutePath - 모듈의 절대 경로
+ * @param {Object} originalVarName - 원본 모듈 변수
+ * @returns {Object} 바벨 변수 선언
+ *
+ * @example
+ * // 반환 결과 (코드로 표현하면):
+ * const utils = mockStore.has('/path/to/utils.js')
+ *   ? { ..._original, ...mockStore.get('/path/to/utils.js') }
+ *   : _original;
+ */
+export const createNamespaceWrapper = (t, localName, absolutePath, originalVarName) => {
+  return t.variableDeclarator(
+    t.identifier(localName),
+    createConditionalModule(t, absolutePath, originalVarName)
+  );
+};
+
+/**
+ * 원본 모듈 선언문 생성
+ * @param {Object} t - Babel types
+ * @param {Object} originalVarName - 원본 모듈 변수
+ * @param {string} source - import 경로
+ * @param {boolean} isRequire - require 방식인지 여부
+ * @returns {Object} 바벨 변수 선언
+ *
+ * @example
+ * // isRequire = false인 경우 (코드로 표현하면):
+ * const _original = await import('./random.js');
+ *
+ * // isRequire = true인 경우 (코드로 표현하면):
+ * const _original = require('./random.js');
+ */
+export const createOriginalDeclaration = (t, originalVarName, source, isRequire = false) => {
+  const init = isRequire
+    ? t.callExpression(t.identifier('require'), [t.stringLiteral(source)])
+    : t.awaitExpression(t.importExpression(t.stringLiteral(source)));
+
+  return t.variableDeclaration(BABEL.CONST, [
+    t.variableDeclarator(originalVarName, init)
+  ]);
+};
+
+/**
+ * 조건부 모듈 표현식 생성 (mockStore 체크)
+ * @param {Object} t - Babel types
+ * @param {string} absolutePath - 모듈의 절대 경로
+ * @param {Object} originalVarName - 원본 모듈 변수
+ * @returns {Object} 바벨 조건문
+ *
+ * @example
+ * // 반환 결과 (코드로 표현하면):
+ * mockStore.has('/path/to/random.js')
+ *   ? { ..._original, ...mockStore.get('/path/to/random.js') }
+ *   : _original
+ */
+const createConditionalModule = (t, absolutePath, originalVarName) => {
+  return t.conditionalExpression(
+    t.callExpression(
+      t.memberExpression(t.identifier(MOCK.STORE_NAME), t.identifier(BABEL.HAS)),
+      [t.stringLiteral(absolutePath)]
+    ),
+    t.objectExpression([
+      t.spreadElement(originalVarName),
+      t.spreadElement(
+        t.callExpression(
+          t.memberExpression(t.identifier(MOCK.STORE_NAME), t.identifier(BABEL.GET)),
+          [t.stringLiteral(absolutePath)]
+        )
+      )
+    ]),
+    originalVarName
+  );
+};

package/src/cli/runTests.js

@@ -0,0 +1,22 @@
+import path from 'path';
+import {getFilePath} from "../utils/messages.js";
+import {transformFiles} from "../utils/transformFiles.js";
+import {NUM} from "../constants/index.js";
+
+export const runTests = async (jsTe, mockedPaths, testFiles) => {
+  let totalPassed = NUM.ZERO;
+  let totalFailed = NUM.ZERO;
+
+  for (const file of testFiles) {
+    console.log(getFilePath(file));
+    transformFiles(file, mockedPaths);
+
+    await import(path.resolve(file));
+
+    const {passed, failed} = await jsTe.run();
+    totalPassed += passed;
+    totalFailed += failed;
+  }
+
+  return {totalPassed, totalFailed}
+};

package/src/cli/setupEnvironment.js

@@ -0,0 +1,32 @@
+import path from 'path';
+import fs from 'fs';
+import {MODULE_TYPE, NUM, PATH} from "../constants/index.js";
+
+const getUserModuleType = () => {
+  try {
+    const pkgPath = path.join(process.cwd(), 'package.json');
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.type === MODULE_TYPE.MODULE ? MODULE_TYPE.ESM : MODULE_TYPE.CJS;
+  } catch {
+    return MODULE_TYPE.CJS;
+  }
+};
+
+export const setupEnvironment = async () => {
+  const moduleType = getUserModuleType();
+
+  let jsTe;
+  if (moduleType === MODULE_TYPE.ESM) {
+    jsTe = await import(PATH.DANNYSIR_JS_TE);
+  } else {
+    const {createRequire} = await import(MODULE_TYPE.MODULE);
+    const require = createRequire(import.meta.url);
+    jsTe = require(PATH.DANNYSIR_JS_TE);
+  }
+
+  Object.keys(jsTe).forEach(key => {
+    global[key] = jsTe[key];
+  });
+
+  return jsTe
+};

package/src/cli/setupFiles.js

@@ -0,0 +1,15 @@
+import {findAllSourceFiles, findTestFiles} from "../utils/findFiles.js";
+import {getFileCountString} from "../utils/messages.js";
+import {collectMockedPaths} from "../mock/collectMocks.js";
+import {transformFiles} from "../utils/transformFiles.js";
+
+export const setupFiles = () => {
+  const testFiles = findTestFiles(process.cwd());
+  const mockedPaths = collectMockedPaths(testFiles);
+  const sourceFiles = findAllSourceFiles(process.cwd());
+
+  for (const file of sourceFiles) {
+    transformFiles(file, mockedPaths);
+  }
+  return {mockedPaths, testFiles}
+};

package/src/constants/babel.js

@@ -0,0 +1,12 @@
+export const MOCK = {
+  STORE_NAME: 'mockStore',
+  STORE_PATH: '@dannysir/js-te/src/mock/store.js'
+};
+
+export const BABEL = {
+  MODULE: 'module',
+  CONST: 'const',
+  HAS: 'has',
+  GET: 'get',
+  PERIOD: '.',
+};

package/src/constants/index.js

@@ -0,0 +1,29 @@
+export const PATH = {
+  NODE_MODULES: 'node_modules',
+  TEST_DIRECTORY: 'test',
+  TEST_FILE: '.test.js',
+  JAVASCRIPT_FILE: '.js',
+  BIN: 'bin',
+  DIST: 'dist',
+  DANNYSIR_JS_TE: '@dannysir/js-te',
+};
+
+export const RESULT_MSG = {
+  TESTS: 'Tests: ',
+  TOTAL: 'Total Result: ',
+  CHECK: '✓ ',
+  CROSS: '✗ ',
+  DIRECTORY_DELIMITER: ' > ',
+  EMPTY: '',
+};
+
+export const NUM = {
+  ZERO: 0,
+  ONE: 1,
+};
+
+export const MODULE_TYPE = {
+  MODULE: 'module',
+  ESM: 'esm',
+  CJS: 'cjs',
+};

package/src/constants/view.js

@@ -0,0 +1,9 @@
+export const COLORS = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+  bold: '\x1b[1m'
+};

package/src/matchers.js

@@ -1,5 +1,4 @@
-
-import {getErrorMsg, getThrowErrorMsg} from "../utils/formatString.js";
+import {getErrorMsg, getThrowErrorMsg} from "./utils/formatString.js";
 
 const runArgFnc = (actual) => {
   if (typeof actual === 'function') {

package/src/mock/collectMocks.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import {transformSync} from "@babel/core";
-import {BABEL} from "../../constants.js";
-import {createMockCollectorPlugin} from "../../babelCollectMocks.js";
+import {createMockCollectorPlugin} from "../babelPlugins/babelCollectMocks.js";
+import {BABEL} from "../constants/babel.js";
 
 export const collectMockedPaths = (testFiles) => {
   const mockedPaths = new Set();
@@ -19,7 +19,6 @@ export const collectMockedPaths = (testFiles) => {
         }
       });
     } catch (error) {
-      // 파싱 에러는 무시 (어차피 테스트 실행 시 에러 발생)
       console.warn(`Warning: Failed to scan ${testFile} for mocks`);
     }
   }

package/src/mock/store.js

@@ -1,17 +1,17 @@
 export const mockStore = new Map();
 
-export function clearAllMocks() {
+export const clearAllMocks = () => {
   mockStore.clear();
 }
 
-export function mock(modulePath, mockExports) {
+export const mock = (modulePath, mockExports) => {
   mockStore.set(modulePath, mockExports);
 }
 
-export function unmock(modulePath) {
+export const unmock = (modulePath) => {
   mockStore.delete(modulePath);
 }
 
-export function isMocked(modulePath) {
+export const isMocked = (modulePath) => {
   return mockStore.has(modulePath);
 }

package/src/testManager.js

@@ -1,4 +1,7 @@
-import {DIRECTORY_DELIMITER} from "../constants.js";
+import {formatFailureMessage, formatSuccessMessage, getMatcherForReplace, placeHolder} from "./utils/formatString.js";
+import {clearAllMocks} from "./mock/store.js";
+import {NUM, RESULT_MSG} from "./constants/index.js";
+import {getTestResultMsg} from "./utils/messages.js";
 
 class TestManager {
   #tests = [];
@@ -24,7 +27,7 @@ class TestManager {
         }
         await fn();
       },
-      path: this.#testDepth.join(DIRECTORY_DELIMITER),
+      path: this.#testDepth.join(RESULT_MSG.DIRECTORY_DELIMITER),
     }
     this.#tests.push(testObj);
   }
@@ -52,21 +55,37 @@ class TestManager {
     this.#beforeEachArr = [];
   }
 
+  async run() {
+    let passed = NUM.ZERO;
+    let failed = NUM.ZERO;
+
+    for (const test of testManager.getTests()) {
+      try {
+        await test.fn();
+        console.log(formatSuccessMessage(test));
+        passed++;
+        clearAllMocks();
+      } catch (error) {
+        console.log(formatFailureMessage(test, error));
+        failed++;
+      }
+    }
+
+    console.log(getTestResultMsg(RESULT_MSG.TESTS, passed, failed));
+
+    testManager.clearTests();
+
+    return {passed, failed};
+  }
+
   #formatDescription(args, description) {
     let argIndex = 0;
-    return description.replace(/%([so])/g, (match, type) => {
+    return description.replace(getMatcherForReplace(), (match, type) => {
       if (argIndex >= args.length) return match;
 
-      const arg = args[argIndex++];
+      const formatter = placeHolder[type];
 
-      switch (type) {
-        case 's':
-          return arg;
-        case 'o':
-          return JSON.stringify(arg);
-        default:
-          return match;
-      }
+      return formatter ? formatter(args[argIndex++]) : match;
     });
   }
 }

package/{utils → src/utils}/consoleColor.js

@@ -1,8 +1,8 @@
-import {COLORS} from "../constants.js";
+import {COLORS} from "../constants/view.js";
 
 export const colorize = (text, color) => `${color}${text}${COLORS.reset}`;
 
 export const green = (text) => colorize(text, COLORS.green + COLORS.bold);
 export const red = (text) => colorize(text, COLORS.red + COLORS.bold);
 export const bold = (text) => colorize(text, COLORS.bold);
-export const yellow = (text) => colorize(text, COLORS.yellow + COLORS.bold);
+export const yellow = (text) => colorize(text, COLORS.yellow + COLORS.bold);

package/{bin → src}/utils/findFiles.js

@@ -1,15 +1,21 @@
 import fs from 'fs';
 import path from 'path';
-import {PATH} from "../../constants.js";
 
+
+import {PATH} from "../constants/index.js";
+
+/**
+ * 테스트 파일을 찾는 로직입니다.
+ * @param {string} dir
+ * @returns {string[]}
+ */
 export const findTestFiles = (dir) => {
   const files = [];
 
-  const walk = (directory, inTestDir = false) => {
+  const walk = (directory) => {
     const items = fs.readdirSync(directory);
     const dirName = path.basename(directory);
-
-    const isTestDir = dirName === PATH.TEST_DIRECTORY || inTestDir;
+    const isTestDir = dirName === PATH.TEST_DIRECTORY;
 
     for (const item of items) {
       if (item === PATH.NODE_MODULES) continue;
@@ -31,6 +37,11 @@ export const findTestFiles = (dir) => {
   return files;
 }
 
+/**
+ * 테스트 파일을 포함한 전체 파일을 찾는 함수입니다.
+ * @param {string} dir
+ * @returns {string[]}
+ */
 export const findAllSourceFiles = (dir) => {
   const files = [];
 
@@ -53,4 +64,4 @@ export const findAllSourceFiles = (dir) => {
 
   walk(dir);
   return files;
-}
+};