mocha-distributed 0.9.1 → 0.9.2

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/docker-compose.yml

@@ -7,6 +7,9 @@ services:
     ports:
       - 6379:6379
 
+    networks:
+      - mordor_gh_network
+
   redis-commander:
     image: rediscommander/redis-commander:latest
     environment:
@@ -16,3 +19,9 @@ services:
     depends_on:
       - redis
 
+    networks:
+      - mordor_gh_network
+
+networks:
+  mordor_gh_network:
+    external: true

package/index.js

@@ -1,3 +1,8 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2018 Pau Sanchez
+//
+// MIT Licensed
+// -----------------------------------------------------------------------------
 const redis = require("redis");
 const crypto = require("crypto");
 
@@ -129,6 +134,7 @@ exports.mochaHooks = {
   },
   afterEach(done) {
     const SKIPPED = "pending";
+    const FAILED = "failed";
 
     // Save all data in redis in a way it can be retrieved and aggregated
     // easily for all test by an external reporter
@@ -139,17 +145,24 @@ exports.mochaHooks = {
         title: this.currentTest.title,
         timedOut: this.currentTest.timedOut,
         duration: this.currentTest.duration,
+        startTime: Date.now() - (this.currentTest.duration || 0),
+        endTime: Date.now(),
         file: this.currentTest.file,
         state: this.currentTest.state,
+        failed: this.currentTest.state === FAILED,
         speed: this.currentTest.speed,
-        err: this.currentTest.err | null,
+        err: this.currentTest.err || null,
       };
 
-      // 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}:${this.currentTest.state}_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,6 +1,6 @@
 {
   "name": "mocha-distributed",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "Run multiple mocha suites and tests in parallel, from different processes or different machines",
   "main": "index.js",
   "scripts": {
@@ -27,10 +27,10 @@
   "author": "Pau Sanchez",
   "license": "MIT",
   "dependencies": {
-    "redis": "^4.0.1"
+    "redis": "^4.0.2"
   },
   "devDependencies": {
     "chai": "^4.2.0",
-    "mocha": "^9.1.3"
+    "mocha": "^9.1.4"
   }
 }