@dannysir/js-te 0.3.0 → 0.3.2

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

@@ -1,14 +1,14 @@
-import {CHECK, CROSS, DIRECTORY_DELIMITER, EMPTY} from "../constants.js";
 import {green, red} from "./consoleColor.js";
+import {RESULT_MSG} from "../constants/index.js";
 
 export const formatSuccessMessage = (test) => {
-  const pathString = test.path === '' ? EMPTY : test.path + DIRECTORY_DELIMITER;
-  return green(CHECK) + pathString + test.description;
+  const pathString = test.path === '' ? RESULT_MSG.EMPTY : test.path + RESULT_MSG.DIRECTORY_DELIMITER;
+  return green(RESULT_MSG.CHECK) + pathString + test.description;
 };
 
 export const formatFailureMessage = (test, error) => {
   const messages = [];
-  messages.push(red(CROSS) + test.path + test.description);
+  messages.push(red(RESULT_MSG.CROSS) + test.path + test.description);
   messages.push(red(`  Error Message : ${error.message}`));
   return messages.join('\n');
 };
@@ -16,6 +16,16 @@ export const formatFailureMessage = (test, error) => {
 export const getErrorMsg = (expect, actual) => {
   return `Expected ${JSON.stringify(expect)} but got ${JSON.stringify(actual)}`;
 };
+
 export const getThrowErrorMsg = (expect) => {
   return `Expected function to throw an error containing "${expect}", but it did not throw`;
-};
+};
+
+export const placeHolder = {
+  's': (value) => value,
+  'o': (value) => JSON.stringify(value),
+};
+
+export const getMatcherForReplace = () => {
+  return new RegExp(`%([${Object.keys(placeHolder).join('')}])`, 'g')
+};

package/src/utils/messages.js

@@ -0,0 +1,26 @@
+import {bold, green, red, yellow} 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;
+};
+
+export const getFileCountString = (n) => {
+  return `\nFound ${green(n)} test file(s)`;
+};
+
+export const getFilePath = (path) => {
+  return `\n${yellow(path)}\n`;
+};
+
+export const getErrorMsgInLogic = (error) => {
+  return red(`\n✗ Test execution failed\n  Error: ${error}\n`)
+};

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

@@ -1,11 +1,16 @@
 import fs from 'fs';
 import {transformSync} from "@babel/core";
-import {babelTransformImport} from "../../babelTransformImport.js";
-import {BABEL} from "../../constants.js";
-import {red} from "../../utils/consoleColor.js";
+import {babelTransformImport} from "../babelPlugins/babelTransformImport.js";
+import {red} from "./consoleColor.js";
+import {BABEL} from "../constants/babel.js";
 
 const originalFiles = new Map();
 
+/**
+ * 파일의 import/require문을 변경하는 함수입니다.
+ * @param {string} filePath - 파일 절대 경로
+ * @param {Set} mockPath - 모킹한 파일 저장소
+ */
 export const transformFiles = (filePath, mockPath) => {
   const originalCode = fs.readFileSync(filePath, 'utf-8');
   originalFiles.set(filePath, originalCode);
@@ -31,4 +36,4 @@ export const restoreFiles = () => {
     }
   }
   originalFiles.clear();
-};
+};

package/babelTransformImport.js

