Merge pull request #16 from mrloop/support-test-each

feat: support test.each, test.todo etc.

Author: mrloop

README.md

@@ -10,6 +10,10 @@ qunit-retry
 Drop in replacement for [QUnit](https://qunitjs.com/) [test](https://api.qunitjs.com/QUnit/test) to `retry` test upon failure.
 
 ```js
+const setup = require('qunit-retry');
+
+const retry = setup(QUnit.test);
+
 // retry this test on failure as third party service occasionally fails
 // we need to test against third party service
 // we can live with occasional third party service failure
@@ -19,13 +23,23 @@ retry("a test relying on 3rd party service that occasionally fails", async funct
 });
 ```
 
+It provides the same API as `QUnit.test`, including `test.each`, `test.only` etc. The only difference is that the test will be retried upon failure.
+
 Use very sparingly, for a suite of 2024 tests, using this for a single acceptance test.
 
 Blog post about `qunit-retry` available [here](https://blog.mrloop.com/javascript/2019/02/26/qunit-retry.html).
 
 ### Set Max Runs
 
-To change the number of retries, set a value in the third parameter (`maxRuns`). The default value for `maxRuns` is `2` (one attempt and one retry):
+The default maximum number of retries is 2 (one attempt and one retry). To change it globally, pass an additional argument to the `setup` function:
+
+```js
+const setup = require('qunit-retry');
+
+const retry = setup(QUnit.test, 3); // sets maxRuns to 3
+```
+
+To change it for a single test, pass the number of retries as the third argument:
 
 ```js
 // retry this test **two times** (in addition to one initial attempt)

main.js

@@ -1,7 +1,36 @@
 import Retry from './src/retry.js'
 
-export default function setup (testFn) {
-  return function retry (name, callback, maxRuns = 2) {
-    return new Retry(name, callback, maxRuns, testFn)
+export default function setup (testFn, defaultMaxRuns = 2) {
+  const retry = function (name, callback, maxRuns = defaultMaxRuns) {
+    return new Retry([name], callback, maxRuns, testFn)
   }
+  retry.todo = function (name, callback, maxRuns = defaultMaxRuns) {
+    return new Retry([name], callback, maxRuns, testFn.todo)
+  }
+  retry.skip = function (name, callback, maxRuns = defaultMaxRuns) {
+    return new Retry([name], callback, maxRuns, testFn.skip)
+  }
+  retry.if = function (name, condition, callback, maxRuns = defaultMaxRuns) {
+    return new Retry([name, condition], callback, maxRuns, testFn.if)
+  }
+  retry.only = function (name, callback, maxRuns = defaultMaxRuns) {
+    return new Retry([name], callback, maxRuns, testFn.only)
+  }
+
+  retry.each = function (name, dataset, callback, maxRuns = defaultMaxRuns) {
+    return new Retry([name, dataset], callback, maxRuns, testFn.each)
+  }
+  retry.todo.each = function (name, dataset, callback, maxRuns = defaultMaxRuns) {
+    return new Retry([name, dataset], callback, maxRuns, testFn.todo.each)
+  }
+  retry.skip.each = function (name, dataset, callback, maxRuns = defaultMaxRuns) {
+    return new Retry([name, dataset], callback, maxRuns, testFn.skip.each)
+  }
+  retry.if.each = function (name, condition, dataset, callback, maxRuns = defaultMaxRuns) {
+    return new Retry([name, condition, dataset], callback, maxRuns, testFn.if.each)
+  }
+  retry.only.each = function (name, dataset, callback, maxRuns = defaultMaxRuns) {
+    return new Retry([name, dataset], callback, maxRuns, testFn.only.each)
+  }
+  return retry
 }

package.json

@@ -26,7 +26,7 @@
   "scripts": {
     "test": "pnpm test:smoke lint && pnpm test:js && pnpm test:smoke",
     "test:smoke": "testem ci",
-    "test:js": "qunit",
+    "test:js": "qunit test/retry.js && qunit test/retry-only.js",
     "dev": "qunit --watch",
     "lint": "eslint index.js"
   },

src/retry.js

@@ -2,15 +2,15 @@ import AssertResultHandler from './assert-result-handler.js'
 import extend from './extend.js'
 
 export default class Retry {
-  constructor (name, callback, maxRuns = 2, testFn) {
-    this.name = name
+  constructor (args, callback, maxRuns = 2, testFn) {
     this.callback = callback
     this.maxRuns = maxRuns
-    this.currentRun = 1
     this.assertResultHandler = new AssertResultHandler(this)
 
-    testFn(name, async (assert) => {
+    testFn(...args, async (assert, ...callbackArgs) => {
       this.assertProxy = new Proxy(assert, this.assertResultHandler)
+      this.callbackArgs = callbackArgs
+      this.currentRun = 1
       await this.retry(this.currentRun)
     })
   }
@@ -71,7 +71,7 @@ export default class Retry {
 
   async tryTest () {
     try {
-      await this.callback.call(this.testEnvironment, this.assertProxy, this.currentRun)
+      await this.callback.call(this.testEnvironment, this.assertProxy, ...this.callbackArgs, this.currentRun)
     } catch (err) {
       if (!this.shouldRetry) {
         throw err

test/retry-only.js

@@ -0,0 +1,44 @@
+const setup = require('../index.js')
+const QUnit = require('qunit')
+
+const retry = setup(QUnit.test)
+
+QUnit.module('retry.only', function () {
+  const calls = []
+
+  retry.only('count only retries', function (assert, currentRun) {
+    calls.push(['only', currentRun])
+
+    assert.equal(currentRun, 2)
+  })
+
+  retry('count non-only retries', function (assert, currentRun) {
+    calls.push(['non-only', currentRun])
+
+    assert.equal(currentRun, 2)
+  })
+
+  QUnit.test('verify calls', function (assert) {
+    assert.deepEqual(calls, [['only', 1], ['only', 2]])
+  })
+})
+
+QUnit.module('retry.only.each', function () {
+  const calls = []
+
+  retry.only.each('count only retries', ['A', 'B'], function (assert, data, currentRun) {
+    calls.push(['only', data, currentRun])
+
+    assert.equal(currentRun, 2)
+  })
+
+  retry.each('count non-only retries', ['A', 'B'], function (assert, data, currentRun) {
+    calls.push(['non-only', data, currentRun])
+
+    assert.equal(currentRun, 2)
+  })
+
+  QUnit.test('verify calls', function (assert) {
+    assert.deepEqual(calls, [['only', 'A', 1], ['only', 'A', 2], ['only', 'B', 1], ['only', 'B', 2]])
+  })
+})

test/retry.js

@@ -118,3 +118,128 @@ QUnit.module('hooks count', function () {
     assert.equal(afterCount, 5)
   })
 })
+
+QUnit.module('default max runs', function () {
+  const calls = []
+  const retryThrice = setup(QUnit.test, 3)
+
+  retryThrice('count retries', function (assert, currentRun) {
+    calls.push(currentRun)
+
+    assert.equal(currentRun, 3)
+  })
+
+  QUnit.test('verify calls', function (assert) {
+    assert.deepEqual(calls, [1, 2, 3])
+  })
+})
+
+QUnit.module('retry.todo', function () {
+  const calls = []
+
+  retry.todo('count retries', function (assert, currentRun) {
+    calls.push(currentRun)
+
+    assert.ok(false)
+  })
+
+  QUnit.test('verify calls', function (assert) {
+    assert.deepEqual(calls, [1, 2])
+  })
+})
+
+QUnit.module('retry.skip', function () {
+  const calls = []
+
+  retry.skip('count retries', function (assert, currentRun) {
+    calls.push(currentRun)
+
+    assert.equal(currentRun, 2)
+  })
+
+  QUnit.test('verify calls', function (assert) {
+    assert.deepEqual(calls, [])
+  })
+})
+
+QUnit.module('retry.if', function () {
+  const calls = []
+
+  retry.if('count true retries', true, function (assert, currentRun) {
+    calls.push([true, currentRun])
+
+    assert.equal(currentRun, 2)
+  })
+
+  retry.if('count false retries', false, function (assert, currentRun) {
+    calls.push([false, currentRun])
+
+    assert.equal(currentRun, 2)
+  })
+
+  QUnit.test('verify calls', function (assert) {
+    assert.deepEqual(calls, [[true, 1], [true, 2]])
+  })
+})
+
+QUnit.module('retry.each', function () {
+  const calls = []
+
+  retry.each('count retries', ['A', 'B', 'C'], function (assert, data, currentRun) {
+    calls.push([data, currentRun])
+
+    assert.equal(currentRun, 2)
+  })
+
+  QUnit.test('verify calls', function (assert) {
+    assert.deepEqual(calls, [['A', 1], ['A', 2], ['B', 1], ['B', 2], ['C', 1], ['C', 2]])
+  })
+})
+
+QUnit.module('retry.todo.each', function () {
+  const calls = []
+
+  retry.todo.each('count retries', ['A', 'B', 'C'], function (assert, data, currentRun) {
+    calls.push([data, currentRun])
+
+    assert.ok(false)
+  })
+
+  QUnit.test('verify calls', function (assert) {
+    assert.deepEqual(calls, [['A', 1], ['A', 2], ['B', 1], ['B', 2], ['C', 1], ['C', 2]])
+  })
+})
+
+QUnit.module('retry.skip.each', function () {
+  const calls = []
+
+  retry.skip.each('count retries', ['A', 'B', 'C'], function (assert, data, currentRun) {
+    calls.push([data, currentRun])
+
+    assert.equal(currentRun, 2)
+  })
+
+  QUnit.test('verify calls', function (assert) {
+    assert.deepEqual(calls, [])
+  })
+})
+
+QUnit.module('retry.if.each', function () {
+  const calls = []
+
+  retry.if.each('count true retries', true, ['A', 'B'], function (assert, data, currentRun) {
+    calls.push([true, data, currentRun])
+
+    assert.equal(currentRun, 2)
+  })
+
+  retry.if.each('count false retries', false, ['A', 'B'], function (assert, data, currentRun) {
+    calls.push([false, data, currentRun])
+
+    assert.equal(currentRun, 2)
+  })
+
+  QUnit.test('verify calls', function (assert) {
+    assert.deepEqual(calls, [[true, 'A', 1], [true, 'A', 2], [true, 'B', 1], [true, 'B', 2]])
+  })
+})