lint cleanup

[websub-hub] / test / src / worker.js

diff --git a/test/src/worker.js b/test/src/worker.js
index 32bd0656665bd854933240eb5323a440e1e438c5..6e1315893f954b17b6eb37233620f977cceacee9 100644 (file)
--- a/test/src/worker.js
+++ b/test/src/worker.js
@@ -131,6 +131,12 @@ describe('Worker', function () {
       stubCtx = {};
     });
     it('gets tasks', async function () {
+      /**
+       * In older versions, could just deepStrictEqual un-awaited promises for equality,
+       * but post 14 or so, async_id symbol properties are included in comparison, and
+       * in some executions of test suites these are somehow different in value so the test
+       * was failing.  So now we settle everything prior to comparison.
+       */
       const expected = [
         Promise.resolve('first'),
         Promise.reject('bad'),
@@ -138,7 +144,11 @@ describe('Worker', function () {
       ];
       worker.promiseGiver.resolves(expected);
       const result = await worker._getWork(stubCtx);
-      assert.deepStrictEqual(result, expected);
+
+      const expectedResolved = await Promise.allSettled(expected);
+      const resultResolved = await Promise.allSettled(result);
+      assert.deepStrictEqual(resultResolved, expectedResolved);
+
       assert.strictEqual(worker.inFlight.length, expected.length);
     });
     it('covers none wanted', async function () {
@@ -204,6 +214,18 @@ describe('Worker', function () {
       assert.strictEqual(worker._getWork.callCount, 0);
       assert.strictEqual(worker._recurr.callCount, 1);
     });
+    it('covers double invocation', async function () {
+      const snooze = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+      this.slow(300);
+      worker.inFlight = [
+        Worker.watchedPromise(snooze(100)),
+      ];
+
+      await Promise.all([worker.process(), worker.process()]);
+      assert.strictEqual(worker._getWork.callCount, 2);
+      assert.strictEqual(worker._recurr.callCount, 1);
+    });
   }); // process
 
 }); // Worker