test: add tests to ensure request is debounced

Author: Hweinstock

packages/amazonq/test/unit/amazonq/apps/inline/recommendationService.test.ts

@@ -9,9 +9,10 @@ import { Position, CancellationToken, InlineCompletionItem } from 'vscode'
 import assert from 'assert'
 import { RecommendationService } from '../../../../../src/app/inline/recommendationService'
 import { SessionManager } from '../../../../../src/app/inline/sessionManager'
-import { createMockDocument } from 'aws-core-vscode/test'
+import { createMockDocument, installFakeClock } from 'aws-core-vscode/test'
 import { LineTracker } from '../../../../../src/app/inline/stateTracker/lineTracker'
 import { InlineGeneratingMessage } from '../../../../../src/app/inline/inlineGeneratingMessage'
+import { inlineCompletionsDebounceDelay } from 'aws-core-vscode/codewhisperer'
 
 describe('RecommendationService', () => {
     let languageClient: LanguageClient
@@ -119,5 +120,100 @@ describe('RecommendationService', () => {
             const items2 = sessionManager.getActiveRecommendation()
             assert.deepStrictEqual(items2, [mockInlineCompletionItemTwo, { insertText: '1' } as InlineCompletionItem])
         })
+
+        describe('debounce functionality', () => {
+            let clock: ReturnType<typeof installFakeClock>
+
+            beforeEach(() => {
+                clock = installFakeClock()
+            })
+
+            afterEach(() => {
+                clock.uninstall()
+            })
+
+            it('debounces multiple rapid calls', async () => {
+                const mockResult = {
+                    sessionId: 'test-session',
+                    items: [mockInlineCompletionItemOne],
+                    partialResultToken: undefined,
+                }
+
+                sendRequestStub.resolves(mockResult)
+
+                // Make multiple rapid calls
+                const promise1 = service.getAllRecommendations(
+                    languageClient,
+                    mockDocument,
+                    mockPosition,
+                    mockContext,
+                    mockToken
+                )
+                const promise2 = service.getAllRecommendations(
+                    languageClient,
+                    mockDocument,
+                    mockPosition,
+                    mockContext,
+                    mockToken
+                )
+                const promise3 = service.getAllRecommendations(
+                    languageClient,
+                    mockDocument,
+                    mockPosition,
+                    mockContext,
+                    mockToken
+                )
+
+                // Verify that the promises are the same object (debounced)
+                assert.strictEqual(promise1, promise2)
+                assert.strictEqual(promise2, promise3)
+
+                await clock.tickAsync(inlineCompletionsDebounceDelay + 1000)
+
+                await promise1
+                await promise2
+                await promise3
+            })
+
+            it('allows new calls after debounce period', async () => {
+                const mockResult = {
+                    sessionId: 'test-session',
+                    items: [mockInlineCompletionItemOne],
+                    partialResultToken: undefined,
+                }
+
+                sendRequestStub.resolves(mockResult)
+
+                const promise1 = service.getAllRecommendations(
+                    languageClient,
+                    mockDocument,
+                    mockPosition,
+                    mockContext,
+                    mockToken
+                )
+
+                await clock.tickAsync(inlineCompletionsDebounceDelay + 1000)
+
+                await promise1
+
+                const promise2 = service.getAllRecommendations(
+                    languageClient,
+                    mockDocument,
+                    mockPosition,
+                    mockContext,
+                    mockToken
+                )
+
+                assert.notStrictEqual(
+                    promise1,
+                    promise2,
+                    'promises should be different when seperated by debounce period'
+                )
+
+                await clock.tickAsync(inlineCompletionsDebounceDelay + 1000)
+
+                await promise2
+            })
+        })
     })
 })