@@ -1,317 +0,0 @@
-import path from 'path';
-import {BABEL, MOCK} from "./constants.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 currentDir = path.dirname(currentFilePath);
-
-          let absolutePath;
-          if (source.startsWith(BABEL.PERIOD)) {
-            absolutePath = path.resolve(currentDir, source);
-          } else {
-            absolutePath = source;
-          }
-
-          if (mockedPaths && !mockedPaths.has(absolutePath)) {
-            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 = t.variableDeclaration(BABEL.CONST, [
-            t.variableDeclarator(
-              originalVarName,
-              t.awaitExpression(
-                t.importExpression(t.stringLiteral(source))
-              )
-            )
-          ]);
-
-          const wrapperDeclarations = 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;
-              return t.variableDeclarator(
-                t.identifier(localName),
-                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
-                )
-              );
-            } else {
-              importedName = spec.imported.name;
-              localName = spec.local.name;
-            }
-
-            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),
-                      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
-                      )
-                    )
-                  ]),
-                  t.returnStatement(
-                    t.callExpression(
-                      t.memberExpression(t.identifier(BABEL.MODULE), t.identifier(importedName)),
-                      [t.spreadElement(t.identifier('args'))]
-                    )
-                  )
-                ])
-              )
-            );
-          });
-
-          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 init = declarator.init;
-
-            if (!init ||
-              !t.isCallExpression(init) ||
-              !t.isIdentifier(init.callee, {name: 'require'}) ||
-              !init.arguments[0] ||
-              !t.isStringLiteral(init.arguments[0])) {
-              newDeclarations.push(declarator);
-              continue;
-            }
-
-            const source = init.arguments[0].value;
-            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;
-            }
-
-            if (mockedPaths && !mockedPaths.has(absolutePath)) {
-              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(
-                  t.variableDeclarator(
-                    t.identifier(localName),
-                    t.arrowFunctionExpression(
-                      [t.restElement(t.identifier('args'))],
-                      t.blockStatement([
-                        t.variableDeclaration(BABEL.CONST, [
-                          t.variableDeclarator(
-                            t.identifier(BABEL.MODULE),
-                            t.conditionalExpression(
-                              t.callExpression(
-                                t.memberExpression(
-                                  t.identifier(MOCK.STORE_NAME),
-                                  t.identifier(BABEL.HAS)
-                                ),
-                                [t.stringLiteral(absolutePath)]
-                              ),
-                              t.objectExpression([
-                                t.spreadElement(originalVar),
-                                t.spreadElement(
-                                  t.callExpression(
-                                    t.memberExpression(
-                                      t.identifier(MOCK.STORE_NAME),
-                                      t.identifier(BABEL.GET)
-                                    ),
-                                    [t.stringLiteral(absolutePath)]
-                                  )
-                                )
-                              ]),
-                              originalVar
-                            )
-                          )
-                        ]),
-                        t.returnStatement(
-                          t.callExpression(
-                            t.memberExpression(
-                              t.identifier(BABEL.MODULE),
-                              t.identifier(key)
-                            ),
-                            [t.spreadElement(t.identifier('args'))]
-                          )
-                        )
-                      ])
-                    )
-                  )
-                );
-              });
-            } else {
-              newDeclarations.push(
-                t.variableDeclarator(
-                  declarator.id,
-                  t.arrowFunctionExpression(
-                    [t.restElement(t.identifier('args'))],
-                    t.blockStatement([
-                      t.variableDeclaration(BABEL.CONST, [
-                        t.variableDeclarator(
-                          t.identifier(BABEL.MODULE),
-                          t.conditionalExpression(
-                            t.callExpression(
-                              t.memberExpression(
-                                t.identifier(MOCK.STORE_NAME),
-                                t.identifier(BABEL.HAS)
-                              ),
-                              [t.stringLiteral(absolutePath)]
-                            ),
-                            t.objectExpression([
-                              t.spreadElement(originalVar),
-                              t.spreadElement(
-                                t.callExpression(
-                                  t.memberExpression(
-                                    t.identifier(MOCK.STORE_NAME),
-                                    t.identifier(BABEL.GET)
-                                  ),
-                                  [t.stringLiteral(absolutePath)]
-                                )
-                              )
-                            ]),
-                            originalVar
-                          )
-                        )
-                      ]),
-                      t.returnStatement(
-                        t.callExpression(
-                          t.memberExpression(
-                            t.identifier(BABEL.MODULE),
-                            t.identifier('default')
-                          ),
-                          [t.spreadElement(t.identifier('args'))]
-                        )
-                      )
-                    ])
-                  )
-                )
-              );
-            }
-          }
-
-          if (hasTransformation) {
-            nodePath.node.declarations = newDeclarations;
-            nodePath.node._transformed = true;
-          }
-        }
-      }
-    };
-  }
-};

package/constants.js

@@ -1,46 +0,0 @@
-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'
-};
-
-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',
-  DIST: 'dist',
-};

package/src/testRunner.js

@@ -1,28 +0,0 @@
-import {DEFAULT_COUNT, RESULT_TITLE} from "../constants.js";
-import {testManager} from "./testManager.js";
-import {formatFailureMessage, formatSuccessMessage} from "../utils/formatString.js";
-import {getTestResultMsg} from "../utils/makeMessage.js";
-import {clearAllMocks} from "./mock/store.js";
-
-export const run = async () => {
-  let passed = DEFAULT_COUNT;
-  let failed = DEFAULT_COUNT;
-
-  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_TITLE.TESTS, passed, failed));
-
-  testManager.clearTests();
-
-  return {passed, failed};
-};

package/utils/makeMessage.js

@@ -1,14 +0,0 @@
-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;
-};