Fixed flaky timeout-threshold tests racing real setTimeout

no ref

- {{#get}} and {{#recommendations}} timeout tests asserted that the
  helper's setTimeout(threshold=1ms) fired before the API stub's
  setTimeout(5ms), which is fundamentally a Node scheduler race
- under CI load, both timers can land in the same macrotask and the
  ordering becomes unreliable, e.g. recommendations.test.js:173 in
  run 25404408183 and get.test.js:562 in run 25399938361
- install sinon fake timers in each test, kick off the helper, then
  tickAsync(2) — that fires the 1ms threshold timer but not the 5ms
  API timer, so the timeout branch wins deterministically
- limited toFake to [setTimeout, clearTimeout] so Date and other
  timers aren't affected (the get notify test still uses real time)

Author: 9larsons

ghost/core/test/unit/frontend/helpers/get.test.js

@@ -551,23 +551,32 @@ describe('{{#get}} helper', function () {
         });
 
         it('should log an error and return safely if it hits the timeout threshold', async function () {
-            configUtils.set('optimization:getHelper:timeout:threshold', 1);
-
-            const result = await get.call(
-                {},
-                'posts',
-                {hash: {}, data: locals, fn: fn, inverse: inverse}
-            );
-
-            assert(result.toString().includes('data-aborted-get-helper'));
-            // A log message will be output
-            sinon.assert.calledOnce(logging.error);
-            // The get helper gets called with an empty array of results
-            sinon.assert.calledOnce(fn);
-            const args = fn.firstCall.args[0];
-            assert(args && typeof args === 'object');
-            assert('posts' in args);
-            assert.deepEqual(args.posts, []);
+            const clock = sinon.useFakeTimers({toFake: ['setTimeout', 'clearTimeout']});
+            try {
+                configUtils.set('optimization:getHelper:timeout:threshold', 1);
+
+                const resultPromise = get.call(
+                    {},
+                    'posts',
+                    {hash: {}, data: locals, fn: fn, inverse: inverse}
+                );
+                // Advance past the 1ms threshold but not the stub's 5ms timer,
+                // so the helper's timeout branch wins deterministically.
+                await clock.tickAsync(2);
+                const result = await resultPromise;
+
+                assert(result.toString().includes('data-aborted-get-helper'));
+                // A log message will be output
+                sinon.assert.calledOnce(logging.error);
+                // The get helper gets called with an empty array of results
+                sinon.assert.calledOnce(fn);
+                const args = fn.firstCall.args[0];
+                assert(args && typeof args === 'object');
+                assert('posts' in args);
+                assert.deepEqual(args.posts, []);
+            } finally {
+                clock.restore();
+            }
         });
     });
 

ghost/core/test/unit/frontend/helpers/recommendations.test.js

@@ -145,6 +145,8 @@ describe('{{#recommendations}} helper', function () {
     });
 
     describe('when timeout is exceeded', function () {
+        let clock;
+
         before(function () {
             sinon.stub(api, 'recommendationsPublic').get(() => {
                 return {
@@ -158,16 +160,29 @@ describe('{{#recommendations}} helper', function () {
                 };
             });
         });
+
+        beforeEach(function () {
+            clock = sinon.useFakeTimers({toFake: ['setTimeout', 'clearTimeout']});
+        });
+
+        afterEach(function () {
+            clock.restore();
+        });
+
         after(async function () {
             await configUtils.restore();
         });
 
         it('should log an error and return safely if it hits the timeout threshold', async function () {
             configUtils.set('optimization:getHelper:timeout:threshold', 1);
 
-            const response = await recommendations.call(
+            const responsePromise = recommendations.call(
                 'recommendations'
             );
+            // Advance past the 1ms threshold but not the stub's 5ms timer,
+            // so the helper's timeout branch wins deterministically.
+            await clock.tickAsync(2);
+            const response = await responsePromise;
 
             // An error message is logged
             sinon.assert.calledOnce(logging.error);