feat: local mocking in node (#324)

* feat: local mocking in node
You now have a global mock function available e.g
const [FancySpan] = aw.mock([["**/react/src/button.js", "() => (<span>hhhhh</span>)"]], ["../src/fancy-button"]);
which can be used locally in your test file

* chore: cleanup lint

Author: stoffeastrom

.eslintrc.json

@@ -39,7 +39,22 @@
         ]
       }
     ],
-    "react/prefer-stateless-function": 0
+    "react/prefer-stateless-function": 0,
+    "no-restricted-syntax": 0,
+    "global-require": 0,
+    "import/no-dynamic-require": 0,
+    "no-unused-expressions": 0,
+    "no-underscore-dangle": 0,
+    "class-methods-use-this": 0,
+    "prefer-const": ["error", { "destructuring": "all" }],
+    "max-len": 0,
+    "no-param-reassign": 0,
+    "no-console": 0,
+    "no-bitwise": 0,
+    "radix": 0,
+    "no-plusplus": 0,
+    "no-new": 0,
+    "import/no-unresolved": 0
   },
   "extends": [
     "airbnb"

appveyor.yml

@@ -15,7 +15,6 @@ install:
   - npm --version
   # install modules
   - npm install
-  - npm run bootstrap -- --no-ci
 
 # Post-install test scripts.
 test_script:

aw.config.js

@@ -1,5 +1,3 @@
-/* eslint import/no-extraneous-dependencies: 0, prefer-destructuring: 0, no-param-reassign: 0, no-unused-expressions: 0, max-len: 0 */
-
 const yargs = require('yargs');
 const path = require('path');
 const globby = require('globby');
@@ -22,7 +20,7 @@ yargs
   .coerce('scope', (scope) => {
     const scopes = new Map();
     globby.sync(packages.map(p => `${p}/package.json`)).forEach((p) => {
-      const { name } = require(`./${p}`); //eslint-disable-line
+      const { name } = require(`./${p}`);
       const pkgPath = path.dirname(p);
       scopes.set(name, pkgPath);
     });

commands-common/register/package.json

@@ -21,10 +21,12 @@
   "homepage": "https://github.com/qlik-oss/after-work.js#readme",
   "dependencies": {
     "@after-work.js/transform": "^5.0.0-beta.5",
+    "@after-work.js/utils": "^5.0.0-beta.5",
     "find-cache-dir": "2.0.0",
     "import-cwd": "2.1.0",
     "minimatch": "3.0.4",
     "pirates": "4.0.0",
+    "require-from-string": "2.0.2",
     "source-map-support": "0.5.8"
   },
   "files": [

commands-common/register/src/index.js

@@ -1,14 +1,16 @@
-/* eslint global-require: 0, import/no-dynamic-require: 0 */
+/* global aw */
 
 const path = require('path');
 const fs = require('fs');
 const { addHook } = require('pirates');
 const sourceMapSupport = require('source-map-support');
-const { transformFile, getTransform } = require('@after-work.js/transform');
+const { transformFile, getTransform, deleteTransform } = require('@after-work.js/transform');
 const minimatch = require('minimatch');
 const mod = require('module');
+const requireFromString = require('require-from-string');
+const utils = require('@after-work.js/utils');
 
-const originLoader = mod._load; //eslint-disable-line
+const originLoader = mod._load;
 let removeCompileHook = () => { };
 let removeLoadHook = () => { };
 
@@ -39,32 +41,39 @@ function compileHook(argv, code, filename, virtualMock = false) {
   return transformFile(filename, newArgv, code);
 }
 
-function compile(value, filename, options) {
-  const Module = module.constructor;
-  const m = new Module();
+function compile(value, filename, options, injectReact) {
   let src;
-  let virtualMock = false;
   if (fs.existsSync(value)) {
     src = fs.readFileSync(value, 'utf8');
   } else {
-    virtualMock = true;
-    src = `export default ${value}`;
+    src = `${injectReact ? 'import React from "react";\n' : ''}export default ${value}`;
   }
-  src = compileHook(options, src, filename, virtualMock);
-  m._compile(src, filename); //eslint-disable-line
-  return m.exports;
+  src = compileHook(options, src, filename, true);
+  return requireFromString(src);
 }
 
 function hookedLoader(options, request, parent, isMain) {
   let filename;
   try {
-    filename = mod._resolveFilename(request, parent); // eslint-disable-line
+    filename = mod._resolveFilename(request, parent);
   } catch (err) {
     filename = request;
   }
 
-  for (const item of options.mocks ||  []) { // eslint-disable-line
-    let [key, value] = item; //eslint-disable-line
+  // Explicit mocks in modules e.g aw.mock(...)
+  for (let [key, [value, injectReact]] of aw.mocks) {
+    if (minimatch(filename, key)) {
+      if (value === undefined && fs.existsSync(filename)) {
+        const src = fs.readFileSync(filename, 'utf8');
+        value = `${JSON.stringify(src)}`;
+      }
+      return compile(value, filename, options, injectReact);
+    }
+  }
+
+  // Global config mocks
+  for (const item of options.mocks || []) {
+    let [key, value] = item;
     if (minimatch(filename, key)) {
       if (value === undefined && fs.existsSync(filename)) {
         const src = fs.readFileSync(filename, 'utf8');
@@ -78,9 +87,9 @@ function hookedLoader(options, request, parent, isMain) {
 
 function addLoadHook(options) {
   const loadHook = hookedLoader.bind(null, options);
-  mod._load = loadHook; //eslint-disable-line
+  mod._load = loadHook;
   return () => {
-    mod._load = originLoader; //eslint-disable-line
+    mod._load = originLoader;
   };
 }
 
@@ -106,7 +115,48 @@ function installSourceMapSupport() {
   sourceMapSupportInstalled = true;
 }
 
-module.exports = function register(options = {}) {
+class AW {
+  constructor(srcFiles, testFiles) {
+    this.srcFiles = srcFiles;
+    this.testFiles = testFiles;
+    this.mocks = new Map();
+  }
+
+  canInjectReact() {
+    try {
+      require.resolve('react');
+    } catch (_) {
+      return false;
+    }
+    return true;
+  }
+
+  mock(mocks, reqs) {
+    const injectReact = this.canInjectReact();
+    mocks.forEach(([key, value]) => this.mocks.set(key, [value, injectReact]));
+    const [filename] = utils.getCurrentFilenameStackInfo(this.testFiles);
+    const deps = utils.getAllDependencies(this.srcFiles, filename);
+    deps.forEach((d) => {
+      utils.safeDeleteCache(d);
+    });
+
+    const mods = reqs.map((r) => {
+      const p = require.resolve(path.resolve(path.dirname(filename), r));
+      const m = require(p);
+      return m.__esModule && m.default ? m.default : m;
+    });
+
+    mocks.forEach(([key]) => this.mocks.delete(key));
+    deps.forEach((d) => {
+      utils.safeDeleteCache(d);
+      deleteTransform(d);
+    });
+    return mods;
+  }
+}
+
+module.exports = function register(options = {}, srcFiles, testFiles) {
+  global.aw = new AW(srcFiles, testFiles);
   installSourceMapSupport();
   removeCompileHook();
   removeLoadHook();

commands-common/transform-middleware/src/index.js

@@ -8,7 +8,7 @@ module.exports = function transform(argv) {
     if (ctx.url.length && ctx.url.startsWith('/')) {
       url = ctx.url.substring(1);
     }
-    const shouldInstrument = argv.coverage && argv.instrument && argv.instrument.testExclude.shouldInstrument(url); //eslint-disable-line
+    const shouldInstrument = argv.coverage && argv.instrument && argv.instrument.testExclude.shouldInstrument(url);
     const shouldTransform = argv.transform && argv.transform.testExclude.shouldInstrument(url);
 
     if (shouldInstrument || shouldTransform) {

commands-common/transform/src/file-cache.js

@@ -38,10 +38,11 @@ class FileCache {
       instrument,
       transform,
     } = options;
-    transformItem.hash = this.getCacheHash(filename, { ...babelOptions, ...instrument, ...transform }); // eslint-disable-line no-param-reassign
-    if (!virtualMock) {
-      transformItem.mtime = +fs.statSync(filename).mtime; // eslint-disable-line no-param-reassign
+    transformItem.hash = this.getCacheHash(filename, { ...babelOptions, ...instrument, ...transform });
+    if (virtualMock) {
+      return;
     }
+    transformItem.mtime = +fs.statSync(filename).mtime;
     this.transform.set(filename, transformItem);
     this.safeSaveCacheSync(filename);
   }
@@ -92,7 +93,7 @@ class FileCache {
       const gz = zlib.gzipSync(str);
       fs.writeFileSync(this.getCacheFilename(filename), gz, 'utf8');
     } catch (err) {
-      console.log(err); // eslint-disable-line no-console
+      console.log(err);
     }
   }
 }

commands-common/transform/src/index.js

@@ -30,7 +30,7 @@ function transformTypescript(filePath, sourceRoot, tsContent, argv) {
   }
   const transpileOpts = { fileName, compilerOptions };
   const res = typescript.transpileModule(tsContent, transpileOpts);
-  tsContent = res.outputText; // eslint-disable-line no-param-reassign
+  tsContent = res.outputText;
   let tsBabelOpts = {
     sourceMaps: 'both',
   };
@@ -48,21 +48,21 @@ function transformFile(filename, argv, content = null) {
     return cachedTransform.map;
   }
   if (!content) {
-    filename = ensureFilePath(filename); // eslint-disable-line no-param-reassign
+    filename = ensureFilePath(filename);
     const cachedTransform = fileCache.getSync(filename, argv);
     if (cachedTransform) {
       return cachedTransform.code;
     }
-    content = fs.readFileSync(filename, 'utf8'); // eslint-disable-line no-param-reassign
+    content = fs.readFileSync(filename, 'utf8');
   }
   const cachedTransform = fileCache.getSync(filename, argv);
   if (cachedTransform) {
     return cachedTransform.code;
   }
   let babelOpts = getBabelOpts(filename, argv);
   if (isTypescript(filename)) {
-    const { tsContent, tsBabelOpts } = transformTypescript(filename, babelOpts.sourceRoot, content, argv); // eslint-disable-line
-    content = tsContent; // eslint-disable-line no-param-reassign
+    const { tsContent, tsBabelOpts } = transformTypescript(filename, babelOpts.sourceRoot, content, argv);
+    content = tsContent;
     babelOpts = Object.assign({}, babelOpts, tsBabelOpts);
   }
   babelOpts.ast = false;

commands-common/utils/src/index.js

@@ -1,4 +1,6 @@
+/* eslint max-len: 0, import/no-dynamic-require: 0, global-require: 0 */
 const fs = require('fs');
+const path = require('path');
 const readline = require('readline');
 const importCwd = require('import-cwd');
 
@@ -48,7 +50,7 @@ const utils = {
     let found = importCwd.silent(name);
     if (!found) {
       try {
-        found = require(name); // eslint-disable-line
+        found = require(name);
       } catch (err) {
         found = null;
       }
@@ -57,7 +59,7 @@ const utils = {
   },
   coerceBabel(opt) {
     if (opt.enable && opt.core && typeof opt.core === 'string') {
-      opt.babel = importCwd(opt.core); // eslint-disable-line no-param-reassign
+      opt.babel = importCwd(opt.core);
     } else if (opt.enable && !opt.core) {
       let core = utils.safeGetModule('@babel/core');
       if (!core) {
@@ -66,16 +68,82 @@ const utils = {
           throw new Error('Can not get babel core module');
         }
       }
-      opt.babel = core; // eslint-disable-line no-param-reassign
+      opt.babel = core;
     }
     if (typeof opt.babelPluginIstanbul === 'string') {
-      opt.babelPluginIstanbul = importCwd(opt.babelPluginIstanbul).default; // eslint-disable-line no-param-reassign, max-len
+      opt.babelPluginIstanbul = importCwd(opt.babelPluginIstanbul).default;
     }
     if (typeof opt.typescript === 'string') {
-      opt.typescript = importCwd.silent(opt.typescript); // eslint-disable-line no-param-reassign
+      opt.typescript = importCwd.silent(opt.typescript);
     }
     return opt;
   },
+  getCurrentFilenameStackInfo(testFiles) {
+    // Magically figure out the current test from the stack trace (callsites not working with sourcemaps)
+    const s = new Error().stack
+      .split('\n')
+      .slice(1)
+      .map(c => c.split(/\(([^)]+)\)/)[1])
+      .filter(c => c !== undefined)
+      .map((c) => {
+        const parts = c.split(':');
+        const columnno = parts.pop();
+        const lineno = parts.pop();
+        const filename = path.resolve(parts.join(':'));
+        return [filename, lineno, columnno];
+      })
+      .filter(([filename]) => testFiles.indexOf(filename) !== -1);
+    if (!s.length) {
+      throw new Error('Can not find test file');
+    }
+    return s.shift();
+  },
+  safeDeleteCache(f) {
+    if (require.cache[f]) {
+      delete require.cache[f];
+    }
+  },
+  safeRequireCache(f) {
+    try {
+      require(f);
+      return require.cache[f];
+    } catch (_) { } //eslint-disable-line
+    return { children: [] };
+  },
+  matchDependency(found, testName) {
+    let use = found;
+    if (found.length > 1) {
+      const matchName = found.filter(id => path.basename(id).split('.').shift() === testName);
+      if (matchName.length === 1) {
+        use = matchName;
+      } else {
+        use = found.splice(0, 1);
+      }
+    }
+    return use;
+  },
+  getDependencies(files, file) {
+    const name = path.basename(file).split('.').shift();
+    const mod = this.safeRequireCache(file);
+    const found = mod
+      .children
+      .filter(m => files.indexOf(m.id) !== -1)
+      .map(m => m.id);
+    return this.matchDependency(found, name);
+  },
+  getAllDependencies(files, file) {
+    let all = [];
+    const deps = this.getDependencies(files, file);
+    const walk = (currentDeps) => {
+      all = all.concat(currentDeps);
+      currentDeps.forEach((d) => {
+        const childDeps = this.getDependencies(files, d);
+        walk(childDeps, files, d);
+      });
+    };
+    walk(deps, files, file);
+    return all;
+  },
 };
 
 module.exports = utils;