mocha-distributed 0.9.1 → 0.9.5

package/README.md

@@ -148,16 +148,29 @@ You will see something like this on each of the items of the list:
     "type": "test",
     "title": "test-1.1-async",
     "timedOut": false,
+    "startTime": 1642705594300,
+    "endTime": 1642705594802,
     "duration": 502,
     "file": "/home/psanchez/github/mocha-distributed/example/suite-1.js",
     "state": "passed",
+    "failed": false,
     "speed": "slow",
     "err": 0
-  }```
+  }
+  ```
 
 The JSON formatting will differ since it is saved in a single line.
 
-Apart of test_result you can also access passed_count and failed_count
+Keep in mind that:
+
+* Duration and start/end times are in milliseconds.
+* Some fields are duplicated in a way, like "state" and "failed" by design
+  because sometimes is handy to have this when reading results back.
+* You can access test_result, passed_count and failed_count in redis
+* Skipped tests are never saved in redis by design, unfortunately
+
+You might have a look at list-tests-from-redis.js for an example on how to
+query redis and list all tests.
 
 ## Examples
 
@@ -243,9 +256,9 @@ or have been skipped will return 0.
 If you use jenkins, bamboo or any other build system, make sure
 one redis is installed somewhere and all runners can access to it.
 
-You can create as many processes processes or launch as docker or kubernetes
-instances as you wish, but for each of the runners that you create, make sure
-they have visibility to the redis.
+Create as many processes, nodes, dockers, kubernetes pods as you wish,
+but for each of the runners that you create, make sure each of them can connect 
+to the redis instance (e.g are in the same network).
 
 You can use the project name and build ID or job id as the execution ID for
 mocha-distributed. Use something unique among the builds of all your projects.

package/example/suite-1.js

