@dannysir/js-te 0.0.2 → 0.1.1

package/README.md

@@ -27,10 +27,12 @@ describe('[단순 연산 테스트]', () => {
 
 ### 2. 테스트 실행
 
-package.json에 추가:
+package.json에 추가.
 
+- type을 module로 설정해주세요.
 ```json
 {
+  "type": "module",
   "scripts": {
     "test": "js-te"
   }
@@ -42,6 +44,11 @@ package.json에 추가:
 npm test
 ```
 
+### 예시 출력 화면
+
+<p align='center'>
+  <img width="585" height="902" alt="스크린샷 2025-11-20 오후 12 22 27" src="https://github.com/user-attachments/assets/3d087a61-cc44-4f5b-8a2f-efd5f15c12b7" />
+</p>
 
 # API
 
@@ -127,41 +134,40 @@ Babel을 사용해서 import 구문을 변환하여 mock 함수를 가져오도
    2. `path`를 key로 이용해 Map에 저장
 2. Babel로 코드 변환
    1. 전체 파일의 import문 확인
-   2. import 경로가 Map에 존재하면 mock 객체로 변환
-   3. import 경로가 Map에 없다면 그대로 import
+   2. (0.0.3 버전 추가) import 경로를 **절대 경로**로 변환
+   2. import 경로(절대 경로)가 Map에 존재하면 mock 객체로 변환
+   3. import 경로(절대 경로)가 Map에 없다면 그대로 import
 3. 테스트 실행
 4. 원본 파일 복구
 
-### 🚨 주의 사항 (현재 수정 중)
-
-mocking 기능의 경우 현재 `path`를 기반으로 직접 변환을 하기 때문에 mocking이 필요한 함수의 경우 
-
-반드시 **절대 경로**로 표현한 후 `mock` 함수에 **절대 경로**로 등록을 해주세요.
+### `mock(모듈 절대 경로), mock객체)`
 
-> 만약 모듈이 사용되는 모든 위치의 path가 동일하다면 상대 경로도 정삭 작동합니다.
+모듈을 모킹합니다. import 하기 **전에** 호출해야 합니다.
 
-### `mock(모듈경로, mock객체)`
+**🚨 주의사항**
 
-모듈을 모킹합니다. import 하기 **전에** 호출해야 합니다.
+1. 반드시 경로는 절대 경로로 입력해주세요.
+   - babel이 import문에서 절대 경로로 변환하여 확인을 하기 때문에 반드시 절대 경로로 등록해주세요.
+2. import문을 반드시 mocking 이후에 선언해주세요.
+   - mocking 전에 import를 하게 되면 mocking되기 전의 모듈을 가져오게 됩니다.
 
 ```javascript
 // random.js
 export const random = () => Math.random();
 
 // game.js
-import { random } from './random.js';
+import { random } from './random.js'; // 자유롭게 import하면 babel에서 절대 경로로 변환하여 판단합니다.
 export const play = () => random() * 10;
 
 // game.test.js
-import { mock, test, expect } from 'js-te';
-
 test('랜덤 함수 모킹', async () => {
   // 1. 먼저 모킹
-  mock('./random.js', {
+  mock('/Users/san/Js-Te/test-helper/random.js', { // 반드시 절대 경로로 등록
     random: () => 0.5
   });
   
   // 2. 그 다음 import
+  // 상단에 import문을 입력할 경우 
   const { play } = await import('./game.js');
   
   // 3. 모킹된 값 사용
@@ -181,6 +187,82 @@ test('랜덤 함수 모킹', async () => {
 
 mock이 등록되어 있는지 확인합니다.
 
+## `each(cases)`
+
+`cases`를 배열로 받아 순차적으로 테스트 진행
+
+#### 🚨 주의 사항
+
+`cases`는 반드시 `Array` 타입으로 받아야 합니다.
+
+### 플레이스 홀더
+
+- %s - 문자열/숫자
+- %o - 객체 (JSON.stringify)
+
+```jsx
+test.each([
+  [1, 2, 3, 6],
+  [3, 4, 5, 12],
+  [10, 20, 13, 43],
+  [10, 12, 13, 35],
+])('[each test] - input : %s, %s, %s, %s', (a, b, c, result) => {
+  expect(a + b + c).toBe(result);
+});
+
+/* 출력 결과
+✓ [each test] - input : 1, 2, 3, 6
+✓ [each test] - input : 3, 4, 5, 12
+✓ [each test] - input : 10, 20, 13, 43
+✓ [each test] - input : 10, 12, 13, 35
+ */
+
+test.each([
+  [{ name : 'dannysir', age : null}],
+])('[each test placeholder] - input : %o', (arg) => {
+  expect(arg.name).toBe('dannysir');
+});
+
+/* 출력 결과
+✓ [each test placeholder] - input : {"name":"dannysir","age":null}
+ */
+```
+
+## `beforeEach(함수)`
+
+각 테스트가 진행되기 전에 실행할 함수를 선언합니다.
+
+중첩된 describe에서의 `beforeEach`는 상위 describe의 `beforeEach`를 모두 실행한 후, 자신의 `beforeEach`를 실행합니다.
+
+```jsx
+describe('카운터 테스트', () => {
+  let counter;
+  
+  beforeEach(() => {
+    counter = 0;
+  });
+  
+  test('카운터 증가', () => {
+    counter++;
+    expect(counter).toBe(1);
+  });
+  
+  test('카운터는 0부터 시작', () => {
+    expect(counter).toBe(0);
+  });
+  
+  describe('중첩된 describe', () => {
+    beforeEach(() => {
+      counter = 10;
+    });
+    
+    test('카운터는 10', () => {
+      expect(counter).toBe(10);
+    });
+  });
+});
+```
+
 ## 테스트 파일 찾기 규칙
 
 자동으로 다음 파일들을 찾아서 실행합니다:
@@ -204,8 +286,6 @@ mock이 등록되어 있는지 확인합니다.
 ### 기본 테스트
 
 ```javascript
-import { describe, test, expect } from 'js-te';
-
 describe('문자열 테스트', () => {
   test('문자열 합치기', () => {
     const result = 'hello' + ' ' + 'world';
@@ -222,10 +302,8 @@ describe('문자열 테스트', () => {
 
 ```javascript
 // mocking.test.js
-import { mock, test, expect } from 'js-te';
-
 test('[mocking] - mocking random function', async () => {
-  mock('/src/test-helper/random.js', {
+  mock('/Users/san/Js-Te/test-helper/random.js', {
     random: () => 3,
   });
   const {play} = await import('../src/test-helper/game.js');
@@ -234,7 +312,7 @@ test('[mocking] - mocking random function', async () => {
 
 
 // game.js
-import {random} from '/src/test-helper/random.js'
+import {random} from '/test-helper/random.js'
 
 export const play = () => {
   return random() * 10;
@@ -244,16 +322,6 @@ export const play = () => {
 export const random = () => Math.random();
 ```
 
-## 설정
-
-`package.json`에 해당 설정을 하셔야 정상 작동합니다.
-
-```json
-{
-  "type": "module"
-}
-```
-
 ## 링크
 
 - [GitHub](https://github.com/dannysir/Js-Te)
@@ -264,4 +332,4 @@ export const random = () => Math.random();
 
 ## 라이선스
 
-ISC
+ISC

package/babelTransformImport.js

@@ -1,44 +1,53 @@
+import path from 'path';
+import {BABEL, MOCK} from "./constants.js";
+
 export const babelTransformImport = ({types: t}) => {
   return {
     visitor: {
       Program(path) {
         const importStatement = t.ImportDeclaration(
           [t.importSpecifier(
-            t.identifier('__mockRegistry__'),
-            t.identifier('__mockRegistry__')
+            t.identifier(MOCK.STORE_NAME),
+            t.identifier(MOCK.STORE_NAME)
           )],
-          t.stringLiteral('@dannysir/js-te/src/mock/store.js')
+          t.stringLiteral(MOCK.STORE_PATH)
         );
         path.node.body.unshift(importStatement);
       },
 
-      ImportDeclaration(path) {
-        const source = path.node.source.value;
+      ImportDeclaration(nodePath, state) {
+        const source = nodePath.node.source.value;
 
-        if (source === '@dannysir/js-te/src/mock/store.js') {
+        if (source === MOCK.STORE_PATH) {
           return;
         }
 
-        const specifiers = path.node.specifiers;
+        const currentFilePath = state.filename || process.cwd();
+        const currentDir = path.dirname(currentFilePath);
+
+        let absolutePath;
+        if (source.startsWith(BABEL.PERIOD)) {
+          absolutePath = path.resolve(currentDir, source);
+        } else {
+          absolutePath = source;
+        }
+
+        const specifiers = nodePath.node.specifiers;
 
-        // 1. 먼저 모듈을 한 번만 가져오기 (mock이면 mock, 아니면 실제)
-        const moduleVarName = path.scope.generateUidIdentifier('module');
+        const moduleVarName = nodePath.scope.generateUidIdentifier(BABEL.MODULE);
 
-        const moduleDeclaration = t.variableDeclaration('const', [
+        const moduleDeclaration = t.variableDeclaration(BABEL.CONST, [
           t.variableDeclarator(
             moduleVarName,
             t.conditionalExpression(
-              // 조건: __mockRegistry__.has(source)
               t.callExpression(
-                t.memberExpression(t.identifier('__mockRegistry__'), t.identifier('has')),
-                [t.stringLiteral(source)]
+                t.memberExpression(t.identifier(MOCK.STORE_NAME), t.identifier(BABEL.HAS)),
+                [t.stringLiteral(absolutePath)]
               ),
-              // true: mock 반환
               t.callExpression(
-                t.memberExpression(t.identifier('__mockRegistry__'), t.identifier('get')),
-                [t.stringLiteral(source)]
+                t.memberExpression(t.identifier(MOCK.STORE_NAME), t.identifier(BABEL.GET)),
+                [t.stringLiteral(absolutePath)]
               ),
-              // false: 실제 import
               t.awaitExpression(
                 t.importExpression(t.stringLiteral(source))
               )
@@ -46,7 +55,6 @@ export const babelTransformImport = ({types: t}) => {
           )
         ]);
 
-        // 2. 각 specifier를 moduleVarName에서 추출
         const extractDeclarations = specifiers.map(spec => {
           let importedName, localName;
 
@@ -55,7 +63,6 @@ export const babelTransformImport = ({types: t}) => {
             localName = spec.local.name;
           } else if (t.isImportNamespaceSpecifier(spec)) {
             localName = spec.local.name;
-            // namespace import는 전체 모듈
             return t.variableDeclarator(
               t.identifier(localName),
               moduleVarName
@@ -71,9 +78,9 @@ export const babelTransformImport = ({types: t}) => {
           );
         });
 
-        const extractDeclaration = t.variableDeclaration('const', extractDeclarations);
+        const extractDeclaration = t.variableDeclaration(BABEL.CONST, extractDeclarations);
 
-        path.replaceWithMultiple([moduleDeclaration, extractDeclaration]);
+        nodePath.replaceWithMultiple([moduleDeclaration, extractDeclaration]);
       }
     }
   };

package/bin/cli.js

@@ -4,9 +4,9 @@ import fs from 'fs';
 import path from 'path';
 import {transformSync} from '@babel/core';
 import * as jsTe from '../index.js';
-import {green, yellow} from "../utils/consoleColor.js";
+import {green, red, yellow} from "../utils/consoleColor.js";
 import {getTestResultMsg} from "../utils/makeMessage.js";
-import {RESULT_TITLE} from "../constants.js";
+import {BABEL, PATH, RESULT_TITLE} from "../constants.js";
 import { babelTransformImport } from '../babelTransformImport.js';
 
 let totalPassed = 0;
@@ -25,7 +25,7 @@ const transformFile = (filePath) => {
     filename: filePath,
     plugins: [babelTransformImport],
     parserOpts: {
-      sourceType: 'module',
+      sourceType: BABEL.MODULE,
       plugins: ['dynamicImport']
     }
   });
@@ -35,8 +35,13 @@ const transformFile = (filePath) => {
 
 const restoreFiles = () => {
   for (const [filePath, originalCode] of originalFiles.entries()) {
-    fs.writeFileSync(filePath, originalCode);
+    try {
+      fs.writeFileSync(filePath, originalCode);
+    } catch (error) {
+      console.error(red(`Failed to restore ${filePath}: ${error.message}`));
+    }
   }
+  originalFiles.clear();
 };
 
 const findTestFiles = (dir) => {
@@ -46,18 +51,18 @@ const findTestFiles = (dir) => {
     const items = fs.readdirSync(directory);
     const dirName = path.basename(directory);
 
-    const isTestDir = dirName === 'test' || inTestDir;
+    const isTestDir = dirName === PATH.TEST_DIRECTORY || inTestDir;
 
     for (const item of items) {
-      if (item === 'node_modules') continue;
+      if (item === PATH.NODE_MODULES) continue;
 
       const fullPath = path.join(directory, item);
       const stat = fs.statSync(fullPath);
 
       if (stat.isDirectory()) {
         walk(fullPath, isTestDir);
-      } else if (item.endsWith('.test.js') || isTestDir) {
-        if (item.endsWith('.js')) {
+      } else if (item.endsWith(PATH.TEST_FILE) || isTestDir) {
+        if (item.endsWith(PATH.JAVASCRIPT_FILE)) {
           files.push(fullPath);
         }
       }
@@ -75,14 +80,14 @@ const findAllSourceFiles = (dir) => {
     const items = fs.readdirSync(directory);
 
     for (const item of items) {
-      if (item === 'node_modules' || item === 'bin' || item === 'test') continue;
+      if (item === PATH.NODE_MODULES || item === PATH.BIN || item === PATH.TEST_DIRECTORY) continue;
 
       const fullPath = path.join(directory, item);
       const stat = fs.statSync(fullPath);
 
       if (stat.isDirectory()) {
         walk(fullPath);
-      } else if (item.endsWith('.js') && !item.endsWith('.test.js')) {
+      } else if (item.endsWith(PATH.JAVASCRIPT_FILE) && !item.endsWith(PATH.TEST_FILE)) {
         files.push(fullPath);
       }
     }
@@ -92,32 +97,41 @@ const findAllSourceFiles = (dir) => {
   return files;
 }
 
-const sourceFiles = findAllSourceFiles(process.cwd());
 
-for (const file of sourceFiles) {
-  transformFile(file);
-}
+const main = async () => {
+  try {
+    const sourceFiles = findAllSourceFiles(process.cwd());
+    for (const file of sourceFiles) {
+      transformFile(file);
+    }
 
-const testFiles = findTestFiles(process.cwd());
+    const testFiles = findTestFiles(process.cwd());
 
-console.log(`\nFound ${green(testFiles.length)} test file(s)`);
+    console.log(`\nFound ${green(testFiles.length)} test file(s)`);
 
-for (const file of testFiles) {
-  console.log(`\n${yellow(file)}\n`);
+    for (const file of testFiles) {
+      console.log(`\n${yellow(file)}\n`);
 
-  transformFile(file);
+      transformFile(file);
+      await import(path.resolve(file));
 
-  await import(path.resolve(file));
+      const {passed, failed} = await jsTe.run();
+      totalPassed += passed;
+      totalFailed += failed;
+    }
 
-  const {passed, failed} = await jsTe.run();
-  totalPassed += passed;
-  totalFailed += failed;
-}
+    console.log(getTestResultMsg(RESULT_TITLE.TOTAL, totalPassed, totalFailed));
 
-restoreFiles();
+    return totalFailed > 0 ? 1 : 0;
 
-console.log(getTestResultMsg(RESULT_TITLE.TOTAL, totalPassed, totalFailed));
+  } catch (error) {
+    console.log(red('\n✗ Test execution failed'));
+    console.log(red(`  Error: ${error.message}\n`));
+    return 1;
+  } finally {
+    restoreFiles();
+  }
+};
 
-if (totalFailed > 0) {
-  process.exit(1);
-}
+const exitCode = await main();
+process.exit(exitCode);

package/constants.js

@@ -25,4 +25,26 @@ export const COLORS = {
   cyan: '\x1b[36m',
   gray: '\x1b[90m',
   bold: '\x1b[1m'
+};
+
+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: '.',
+};
+
+export const PATH = {
+  NODE_MODULES: 'node_modules',
+  TEST_DIRECTORY: 'test',
+  TEST_FILE: '.test.js',
+  JAVASCRIPT_FILE: '.js',
+  BIN: 'bin',
+
 };

package/index.js

@@ -6,15 +6,19 @@ import {
 import {Tests} from "./src/tests.js";
 import {green, red} from "./utils/consoleColor.js";
 import {getTestResultMsg} from "./utils/makeMessage.js";
+import {clearAllMocks} from "./src/mock/store.js";
 
 const tests = new Tests();
 
 export { mock, clearAllMocks, unmock, isMocked } from './src/mock/store.js';
 
 export const test = (description, fn) => tests.test(description, fn);
+test.each = (cases) => tests.testEach(cases);
 
 export const describe = (suiteName, fn) => tests.describe(suiteName, fn);
 
+export const beforeEach = (fn) => tests.beforeEach(fn);
+
 export const expect = (actual) => {
   let value = actual;
 
@@ -73,10 +77,11 @@ export const run = async () => {
       const directoryString = green(CHECK) + (test.path === '' ? EMPTY : test.path + DIRECTORY_DELIMITER) + test.description
       console.log(directoryString);
       passed++;
+      clearAllMocks();
     } catch (error) {
       const errorDirectory = red(CROSS) + test.path + test.description
       console.log(errorDirectory);
-      console.log(red(`  ${error.message}`));
+      console.log(red(`  Error Message : ${error.message}`));
       failed++;
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dannysir/js-te",
-  "version": "0.0.2",
+  "version": "0.1.1",
   "type": "module",
   "description": "JavaScript test library",
   "main": "index.js",

package/src/mock/store.js

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

package/src/tests.js

@@ -3,22 +3,45 @@ import {DIRECTORY_DELIMITER} from "../constants.js";
 export class Tests {
   #tests = [];
   #testDepth = [];
+  #beforeEachArr = [];
 
   describe(str, fn) {
     this.#testDepth.push(str);
+    const prevLength = this.#beforeEachArr.length;
     fn();
+    this.#beforeEachArr.length = prevLength;
     this.#testDepth.pop();
   }
 
   test(description, fn) {
+    const beforeEachHooks = [...this.#beforeEachArr];
+
     const testObj = {
       description,
-      fn,
+      fn: async () => {
+        for (const hook of beforeEachHooks) {
+          await hook();
+        }
+        await fn();
+      },
       path: this.#testDepth.join(DIRECTORY_DELIMITER),
     }
     this.#tests.push(testObj);
   }
 
+  testEach(cases) {
+    return (description, fn) => {
+      cases.forEach(testCase => {
+        const args = Array.isArray(testCase) ? testCase : [testCase];
+        this.test(this.#formatDescription(args, description), () => fn(...args));
+      });
+    };
+  }
+
+  beforeEach(fn) {
+    this.#beforeEachArr.push(fn);
+  }
+
   getTests() {
     return [...this.#tests];
   }
@@ -26,5 +49,24 @@ export class Tests {
   clearTests() {
     this.#tests = [];
     this.#testDepth = [];
+    this.#beforeEachArr = [];
+  }
+
+  #formatDescription(args, description) {
+    let argIndex = 0;
+    return description.replace(/%([so])/g, (match, type) => {
+      if (argIndex >= args.length) return match;
+
+      const arg = args[argIndex++];
+
+      switch (type) {
+        case 's':
+          return arg;
+        case 'o':
+          return JSON.stringify(arg);
+        default:
+          return match;
+      }
+    });
   }
 }