@dannysir/js-te 0.0.1

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025 dannysir
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,267 @@
+# js-te
+
+Jest에서 영감을 받아 만든 가벼운 JavaScript 테스트 프레임워크입니다.
+
+## 설치
+
+```bash
+npm install --save-dev js-te
+```
+
+## 빠른 시작
+
+### 1. 테스트 파일 만들기
+
+`*.test.js` 파일을 만들면 자동으로 찾아서 실행합니다.
+
+별도의 import문 없이 `describe`와 `test`, `expect` 로직이 사용 가능합니다. 
+
+```javascript
+// math.test.js
+describe('[단순 연산 테스트]', () => {
+  test('더하기 테스트', () => {
+    expect(1 + 2).toBe(3);
+  });
+});
+```
+
+### 2. 테스트 실행
+
+package.json에 추가:
+
+```json
+{
+  "scripts": {
+    "test": "js-te"
+  }
+}
+```
+
+실행:
+```bash
+npm test
+```
+
+
+# API
+
+## 테스트 작성
+
+### `test(설명, 함수)`
+
+테스트 하나를 정의합니다.
+
+```javascript
+test('배열 길이 확인', () => {
+  expect([1, 2, 3].length).toBe(3);
+});
+```
+
+#### `describe(이름, 함수)`
+
+테스트를 그룹으로 묶습니다. 중첩도 됩니다.
+
+```javascript
+describe('계산기', () => {
+  describe('더하기', () => {
+    test('양수 더하기', () => {
+      expect(2 + 3).toBe(5);
+    });
+  });
+  
+  describe('빼기', () => {
+    test('양수 빼기', () => {
+      expect(5 - 3).toBe(2);
+    });
+  });
+});
+```
+
+## Matcher
+
+### `expect(값).toBe(기댓값)`
+
+`===`로 비교합니다. 숫자, 문자열 같은 원시값 비교할 때 사용.
+
+```javascript
+expect(5).toBe(5);
+expect('안녕').toBe('안녕');
+```
+
+### `expect(값).toEqual(기댓값)`
+
+객체나 배열의 내용을 비교합니다.
+
+```javascript
+expect({ name: '철수' }).toEqual({ name: '철수' });
+expect([1, 2, 3]).toEqual([1, 2, 3]);
+```
+
+### `expect(함수).toThrow(에러메시지)`
+
+함수가 에러를 던지는지 확인합니다.
+
+```javascript
+expect(() => {
+  throw new Error('에러 발생');
+}).toThrow('에러');
+```
+
+### `expect(값).toBeTruthy()` / `expect(값).toBeFalsy()`
+
+참/거짓 여부를 확인합니다.
+
+```javascript
+expect(true).toBeTruthy();
+expect(0).toBeFalsy();
+```
+
+## Mocking
+
+### 동작 원리
+
+Babel을 사용해서 import 구문을 변환하여 mock 함수를 가져오도록 했습니다.
+
+1. 테스트 파일 찾기
+   1. `mock(path, mockObj)` 선언 확인
+   2. `path`를 key로 이용해 Map에 저장
+2. Babel로 코드 변환
+   1. 전체 파일의 import문 확인
+   2. import 경로가 Map에 존재하면 mock 객체로 변환
+   3. import 경로가 Map에 없다면 그대로 import
+3. 테스트 실행
+4. 원본 파일 복구
+
+### 🚨 주의 사항 (현재 수정 중)
+
+mocking 기능의 경우 현재 `path`를 기반으로 직접 변환을 하기 때문에 mocking이 필요한 함수의 경우 
+
+반드시 **절대 경로**로 표현한 후 `mock` 함수에 **절대 경로**로 등록을 해주세요.
+
+> 만약 모듈이 사용되는 모든 위치의 path가 동일하다면 상대 경로도 정삭 작동합니다.
+
+### `mock(모듈경로, mock객체)`
+
+모듈을 모킹합니다. import 하기 **전에** 호출해야 합니다.
+
+```javascript
+// random.js
+export const random = () => Math.random();
+
+// game.js
+import { random } from './random.js';
+export const play = () => random() * 10;
+
+// game.test.js
+import { mock, test, expect } from 'js-te';
+
+test('랜덤 함수 모킹', async () => {
+  // 1. 먼저 모킹
+  mock('./random.js', {
+    random: () => 0.5
+  });
+  
+  // 2. 그 다음 import
+  const { play } = await import('./game.js');
+  
+  // 3. 모킹된 값 사용
+  expect(play()).toBe(5);
+});
+```
+
+### `clearAllMocks()`
+
+등록된 모든 mock을 제거합니다.
+
+### `unmock(모듈경로)`
+
+특정 mock만 제거합니다.
+
+### `isMocked(모듈경로)`
+
+mock이 등록되어 있는지 확인합니다.
+
+## 테스트 파일 찾기 규칙
+
+자동으로 다음 파일들을 찾아서 실행합니다:
+
+1. `*.test.js` 파일
+2. `test/` 폴더 안의 모든 `.js` 파일
+
+```
+프로젝트/
+├── src/
+│   ├── utils.js
+│   └── utils.test.js       ✅
+├── test/
+│   ├── integration.js      ✅
+│   └── e2e.js              ✅
+└── calculator.test.js      ✅
+```
+
+## 예제
+
+### 기본 테스트
+
+```javascript
+import { describe, test, expect } from 'js-te';
+
+describe('문자열 테스트', () => {
+  test('문자열 합치기', () => {
+    const result = 'hello' + ' ' + 'world';
+    expect(result).toBe('hello world');
+  });
+  
+  test('대문자 변환', () => {
+    expect('hello'.toUpperCase()).toBe('HELLO');
+  });
+});
+```
+
+### 모킹 예제
+
+```javascript
+// mocking.test.js
+import { mock, test, expect } from 'js-te';
+
+test('[mocking] - mocking random function', async () => {
+  mock('/src/test-helper/random.js', {
+    random: () => 3,
+  });
+  const {play} = await import('../src/test-helper/game.js');
+  expect(play()).toBe(30);
+});
+
+
+// game.js
+import {random} from '/src/test-helper/random.js'
+
+export const play = () => {
+  return random() * 10;
+};
+
+// random.js
+export const random = () => Math.random();
+```
+
+## 설정
+
+`package.json`에 해당 설정을 하셔야 정상 작동합니다.
+
+```json
+{
+  "type": "module"
+}
+```
+
+## 링크
+
+- [GitHub](https://github.com/dannysir/Js-Te)
+
+## 만든 이유
+
+우아한테크코스 과제하면서 Jest 써보고 테스트 프레임워크가 어떻게 동작하는지 궁금해서 만들어봤습니다.
+
+## 라이선스
+
+ISC

package/babelTransformImport.js

@@ -0,0 +1,80 @@
+export const babelTransformImport = ({types: t}) => {
+  return {
+    visitor: {
+      Program(path) {
+        const importStatement = t.ImportDeclaration(
+          [t.importSpecifier(
+            t.identifier('__mockRegistry__'),
+            t.identifier('__mockRegistry__')
+          )],
+          t.stringLiteral('js-te/src/mock/store.js')
+        );
+        path.node.body.unshift(importStatement);
+      },
+
+      ImportDeclaration(path) {
+        const source = path.node.source.value;
+
+        if (source === 'js-te/src/mock/store.js') {
+          return;
+        }
+
+        const specifiers = path.node.specifiers;
+
+        // 1. 먼저 모듈을 한 번만 가져오기 (mock이면 mock, 아니면 실제)
+        const moduleVarName = path.scope.generateUidIdentifier('module');
+
+        const moduleDeclaration = t.variableDeclaration('const', [
+          t.variableDeclarator(
+            moduleVarName,
+            t.conditionalExpression(
+              // 조건: __mockRegistry__.has(source)
+              t.callExpression(
+                t.memberExpression(t.identifier('__mockRegistry__'), t.identifier('has')),
+                [t.stringLiteral(source)]
+              ),
+              // true: mock 반환
+              t.callExpression(
+                t.memberExpression(t.identifier('__mockRegistry__'), t.identifier('get')),
+                [t.stringLiteral(source)]
+              ),
+              // false: 실제 import
+              t.awaitExpression(
+                t.importExpression(t.stringLiteral(source))
+              )
+            )
+          )
+        ]);
+
+        // 2. 각 specifier를 moduleVarName에서 추출
+        const extractDeclarations = specifiers.map(spec => {
+          let importedName, localName;
+
+          if (t.isImportDefaultSpecifier(spec)) {
+            importedName = 'default';
+            localName = spec.local.name;
+          } else if (t.isImportNamespaceSpecifier(spec)) {
+            localName = spec.local.name;
+            // namespace import는 전체 모듈
+            return t.variableDeclarator(
+              t.identifier(localName),
+              moduleVarName
+            );
+          } else {
+            importedName = spec.imported.name;
+            localName = spec.local.name;
+          }
+
+          return t.variableDeclarator(
+            t.identifier(localName),
+            t.memberExpression(moduleVarName, t.identifier(importedName))
+          );
+        });
+
+        const extractDeclaration = t.variableDeclaration('const', extractDeclarations);
+
+        path.replaceWithMultiple([moduleDeclaration, extractDeclaration]);
+      }
+    }
+  };
+};

package/bin/cli.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+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 {getTestResultMsg} from "../utils/makeMessage.js";
+import {RESULT_TITLE} from "../constants.js";
+import { babelTransformImport } from '../babelTransformImport.js';
+
+let totalPassed = 0;
+let totalFailed = 0;
+const originalFiles = new Map();
+
+Object.keys(jsTe).forEach(key => {
+  global[key] = jsTe[key];
+});
+
+const transformFile = (filePath) => {
+  const originalCode = fs.readFileSync(filePath, 'utf-8');
+  originalFiles.set(filePath, originalCode);
+
+  const transformed = transformSync(originalCode, {
+    filename: filePath,
+    plugins: [babelTransformImport],
+    parserOpts: {
+      sourceType: 'module',
+      plugins: ['dynamicImport']
+    }
+  });
+
+  fs.writeFileSync(filePath, transformed.code);
+};
+
+const restoreFiles = () => {
+  for (const [filePath, originalCode] of originalFiles.entries()) {
+    fs.writeFileSync(filePath, originalCode);
+  }
+};
+
+const findTestFiles = (dir) => {
+  const files = [];
+
+  const walk = (directory, inTestDir = false) => {
+    const items = fs.readdirSync(directory);
+    const dirName = path.basename(directory);
+
+    const isTestDir = dirName === 'test' || inTestDir;
+
+    for (const item of items) {
+      if (item === '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')) {
+          files.push(fullPath);
+        }
+      }
+    }
+  }
+
+  walk(dir);
+  return files;
+}
+
+const findAllSourceFiles = (dir) => {
+  const files = [];
+
+  const walk = (directory) => {
+    const items = fs.readdirSync(directory);
+
+    for (const item of items) {
+      if (item === 'node_modules' || item === 'bin' || item === 'test') 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')) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  walk(dir);
+  return files;
+}
+
+const sourceFiles = findAllSourceFiles(process.cwd());
+
+for (const file of sourceFiles) {
+  transformFile(file);
+}
+
+const testFiles = findTestFiles(process.cwd());
+
+console.log(`\nFound ${green(testFiles.length)} test file(s)`);
+
+for (const file of testFiles) {
+  console.log(`\n${yellow(file)}\n`);
+
+  transformFile(file);
+
+  await import(path.resolve(file));
+
+  const {passed, failed} = await jsTe.run();
+  totalPassed += passed;
+  totalFailed += failed;
+}
+
+restoreFiles();
+
+console.log(getTestResultMsg(RESULT_TITLE.TOTAL, totalPassed, totalFailed));
+
+if (totalFailed > 0) {
+  process.exit(1);
+}

package/constants.js

@@ -0,0 +1,28 @@
+export const getErrorMsg = (expect, actual) => {
+  return `Expected ${JSON.stringify(expect)} but got ${JSON.stringify(actual)}`;
+};
+
+export const RESULT_TITLE = {
+  TESTS: 'Tests: ',
+  TOTAL : 'Total Result: '
+};
+
+export const CHECK = '✓ ';
+
+export const CROSS = '✗ ';
+
+export const DIRECTORY_DELIMITER = ' > ';
+
+export const EMPTY = '';
+
+export const DEFAULT_COUNT = 0;
+
+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/index.js

@@ -0,0 +1,89 @@
+import {
+  CHECK,
+  CROSS, DEFAULT_COUNT, DIRECTORY_DELIMITER, EMPTY,
+  getErrorMsg, RESULT_TITLE,
+} from "./constants.js";
+import {Tests} from "./src/tests.js";
+import {green, red} from "./utils/consoleColor.js";
+import {getTestResultMsg} from "./utils/makeMessage.js";
+
+const tests = new Tests();
+
+export { mock, clearAllMocks, unmock, isMocked } from './src/mock/store.js';
+
+export const test = (description, fn) => tests.test(description, fn);
+
+export const describe = (suiteName, fn) => tests.describe(suiteName, fn);
+
+export const expect = (actual) => {
+  let value = actual;
+
+  const runArgFnc = (actual) => {
+    let value = actual;
+    if (typeof actual === 'function') {
+      value = actual();
+    }
+    return value;
+  };
+
+  return {
+    toBe(expected) {
+      value = runArgFnc(actual);
+      if (value !== expected) {
+        throw new Error(getErrorMsg(expected, value));
+      }
+    },
+    toEqual(expected) {
+      value = runArgFnc(actual);
+      if (JSON.stringify(value) !== JSON.stringify(expected)) {
+        throw new Error(getErrorMsg(expected, value));
+      }
+    },
+    toThrow(expected) {
+      try {
+        value = runArgFnc(actual);
+      } catch (e) {
+        if (!e.message.includes(expected)) {
+          throw new Error(getErrorMsg(expected, e.message));
+        } else return;
+      }
+    },
+    toBeTruthy() {
+      value = runArgFnc(actual);
+      if (!value) {
+        throw new Error(getErrorMsg(true, value));
+      }
+    },
+    toBeFalsy() {
+      value = runArgFnc(actual);
+      if (value) {
+        throw new Error(getErrorMsg(true, value));
+      }
+    },
+  };
+}
+
+export const run = async () => {
+  let passed = DEFAULT_COUNT;
+  let failed = DEFAULT_COUNT;
+
+  for (const test of tests.getTests()) {
+    try {
+      await test.fn();
+      const directoryString = green(CHECK) + (test.path === '' ? EMPTY : test.path + DIRECTORY_DELIMITER) + test.description
+      console.log(directoryString);
+      passed++;
+    } catch (error) {
+      const errorDirectory = red(CROSS) + test.path + test.description
+      console.log(errorDirectory);
+      console.log(red(`  ${error.message}`));
+      failed++;
+    }
+  }
+
+  console.log(getTestResultMsg(RESULT_TITLE.TESTS, passed, failed));
+
+  tests.clearTests();
+
+  return {passed, failed};
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@dannysir/js-te",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "JavaScript test library",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./src/mock/store.js": "./src/mock/store.js"
+  },
+  "bin": {
+    "js-te": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "node bin/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dannysir/Js-Te.git"
+  },
+  "keywords": [
+    "javascript",
+    "test",
+    "testing",
+    "jest",
+    "mocking"
+  ],
+  "files": [
+    "bin/",
+    "src/tests.js",
+    "src/mock",
+    "utils/",
+    "index.js",
+    "constants.js",
+    "babelTransformImport.js"
+  ],
+  "author": "dannysir",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/dannysir/Js-Te/issues"
+  },
+  "homepage": "https://github.com/dannysir/Js-Te#readme",
+  "dependencies": {
+    "@babel/core": "^7.28.5",
+    "@babel/generator": "^7.28.5",
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5"
+  }
+}

