replicate mocha-coderoad with jest config

Author: ShMcK

Diff for: .DS_Store

@@ -0,0 +1,4 @@
+.DS_STORE
+.vscode
+
+node_modules

Diff for: .gitignore

@@ -1,3 +1,6 @@
+.DS_Store
+.vscode
+
 node_modules
 src/*.js
 test/**/*.ts

Diff for: .npmignore

@@ -0,0 +1,21 @@
+// cSpell Settings
+{
+    
+    // Version of the setting file.  Always 0.1
+    "version": "0.1",
+    
+    // language - current active spelling language
+    "language": "en",
+    
+    // words - list of words to be always considered correct
+    "words": [
+        "coderoad"
+    ],
+    
+    // flagWords - list of words to be always considered incorrect
+    // This is useful for offensive words and common spelling errors.
+    // For example "hte" should be "the"
+    "flagWords": [
+        "hte"
+    ]
+}

Diff for: .vscode/cSpell.json

@@ -19,5 +19,11 @@
   "bugs": {
     "url": "https://github.com/coderoad/jest-coderoad/issues"
   },
-  "homepage": "https://github.com/coderoad/jest-coderoad#readme"
+  "homepage": "https://github.com/coderoad/jest-coderoad#readme",
+  "dependencies": {
+    "babel-jest": "^15.0.0",
+    "jest": "^15.1.1",
+    "js-coderoad": "^0.2.1",
+    "node-file-exists": "1.1.0"
+  }
 }

Diff for: package.json

@@ -0,0 +1,12 @@
+// test results are taken after this signal
+// this helps to avoid parsing console.logs before the output
+export const signal = '@@@CodeRoad Results@@@';
+
+// path to test runner executable from "node_modules"
+export const runnerPath = ['jest', 'bin', 'jest'];
+
+// options passed in the runner command process
+export const runnerOptions = [
+  '--bail', // quit on first fail
+  '--notify'
+];

Diff for: src/constants.ts

@@ -0,0 +1,9 @@
+- runner name
+- runner path
+- capture output
+
+- js-coderoad
+- jest
+
+
+npm install -g jest-cli

Diff for: src/elements.md

@@ -0,0 +1,20 @@
+import writeTests from './writeTests';
+import runner from './runner';
+import getTestPath from './testPath';
+
+export function load({ dir, testFile, tests }) {
+  writeTests({
+    dir,
+    tests,
+    testPath: getTestPath(testFile),
+  });
+};
+
+export function run({ dir, taskPosition, handleResult, testFile }) {
+  runner({
+    dir,
+    taskPosition,
+    handleResult,
+    testPath: getTestPath(testFile),
+  });
+}

Diff for: src/index.ts

@@ -0,0 +1,54 @@
+import { signal } from '../constants';
+
+exports = module.exports = reporter;
+function reporter(runner) {
+  let result = {
+    passes: [],
+    failures: [],
+    pass: true,
+  };
+
+  runner.on('pass', (test) => {
+    const {index} = getIndexAndTitle(test.fullTitle());
+    // add pass
+    result.passes.push({
+      msg: `Task ${index} Complete`,
+      taskPosition: index,
+    });
+  });
+
+  runner.on('fail', (test, err: Error) => {
+    const {msg, index} = getIndexAndTitle(test.fullTitle());
+    // add fail
+    result.failures.push({
+      msg,
+      taskPosition: index - 1,
+      // body: test.body,
+      timedOut: test.timedOut,
+      // duration: test.duration
+    });
+    result.pass = false;
+  });
+
+  runner.on('end', function() {
+    // anything before the signal will be captured as log
+    process.stdout.write(signal + JSON.stringify(result, null, 2));
+  });
+}
+
+interface IndexTitle {
+  index: number;
+  msg: string;
+}
+
+function getIndexAndTitle(title: string): IndexTitle {
+  // tests prefixed with task number: "01 title"
+  const indexString = title.match(/^[0-9]+/);
+  if (!indexString) {
+    throw 'Tests should begin with a number, indicating the task number';
+  }
+  return {
+    index: parseInt(indexString[0], 10),
+    msg: title.slice(indexString[0].length + 1),
+  };
+}

Diff for: src/reporter/index.ts

@@ -0,0 +1,15 @@
+import startRunner from './start-runner';
+import spawnRunnerProcess from './runner-process';
+
+const isWindows = window.navigator.appVersion.indexOf('Win') > -1;
+
+export default function runner({dir, taskPosition, handleResult, testPath}) {
+
+  if (isWindows) {
+    testPath = testPath.split('\\').join('\\\\');
+    testPath = testPath.split('/').join('\\\\');
+  }
+
+  const runner = spawnRunnerProcess({dir, taskPosition, testPath});
+  return startRunner({runner, handleResult, taskPosition});
+}

