test: unreliable ExtensionUserActivity test #3690

This fixes a flaky test due to the timeout delays
not being properly spaced. Because of this the
vscode Event Emitter would fire in the same
throttle interval. This caused the throttled function to treat
all calls to it to be in the same interval, such
that it only triggered once.

This fixes the delay of when the second set of
event firing goes off so that those are triggered
when we are in the next throttle interval, instead
of the first.

Signed-off-by: Nikolas Komonen <[email protected]>

Author: nkomonen-amazon

src/test/shared/extensionUtilities.test.ts

@@ -28,6 +28,7 @@ import { FakeExtensionContext } from '../fakeExtensionContext'
 import { InstanceIdentity } from '../../shared/clients/ec2MetadataClient'
 import { extensionVersion } from '../../shared/vscode/env'
 import { sleep } from '../../shared/utilities/timeoutUtils'
+import globals from '../../shared/extensionGlobals'
 
 describe('extensionUtilities', function () {
     describe('safeGet', function () {
@@ -205,102 +206,112 @@ describe('ExtensionUserActivity', function () {
     })
 
     it('triggers twice when multiple user activities are fired in separate intervals', async function () {
-        const throttleDelay = 2000
-        const middleOfInterval = Math.floor(throttleDelay / 2)
-        const waitFor = throttleDelay * 3 // delay * (2 event intervals + test buffer)
-
-        const eventsFirst = [
-            delayedFiringEvent(middleOfInterval + 1),
-            delayedFiringEvent(middleOfInterval + 2),
-            delayedFiringEvent(middleOfInterval + 3),
-            delayedFiringEvent(middleOfInterval + 4),
-        ]
-        const eventsSecond = [
-            delayedFiringEvent(throttleDelay + middleOfInterval + 1),
-            delayedFiringEvent(throttleDelay + middleOfInterval + 2),
-            delayedFiringEvent(throttleDelay + middleOfInterval + 2),
-            delayedFiringEvent(throttleDelay + middleOfInterval + 3),
+        const throttleDelay = 200
+
+        const firstInvervalMillisUntilFire = [51, 52, 53, 54]
+
+        const secondIntervalStart = firstInvervalMillisUntilFire[0] + throttleDelay + 1
+        const secondIntervalMillisUntilFire = [
+            secondIntervalStart + 10,
+            secondIntervalStart + 11,
+            secondIntervalStart + 11,
+            secondIntervalStart + 12,
         ]
-        
-        const instance = new ExtensionUserActivity(throttleDelay, [...eventsFirst, ...eventsSecond])
+
+        const instance = new ExtensionUserActivity(throttleDelay, [
+            ...firstInvervalMillisUntilFire.map(delayedTriggeredEvent),
+            ...secondIntervalMillisUntilFire.map(delayedTriggeredEvent),
+        ])
         instance.onUserActivity(onEventTriggered)
-        await sleep(waitFor)
+        await sleep(secondIntervalStart + throttleDelay + 1)
 
-        assert.strictEqual(count, 2, 'This may be flaky in CI, so we may need to increase the intervals for better tolerance')
+        assert.strictEqual(count, 2)
     })
 
-    describe('does not fire user activity events in specific scenarios', function() {
+    describe('does not fire user activity events in specific scenarios', function () {
         let userActivitySubscriber: sinon.SinonStubbedMember<() => void>
         let _triggerUserActivity: (obj: any) => void
         let instance: ExtensionUserActivity
 
         beforeEach(function () {
             userActivitySubscriber = sandbox.stub()
-            _triggerUserActivity = () => { throw Error('Called before ExtensionUserActivity was instantiated')}
+            _triggerUserActivity = () => {
+                throw Error('Called before ExtensionUserActivity was instantiated')
+            }
         })
 
         afterEach(function () {
             instance.dispose()
             sandbox.restore()
         })
 
-        it('does not fire onDidChangeWindowState when not active', function() {
+        it('does not fire onDidChangeWindowState when not active', function () {
             stubUserActivityEvent(vscode.window, 'onDidChangeWindowState')
-            
+
             const triggerUserActivity = createTriggerActivityFunc()
 
-            triggerUserActivity({active: false})
+            triggerUserActivity({ active: false })
             assert.strictEqual(userActivitySubscriber.callCount, 0)
 
-            triggerUserActivity({active: true})
+            triggerUserActivity({ active: true })
             assert.strictEqual(userActivitySubscriber.callCount, 1)
         })
 
-        it('does not fire onDidChangeTextEditorSelection when editor is `Output` panel', function() {
+        it('does not fire onDidChangeTextEditorSelection when editor is `Output` panel', function () {
             stubUserActivityEvent(vscode.window, 'onDidChangeTextEditorSelection')
-            
+
             const triggerUserActivity = createTriggerActivityFunc()
 
-            triggerUserActivity({textEditor: {document: {uri: {scheme: 'output'}}}})
+            triggerUserActivity({ textEditor: { document: { uri: { scheme: 'output' } } } })
             assert.strictEqual(userActivitySubscriber.callCount, 0)
 
-            triggerUserActivity({textEditor: {document: {uri: {scheme: 'NOToutput'}}}})
+            triggerUserActivity({ textEditor: { document: { uri: { scheme: 'NOToutput' } } } })
             assert.strictEqual(userActivitySubscriber.callCount, 1)
         })
 
-        it('does not fire onDidChangeTextEditorVisibleRanges when when editor is `Output` panel', function() {
+        it('does not fire onDidChangeTextEditorVisibleRanges when when editor is `Output` panel', function () {
             stubUserActivityEvent(vscode.window, 'onDidChangeTextEditorVisibleRanges')
-            
+
             const triggerUserActivity = createTriggerActivityFunc()
 
-            triggerUserActivity({textEditor: {document: {uri: {scheme: 'output'}}}})
+            triggerUserActivity({ textEditor: { document: { uri: { scheme: 'output' } } } })
             assert.strictEqual(userActivitySubscriber.callCount, 0)
 
-            triggerUserActivity({textEditor: {document: {uri: {scheme: 'NOToutput'}}}})
+            triggerUserActivity({ textEditor: { document: { uri: { scheme: 'NOToutput' } } } })
             assert.strictEqual(userActivitySubscriber.callCount, 1)
         })
 
-        it('does not fire onDidChangeTextDocument when not the active user document', function() {
+        it('does not fire onDidChangeTextDocument when not the active user document', function () {
             stubUserActivityEvent(vscode.workspace, 'onDidChangeTextDocument')
             const activeEditorStub = sandbox.stub(vscode.window, 'activeTextEditor')
-            
+
             const triggerUserActivity = createTriggerActivityFunc()
 
             activeEditorStub.get(() => undefined)
             triggerUserActivity({})
             assert.strictEqual(userActivitySubscriber.callCount, 0, 'Was not ignored when no active editor')
 
-            activeEditorStub.get(() => {return {document: {uri: 'myUri'}}})
-            triggerUserActivity({document: {uri: 'myOtherUri'}})
-            assert.strictEqual(userActivitySubscriber.callCount, 0, 'Was not ignored when active editor document was different from the event')
+            activeEditorStub.get(() => {
+                return { document: { uri: 'myUri' } }
+            })
+            triggerUserActivity({ document: { uri: 'myOtherUri' } })
+            assert.strictEqual(
+                userActivitySubscriber.callCount,
+                0,
+                'Was not ignored when active editor document was different from the event'
+            )
 
-            triggerUserActivity({document: {uri: 'myUri'}})
-            assert.strictEqual(userActivitySubscriber.callCount, 1, 'Was ignored when the active editor document was the same as the event')
+            triggerUserActivity({ document: { uri: 'myUri' } })
+            assert.strictEqual(
+                userActivitySubscriber.callCount,
+                1,
+                'Was ignored when the active editor document was the same as the event'
+            )
         })
 
         it('fires for onDidChangeActiveColorTheme (sanity check)', function () {
             stubUserActivityEvent(vscode.window, 'onDidChangeActiveColorTheme')
-            
+
             const triggerUserActivity = createTriggerActivityFunc()
 
             triggerUserActivity({})
@@ -309,23 +320,20 @@ describe('ExtensionUserActivity', function () {
 
         /**
          * Helper to stub a vscode event object.
-         * 
+         *
          * Once stubbed, you can call {@link _triggerUserActivity} to fire
          * the event.
          */
-        function stubUserActivityEvent<T, K extends keyof T>(vscodeObj: T, eventName: K){
-            const eventStub = sandbox.stub(
-                vscodeObj, 
-                eventName
-            )
-            
+        function stubUserActivityEvent<T, K extends keyof T>(vscodeObj: T, eventName: K) {
+            const eventStub = sandbox.stub(vscodeObj, eventName)
+
             eventStub.callsFake((callback: any) => {
                 _triggerUserActivity = callback
                 return {
-                    dispose: sandbox.stub()
+                    dispose: sandbox.stub(),
                 }
             })
-            
+
             return eventStub
         }
 
@@ -339,9 +347,9 @@ describe('ExtensionUserActivity', function () {
         }
     })
 
-    function delayedFiringEvent(fireInMillis: number): vscode.Event<any> {
+    function delayedTriggeredEvent(millisUntilFire: number): vscode.Event<any> {
         const event = new vscode.EventEmitter<void>()
-        setTimeout(() => event.fire(), fireInMillis)
+        globals.clock.setTimeout(() => event.fire(), millisUntilFire)
         return event.event
     }
 })