package/src/mock/store.js

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

package/src/tests.js

@@ -0,0 +1,30 @@
+import {DIRECTORY_DELIMITER} from "../constants.js";
+
+export class Tests {
+  #tests = [];
+  #testDepth = [];
+
+  describe(str, fn) {
+    this.#testDepth.push(str);
+    fn();
+    this.#testDepth.pop();
+  }
+
+  test(description, fn) {
+    const testObj = {
+      description,
+      fn,
+      path: this.#testDepth.join(DIRECTORY_DELIMITER),
+    }
+    this.#tests.push(testObj);
+  }
+
+  getTests() {
+    return [...this.#tests];
+  }
+
+  clearTests() {
+    this.#tests = [];
+    this.#testDepth = [];
+  }
+}

package/utils/consoleColor.js

@@ -0,0 +1,8 @@
+import {COLORS} from "../constants.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);

package/utils/makeMessage.js

@@ -0,0 +1,14 @@
+import {bold, green, red} from "./consoleColor.js";
+
+export const getTestResultMsg = (title, success, fail) => {
+  let msg = '\n';
+
+  msg += title;
+  msg += green(success + ' passed') + ', ';
+  if (fail) {
+    msg += red(fail + ' failed') + ', ';
+  }
+  msg += bold(success + fail + ' total');
+
+  return msg;
+};