Diff for: src/runner/index.ts

@@ -0,0 +1,10 @@
+import { join } from 'path';
+
+export default function getNode(): string {
+  if (process.platform === 'darwin' && process.resourcesPath) {
+    return join(process.resourcesPath, '..', 'Frameworks', 'Atom Helper.app', 'Contents', 'MacOS', 'Atom Helper');
+  } else if (process.platform.match(/win/)) {
+    return 'node';
+  }
+  return process.execPath;
+}

Diff for: src/runner/paths/node.ts

@@ -0,0 +1,17 @@
+import fileExists from 'node-file-exists';
+import { join } from 'path';
+import { runnerPath } from '../../constants';
+
+
+const nestedPath = [__dirname, '..', '..', '..', '..'].concat(runnerPath);
+const flattenedPath = [__dirname, '..', '..', '..', 'node_modules'].concat(runnerPath);
+
+export default function getRunner(): string {
+  // runner, location may differ based on NPM version
+  if (fileExists(join(...nestedPath))) {
+    return join(...nestedPath);
+  } else if (fileExists(join(...flattenedPath))) {
+    return join(...flattenedPath);
+  }
+  throw new Error('Error finding test runner.');
+}

Diff for: src/runner/paths/runner.ts

@@ -0,0 +1,37 @@
+import { join } from 'path';
+import { spawn } from 'child_process';
+
+import getRunner from './paths/runner';
+import getNode from './paths/node';
+import { runnerOptions } from '../constants';
+
+const reporterPath = join(__dirname, '..', 'reporter', 'index.js');
+const node = getNode();
+const runner = getRunner();
+
+export default function spawnRunnerProcess({dir, taskPosition, testPath}) {
+  // node electron setup
+  let options: any = {
+    cwd: dir
+  };
+  if (options.env == null) {
+    options.env = Object.create(process.env);
+  }
+
+  Object.assign(options.env, {
+    ATOM_SHELL_INTERNAL_RUN_AS_NODE: 1,
+    DIR: dir, // user project directory
+    TASK_POSITION: taskPosition,
+    NODE_PATH: join(dir, 'node_modules'),
+  });
+
+  // spawn child process calling jest test runner
+  return spawn(node, [
+    // into shared node_modules directory
+    runner,
+    `--reporter=${reporterPath}`  // test feedback
+    ]
+    .concat(runnerOptions)
+    .concat(testPath), // unit tests
+  options);
+}

Diff for: src/runner/runner-process.ts

@@ -0,0 +1,68 @@
+import { parseLog } from 'process-console-log';
+import { signal } from '../constants';
+
+// take code after the signal to avoid confusing console.log statements
+// with test output
+const signalMatch = new RegExp(signal);
+
+export default function startRunner({runner, handleResult, taskPosition}) {
+
+  var final = null;
+
+  new Promise(function run(resolve, reject) {
+
+    runner.stdout.on('data', function onData(data): void {
+      data = data.toString();
+			// parse only final output data
+      let match = signalMatch.exec(data); // 0
+
+      if (!match) {
+        try {
+          parseLog(data);
+        } catch (e) {
+          parseLog(data);
+        }
+        return;
+      }
+
+			/* Result */
+			// transform string result into object
+      let resultString = data.substring(match.index + signal.length);
+      let result = JSON.parse(JSON.stringify(resultString));
+			// why parse twice? it works
+      if (typeof result === 'string') {
+        result = JSON.parse(result);
+      }
+
+      switch (result.pass) {
+        case true:
+        final = result.passes[result.passes.length - 1];
+        break;
+        case false:
+        final = result.failures[0];
+        break;
+        default:
+        console.log('error processing result: ', result);
+      }
+
+      final.change = final.taskPosition - taskPosition;
+      final.pass = final.change > 0;
+      final.completed = result.pass;
+
+			// return result to atom-coderoad
+      handleResult(final);
+    });
+
+    runner.stderr.on('data', function onError(data) {
+      console.log('test error', data.toString());
+    });
+
+    runner.on('close', function onClose(code: number) {
+			// if (code === 0) {
+			//   resolve(final);
+			// } else {
+      resolve(final);
+			// }
+    });
+  });
+}

Diff for: src/runner/start-runner.ts

@@ -0,0 +1,11 @@
+import { join } from 'path';
+
+const isWindows = window.navigator.appVersion.includes('Win') || false;
+
+export default function tmpTestName(testFile: string): string {
+  let testPath = join(__dirname, '..', '.tmp', testFile + '.js');
+  if (isWindows) {
+    testPath = testPath.split('/').join('\\');
+  }
+  return testPath;
+}