@@ -24,7 +24,7 @@ describe ('suite-1-async', async function () {
 
 describe ('suite-1-sync', function () {
   it ('test-1.1-async', async function () {
-    await util.sleep(0.5);
+    await util.sleep(1.5);
   })
 
   it ('test-1.2-sync', function () {
@@ -39,3 +39,27 @@ describe ('suite-1.2-sync', function () {
     });
   });
 });
+
+describe ('suite-1.3-io', function () {
+  it ('console.log', function () {
+    console.log ("Writing from console.log\nAnother line")
+  });
+
+  it ('console.error', function () {
+    console.error ("Writing from console.error\nAnother line")
+  });
+
+  it ('process.stdout', function () {
+    process.stdout.write("Writing from process.stdout. No newline.")
+  });
+
+  it ('process.stderr', function () {
+    process.stderr.write("Writing from process.stderr. No newline.")
+  });
+
+  it ('process.stdout & process.stderr', function () {
+    process.stdout.write("stdout output\nanother line")
+    process.stderr.write("stderr output\nanother line\nand yet another one.")
+  });
+
+});

package/index.js

@@ -1,3 +1,8 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2018 Pau Sanchez
+//
+// MIT Licensed
+// -----------------------------------------------------------------------------
 const redis = require("redis");
 const crypto = require("crypto");
 
@@ -27,6 +32,8 @@ if (g_granularity !== GRANULARITY.TEST) {
 
 let g_redis = null;
 
+let g_capture = { stdout: null, stderr: null };
+
 // -----------------------------------------------------------------------------
 // getTestPath
 //
@@ -52,6 +59,28 @@ function getTestPath(testContext) {
   return path.reverse();
 }
 
+// -----------------------------------------------------------------------------
+// captureStream
+// -----------------------------------------------------------------------------
+function captureStream(stream) {
+  var oldWrite = stream.write;
+  var buf = [];
+
+  stream.write = function (chunk, encoding, callback) {
+    buf.push(chunk.toString()); // chunk is a String or Buffer
+    oldWrite.apply(stream, arguments);
+  };
+
+  return {
+    unhook() {
+      stream.write = oldWrite;
+    },
+    captured() {
+      return buf;
+    },
+  };
+}
+
 // -----------------------------------------------------------------------------
 // Initialize redis once before the tests
 // -----------------------------------------------------------------------------
@@ -72,7 +101,7 @@ exports.mochaGlobalSetup = async function () {
   }
 
   if (!g_redisAddress || !g_testExecutionId) {
-    console.log (g_redisAddress, g_testExecutionId)
+    console.log(g_redisAddress, g_testExecutionId);
     console.error(
       "You need to set at least the following environment variables:\n" +
         "  - MOCHA_DISTRIBUTED\n" +
@@ -125,31 +154,89 @@ exports.mochaHooks = {
     if (assignedRunnerId !== g_runnerId) {
       this.currentTest.title += " (skipped by mocha_distributted)";
       this.skip();
+    } else {
+      g_capture.stdout = captureStream(process.stdout);
+      g_capture.stderr = captureStream(process.stderr);
     }
   },
+
   afterEach(done) {
     const SKIPPED = "pending";
+    const FAILED = "failed";
+    const PASSED = "passed";
+
+    let capturedStdout = "";
+    let capturedStderr = "";
+    if (g_capture.stdout) {
+      const stdoutArray = g_capture.stdout.captured();
+      capturedStdout = stdoutArray.join("");
+      capturedStdout = capturedStdout.replace(
+        /\s*\u001b\[3[12]m[^\n]*\n$/g,
+        ""
+      );
+      g_capture.stdout.unhook();
+      g_capture.stdout = null;
+    }
+
+    if (g_capture.stderr) {
+      capturedStderr = g_capture.stderr.captured().join("");
+      g_capture.stderr.unhook();
+      g_capture.stderr = null;
+    }
 
     // Save all data in redis in a way it can be retrieved and aggregated
     // easily for all test by an external reporter
     if (this.currentTest.state !== SKIPPED) {
+      const retryAttempt = this.currentTest._currentRetry || 0;
+      const retryTotal = this.currentTest._retries || 1;
+
+      // adjust state value accounting for exceptions, timeouts & retries
+      let stateFixed = PASSED;
+      if (
+        this.currentTest.state === FAILED ||
+        this.currentTest.timedOut ||
+        (typeof this.currentTest.state === "undefined" &&
+          retryAttempt < retryTotal)
+      ) {
+        stateFixed = FAILED;
+      }
+
+      // Error objects cannot be properly serialized with stringify, thus
+      // we need to use this hack to make it look like a normal object.
+      // Hopefully this should work as well with other sort of objects
+      const err = this.currentTest.err || null;
+      const errObj = JSON.parse(
+        JSON.stringify(err, Object.getOwnPropertyNames(err || {}))
+      );
+
       const testResult = {
         id: getTestPath(this.currentTest),
         type: this.currentTest.type,
         title: this.currentTest.title,
         timedOut: this.currentTest.timedOut,
         duration: this.currentTest.duration,
+        startTime: Date.now() - (this.currentTest.duration || 0),
+        endTime: Date.now(),
+        retryAttempt: retryAttempt,
+        retryTotal: retryTotal,
         file: this.currentTest.file,
-        state: this.currentTest.state,
+        state: stateFixed,
+        failed: stateFixed === FAILED,
         speed: this.currentTest.speed,
-        err: this.currentTest.err | null,
+        err: errObj,
+        stdout: capturedStdout,
+        stderr: capturedStderr,
       };
 
-      // save as single line on purpose
+      // save results as single line on purpose
       const key = `${g_testExecutionId}:test_result`;
       g_redis.rPush(key, JSON.stringify(testResult));
       g_redis.expire(key, g_expirationTime);
-      g_redis.incr(`${g_testExecutionId}:${this.currentTest.state}_count`);
+
+      // increment passed_count/failed_count & set expiry time
+      const countKey = `${g_testExecutionId}:${stateFixed}_count`;
+      g_redis.incr(countKey);
+      g_redis.expire(countKey, g_expirationTime);
     }
 
     done();

package/list-tests-from-redis.js

@@ -0,0 +1,85 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2018 Pau Sanchez
+//
+// MIT Licensed
+// -----------------------------------------------------------------------------
+
+const redis = require("redis");
+
+async function getTestResults(redisHost = 'localhost', redisPort = 6379) {
+  const allResults = []
+  try {
+    const redisClient = redis.createClient({
+      url: `redis://${redisHost}:${redisPort}/`
+    });
+
+    await redisClient.connect()
+
+    // get all potential test results keys
+    const keyResults = await redisClient.keys('*:test_result')
+
+    // we can get all in parallel
+    const parallelResults = []
+    for(const key of keyResults) {
+      const rawResultList = await redisClient.lRange(key, 0, -1)
+
+      let passed = 0
+      let failed = 0
+      let aggregatedDurationMs = 0
+      let firstStartTime = null
+      let lastEndTime = null
+      const jsonResultList = []
+      for (const rawResult of rawResultList) {
+        const jsonResult = JSON.parse(rawResult)
+        jsonResultList.push(jsonResult)
+
+        // compute some extra stuff
+        if (firstStartTime === null || jsonResult.startTime < firstStartTime) {
+          firstStartTime = jsonResult.startTime
+        }
+
+        if (lastEndTime === null || jsonResult.endTime > lastEndTime) {
+          lastEndTime = jsonResult.endTime
+        }
+
+        passed += (jsonResult.state === "passed")
+        failed += (jsonResult.state === "failed")
+
+        aggregatedDurationMs += (jsonResult.duration || 0)
+      }
+
+      // sort all jsonResultList by the full test route, because they will
+      // be visualized better
+      jsonResultList.sort((a, b) => (a.id.join('/') > b.id.join('/')) ? 1 : -1)
+
+      allResults.push({
+        key: key,
+        start_time : firstStartTime || 0,
+        end_time : lastEndTime || 0,
+        aggregated_duration: aggregatedDurationMs,
+        real_duration: (firstStartTime && lastEndTime) ? lastEndTime - firstStartTime : aggregatedDurationMs,
+        tests_passed : passed,
+        tests_failed : failed,
+        test_results : jsonResultList
+      })
+    }
+
+    // sort results by startTime, most recent first
+    allResults.sort((a, b) => (a.start_time < b.start_time) ? 1 : -1)
+
+    await redisClient.quit()
+    return allResults
+  }
+  catch(e) {
+    console.error ("Test Error: ", e)
+    return false
+  }
+}
+
+
+// -----------------------------------------------------------------------------
+// Print results as JSON output
+// -----------------------------------------------------------------------------
+getTestResults().then( (results) => {
+  console.log (JSON.stringify(results, null, 2))
+})

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mocha-distributed",
-  "version": "0.9.1",
-  "description": "Run multiple mocha suites and tests in parallel, from different processes or different machines",
+  "version": "0.9.5",
+  "description": "Run multiple mocha suites and tests in parallel, from different processes and different machines. Results available on a redis database.",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -14,6 +14,7 @@
     "integration tests",
     "pipelines",
     "chai",
+    "expect",
     "kubernetes",
     "docker",
     "mocha-parallel-tests",
@@ -27,10 +28,10 @@
   "author": "Pau Sanchez",
   "license": "MIT",
   "dependencies": {
-    "redis": "^4.0.1"
+    "redis": "^4.0.3"
   },
   "devDependencies": {
     "chai": "^4.2.0",
-    "mocha": "^9.1.3"
+    "mocha": "^9.1.4"
   }
 }