@aws/lsp-codewhisperer 0.0.3

package/out/language-server/codeWhispererServer.test.js

@@ -0,0 +1,1218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const testing_1 = require("@aws/language-server-runtimes/out/testing");
+const assert = require("assert");
+const ts_sinon_1 = require("ts-sinon");
+const vscode_languageserver_1 = require("vscode-languageserver");
+const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
+const codeWhispererServer_1 = require("./codeWhispererServer");
+const sessionManager_1 = require("./session/sessionManager");
+const testUtils_1 = require("./testUtils");
+describe('CodeWhisperer Server', () => {
+    const sandbox = ts_sinon_1.default.createSandbox();
+    let SESSION_IDS_LOG = [];
+    let sessionManager;
+    let sessionManagerSpy;
+    let generateSessionIdStub;
+    beforeEach(() => {
+        const StubSessionIdGenerator = () => {
+            const id = 'some-random-session-uuid-' + SESSION_IDS_LOG.length;
+            SESSION_IDS_LOG.push(id);
+            return id;
+        };
+        generateSessionIdStub = ts_sinon_1.default
+            .stub(sessionManager_1.CodeWhispererSession.prototype, 'generateSessionId')
+            .callsFake(StubSessionIdGenerator);
+        sessionManager = sessionManager_1.SessionManager.getInstance();
+        sessionManagerSpy = sandbox.spy(sessionManager);
+    });
+    afterEach(() => {
+        generateSessionIdStub.restore();
+        sessionManager_1.SessionManager.reset();
+        sandbox.restore();
+        SESSION_IDS_LOG = [];
+    });
+    describe('Recommendations', () => {
+        let features;
+        let server;
+        // TODO move more of the service code out of the stub and into the testable realm
+        // See: https://aws.amazon.com/blogs/developer/mocking-modular-aws-sdk-for-javascript-v3-in-unit-tests/
+        // for examples on how to mock just the SDK client
+        let service;
+        beforeEach(async () => {
+            // Set up the server with a mock service, returning predefined recommendations
+            service = (0, ts_sinon_1.stubInterface)();
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: testUtils_1.EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            server = (0, codeWhispererServer_1.CodewhispererServerFactory)(_auth => service);
+            // Initialize the features, but don't start server yet
+            features = new testing_1.TestFeatures();
+            // Return no specific configuration for CodeWhisperer
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({}));
+            // Start the server and open a document
+            await features.start(server);
+            features
+                .openDocument(testUtils_1.SOME_FILE)
+                .openDocument(testUtils_1.SOME_FILE_WITH_ALT_CASED_LANGUAGE_ID)
+                .openDocument(testUtils_1.SOME_UNSUPPORTED_FILE)
+                .openDocument(testUtils_1.SOME_FILE_WITH_EXTENSION)
+                .openDocument(testUtils_1.SOME_SINGLE_LINE_FILE);
+        });
+        afterEach(() => {
+            features.dispose();
+        });
+        it('should return recommendations', async () => {
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT);
+            const expectedGenerateSuggestionsRequest = {
+                fileContext: {
+                    filename: testUtils_1.SOME_FILE.uri,
+                    programmingLanguage: { languageName: 'csharp' },
+                    leftFileContent: '',
+                    rightFileContent: testUtils_1.HELLO_WORLD_IN_CSHARP,
+                },
+                maxResults: 5,
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(service.generateSuggestions, expectedGenerateSuggestionsRequest);
+        });
+        it('should correctly get left and right context', async () => {
+            const cutOffLine = 2;
+            const lines = testUtils_1.HELLO_WORLD_IN_CSHARP.split('\n');
+            const firstTwoLines = lines.slice(0, cutOffLine).join('\n') + '\n';
+            const remainingLines = lines.slice(cutOffLine).join('\n');
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: cutOffLine, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT);
+            const expectedGenerateSuggestionsRequest = {
+                fileContext: {
+                    filename: testUtils_1.SOME_FILE.uri,
+                    programmingLanguage: { languageName: 'csharp' },
+                    leftFileContent: firstTwoLines,
+                    rightFileContent: remainingLines,
+                },
+                maxResults: 5,
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(service.generateSuggestions, expectedGenerateSuggestionsRequest);
+        });
+        it('should truncate left and right context', async () => {
+            const BIG_FILE_CONTENT = '123456789\n'.repeat(5000);
+            const BIG_FILE = vscode_languageserver_textdocument_1.TextDocument.create('file:///big_file.cs', 'csharp', 1, BIG_FILE_CONTENT);
+            const cutOffLine = 2000;
+            features.openDocument(BIG_FILE);
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: BIG_FILE.uri },
+                position: { line: cutOffLine, character: 1 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            const leftContentChecker = (leftContent) => leftContent.length == codeWhispererServer_1.CONTEXT_CHARACTERS_LIMIT && leftContent.endsWith('\n1');
+            const rightContentChecker = (rightContent) => rightContent.length == codeWhispererServer_1.CONTEXT_CHARACTERS_LIMIT && rightContent.startsWith('234');
+            ts_sinon_1.default.assert.calledWith(service.generateSuggestions, ts_sinon_1.default.match.hasNested('fileContext.leftFileContent', ts_sinon_1.default.match(leftContentChecker)));
+            ts_sinon_1.default.assert.calledWith(service.generateSuggestions, ts_sinon_1.default.match.hasNested('fileContext.rightFileContent', ts_sinon_1.default.match(rightContentChecker)));
+        });
+        it('should return recommendations when using a different languageId casing', async () => {
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE_WITH_ALT_CASED_LANGUAGE_ID.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT);
+            const expectedGenerateSuggestionsRequest = {
+                fileContext: {
+                    filename: testUtils_1.SOME_FILE_WITH_ALT_CASED_LANGUAGE_ID.uri,
+                    programmingLanguage: { languageName: 'csharp' },
+                    leftFileContent: '',
+                    rightFileContent: testUtils_1.HELLO_WORLD_IN_CSHARP,
+                },
+                maxResults: 5,
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(service.generateSuggestions, expectedGenerateSuggestionsRequest);
+        });
+        it('should not return recommendations for a closed file', async () => {
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_CLOSED_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EMPTY_RESULT);
+            // Check the service was not called
+            ts_sinon_1.default.assert.notCalled(service.generateSuggestions);
+        });
+        it('should not return recommendations for an unsupported file type', async () => {
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_UNSUPPORTED_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EMPTY_RESULT);
+            // Check the service was not called
+            ts_sinon_1.default.assert.notCalled(service.generateSuggestions);
+        });
+        it('should return recommendations based on known extension', async () => {
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE_WITH_EXTENSION.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT);
+            const expectedGenerateSuggestionsRequest = {
+                fileContext: {
+                    filename: testUtils_1.SOME_FILE_WITH_EXTENSION.uri,
+                    programmingLanguage: { languageName: 'cpp' },
+                    leftFileContent: '',
+                    rightFileContent: testUtils_1.HELLO_WORLD_IN_CSHARP,
+                },
+                maxResults: 5,
+            };
+            // Check the service was called with the right parameters
+            ts_sinon_1.default.assert.calledOnceWithExactly(service.generateSuggestions, expectedGenerateSuggestionsRequest);
+        });
+        // Merge right tests
+        it('should not show recommendation when the recommendation is equal to right context', async () => {
+            // The suggestion returned by generateSuggestions will be equal to the contents of the file
+            const EXPECTED_SUGGESTION = [{ itemId: 'cwspr-item-id', content: testUtils_1.HELLO_WORLD_IN_CSHARP }];
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.deepEqual(result, testUtils_1.EMPTY_RESULT);
+        });
+        it('should only show the part of the recommendation that does not overlap with the right context in multiline', async () => {
+            const cutOffLine = 2;
+            const lines = testUtils_1.HELLO_WORLD_IN_CSHARP.split('\n');
+            // The recommendation will be the contents of hello world starting from line 3 (static void Main)
+            const recommendation = lines.slice(cutOffLine).join('\n');
+            // We delete the static void Main line from Hello World but keep the rest in the file
+            const deletedLine = lines.splice(cutOffLine, 1)[0];
+            const finalFileContent = lines.join('\n');
+            const MY_FILE = vscode_languageserver_textdocument_1.TextDocument.create('file:///rightContext.cs', 'csharp', 1, finalFileContent);
+            features.openDocument(MY_FILE);
+            const EXPECTED_SUGGESTION = [{ itemId: 'cwspr-item-id', content: recommendation }];
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            // Expected result is the deleted line + new line + 4 spaces
+            // Newline and the 4 spaces get lost when we do the `split` so we add them back to expected result
+            const EXPECTED_RESULT = {
+                sessionId: testUtils_1.EXPECTED_SESSION_ID,
+                items: [
+                    {
+                        itemId: EXPECTED_SUGGESTION[0].itemId,
+                        insertText: deletedLine.concat('\n    '),
+                        range: undefined,
+                        references: undefined,
+                    },
+                ],
+            };
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: MY_FILE.uri },
+                position: { line: cutOffLine, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.deepEqual(result, EXPECTED_RESULT);
+            const leftContext = lines.slice(0, cutOffLine).join('\n') + '\n';
+            const rightContext = lines.slice(cutOffLine).join('\n');
+            const expectedGenerateSuggestionsRequest = {
+                fileContext: {
+                    filename: MY_FILE.uri,
+                    programmingLanguage: { languageName: 'csharp' },
+                    leftFileContent: leftContext,
+                    rightFileContent: rightContext,
+                },
+                maxResults: 5,
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(service.generateSuggestions, expectedGenerateSuggestionsRequest);
+        });
+        it('should convert windows newlines to UNIX newlines in request file contents', async () => {
+            const cutOffLine = 2;
+            const lines = testUtils_1.HELLO_WORLD_WITH_WINDOWS_ENDING.split('\r\n');
+            const MY_WINDOWS_FILE = vscode_languageserver_textdocument_1.TextDocument.create('file:///rightContext.cs', 'csharp', 1, testUtils_1.HELLO_WORLD_WITH_WINDOWS_ENDING);
+            features.openDocument(MY_WINDOWS_FILE);
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: MY_WINDOWS_FILE.uri },
+                position: { line: cutOffLine, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            const modifiedLeftContext = lines.slice(0, cutOffLine).join('\n') + '\n';
+            const modifiedRightContext = lines.slice(cutOffLine).join('\n');
+            const expectedGenerateSuggestionsRequest = {
+                fileContext: {
+                    filename: MY_WINDOWS_FILE.uri,
+                    programmingLanguage: { languageName: 'csharp' },
+                    leftFileContent: modifiedLeftContext,
+                    rightFileContent: modifiedRightContext,
+                },
+                maxResults: 5,
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(service.generateSuggestions, expectedGenerateSuggestionsRequest);
+        });
+        it('should only show the part of the recommendation that does not overlap with the right context', async () => {
+            const EXPECTED_SUGGESTION = [{ itemId: 'cwspr-item-id', content: testUtils_1.HELLO_WORLD_LINE }];
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            const EXPECTED_RESULT = {
+                sessionId: testUtils_1.EXPECTED_SESSION_ID,
+                items: [
+                    {
+                        itemId: EXPECTED_SUGGESTION[0].itemId,
+                        insertText: testUtils_1.HELLO_WORLD_LINE.substring(0, testUtils_1.SINGLE_LINE_FILE_CUTOFF_INDEX),
+                        range: undefined,
+                        references: undefined,
+                    },
+                ],
+            };
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_SINGLE_LINE_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.deepEqual(result, EXPECTED_RESULT);
+        });
+        it('should show full recommendation when the right context does not match recommendation ', async () => {
+            const EXPECTED_SUGGESTION = [{ itemId: 'cwspr-item-id', content: 'Something something' }];
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            const EXPECTED_RESULT = {
+                sessionId: testUtils_1.EXPECTED_SESSION_ID,
+                items: [
+                    {
+                        itemId: EXPECTED_SUGGESTION[0].itemId,
+                        insertText: EXPECTED_SUGGESTION[0].content,
+                        range: undefined,
+                        references: undefined,
+                    },
+                ],
+            };
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.deepEqual(result, EXPECTED_RESULT);
+        });
+        it('should return empty recommendations list on failed request', async () => {
+            // Plant exception
+            service.generateSuggestions.returns(Promise.reject('UNEXPECTED EXCEPTION'));
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EMPTY_RESULT);
+        });
+        // TODO: mock http request and verify the headers are passed
+        // or spawn an http server and pass it as an endpoint to the sdk client,
+        // mock responses and verify that correct headers are receieved on the server side.
+        // Currently the suite just checks whether the boolean is passed to codeWhispererService
+        describe('Opting out of sending data to CodeWhisperer', () => {
+            it('should send opt-out header when the setting is disabled', async () => {
+                features.lsp.workspace.getConfiguration.returns(Promise.resolve({ shareCodeWhispererContentWithAWS: false }));
+                await features.start(server);
+                assert(service.shareCodeWhispererContentWithAWS === false);
+            });
+            it('should not send opt-out header when the setting is enabled after startup', async () => {
+                features.lsp.workspace.getConfiguration.returns(Promise.resolve({ shareCodeWhispererContentWithAWS: false }));
+                await features.start(server);
+                features.lsp.workspace.getConfiguration.returns(Promise.resolve({ shareCodeWhispererContentWithAWS: true }));
+                await features.openDocument(testUtils_1.SOME_FILE).doChangeConfiguration();
+                assert(service.shareCodeWhispererContentWithAWS === true);
+            });
+            it('should send opt-out header if no settings are specificed', async () => {
+                features.lsp.workspace.getConfiguration.returns(Promise.resolve({}));
+                await features.start(server);
+                assert(service.shareCodeWhispererContentWithAWS === false);
+            });
+        });
+    });
+    describe('Recommendations With References', () => {
+        let features;
+        let server;
+        // TODO move more of the service code out of the stub and into the testable realm
+        // See: https://aws.amazon.com/blogs/developer/mocking-modular-aws-sdk-for-javascript-v3-in-unit-tests/
+        // for examples on how to mock just the SDK client
+        let service;
+        beforeEach(() => {
+            // Set up the server with a mock service, returning predefined recommendations
+            service = (0, ts_sinon_1.stubInterface)();
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: testUtils_1.EXPECTED_SUGGESTION_LIST,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            server = (0, codeWhispererServer_1.CodewhispererServerFactory)(_auth => service);
+            // Initialize the features, but don't start server yet
+            features = new testing_1.TestFeatures();
+        });
+        afterEach(() => {
+            features.dispose();
+        });
+        it('should return all recommendations if no settings are specificed', async () => {
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({}));
+            await features.start(server);
+            const result = await features.openDocument(testUtils_1.SOME_FILE).doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT_WITHOUT_REFERENCES);
+        });
+        it('should filter recommendations with references if GetConfiguration is not handled by the client', async () => {
+            features.lsp.workspace.getConfiguration.returns(Promise.reject(new Error('GetConfiguration failed')));
+            await features.start(server);
+            const result = await features.openDocument(testUtils_1.SOME_FILE).doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT_WITHOUT_REFERENCES);
+        });
+        it('should return all recommendations if settings are true', async () => {
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: true }));
+            await features.start(server);
+            const result = await features.openDocument(testUtils_1.SOME_FILE).doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT_WITH_REFERENCES);
+        });
+        it('should filter recommendations with references if no code references are allowed by settings', async () => {
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: false }));
+            await features.start(server);
+            const result = await features.openDocument(testUtils_1.SOME_FILE).doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT_WITHOUT_REFERENCES);
+        });
+        it('should filter recommendations with references if code references are disabled after startup', async () => {
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: true }));
+            await features.start(server);
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: false }));
+            const afterConfigChange = await features.openDocument(testUtils_1.SOME_FILE).doChangeConfiguration();
+            const result = await afterConfigChange.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT_WITHOUT_REFERENCES);
+        });
+        it('should filter recommendations with references if code references are enabled after startup', async () => {
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: false }));
+            await features.start(server);
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: true }));
+            const afterConfigChange = await features.openDocument(testUtils_1.SOME_FILE).doChangeConfiguration();
+            const result = await afterConfigChange.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT_WITH_REFERENCES);
+        });
+        it('should not show references when the right context is equal to suggestion', async () => {
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: true }));
+            await features.start(server);
+            const EXPECTED_SUGGESTION = [{ itemId: 'cwspr-item-id', content: testUtils_1.HELLO_WORLD_IN_CSHARP }];
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            const result = await features.openDocument(testUtils_1.SOME_FILE).doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.deepEqual(result, testUtils_1.EMPTY_RESULT);
+        });
+        it('should show references and update range when there is partial overlap on right context', async () => {
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: true }));
+            await features.start(server);
+            const cutOffLine = 2;
+            const lines = testUtils_1.HELLO_WORLD_IN_CSHARP.split('\n');
+            // The recommendation will be the contents of hello world starting from line 3 (static void Main)
+            const recommendation = lines.slice(cutOffLine).join('\n');
+            // We delete the static void Main line from Hello World but keep the rest in the file
+            const deletedLine = lines.splice(cutOffLine, 1)[0];
+            const finalFileContent = lines.join('\n');
+            const MY_FILE = vscode_languageserver_textdocument_1.TextDocument.create('file:///rightContext.cs', 'csharp', 1, finalFileContent);
+            features.openDocument(MY_FILE);
+            const EXPECTED_REFERENCE_WITH_LONG_RANGE = {
+                ...testUtils_1.EXPECTED_REFERENCE,
+                recommendationContentSpan: { start: 0, end: testUtils_1.HELLO_WORLD_IN_CSHARP.length },
+            };
+            const EXPECTED_SUGGESTION = [
+                { itemId: 'cwspr-item-id', content: recommendation, references: [EXPECTED_REFERENCE_WITH_LONG_RANGE] },
+            ];
+            const insertText = deletedLine.concat('\n    ');
+            const EXPECTED_RESULT = {
+                sessionId: testUtils_1.EXPECTED_SESSION_ID,
+                items: [
+                    {
+                        itemId: EXPECTED_SUGGESTION[0].itemId,
+                        insertText: insertText,
+                        range: undefined,
+                        references: [
+                            {
+                                licenseName: EXPECTED_REFERENCE_WITH_LONG_RANGE.licenseName,
+                                referenceName: EXPECTED_REFERENCE_WITH_LONG_RANGE.repository,
+                                referenceUrl: EXPECTED_REFERENCE_WITH_LONG_RANGE.url,
+                                position: {
+                                    startCharacter: EXPECTED_REFERENCE_WITH_LONG_RANGE.recommendationContentSpan?.start,
+                                    endCharacter: insertText.length - 1,
+                                },
+                            },
+                        ],
+                    },
+                ],
+            };
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            const result = await features.openDocument(MY_FILE).doInlineCompletionWithReferences({
+                textDocument: { uri: MY_FILE.uri },
+                position: { line: cutOffLine, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.deepEqual(result, EXPECTED_RESULT);
+        });
+        it('should discard reference if it references trimmed content after right-context merge', async () => {
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: true }));
+            await features.start(server);
+            const cutOffLine = 2;
+            const lines = testUtils_1.HELLO_WORLD_IN_CSHARP.split('\n');
+            // The recommendation will be the contents of hello world starting from line 3 (static void Main)
+            const recommendation = lines.slice(cutOffLine).join('\n');
+            // We delete the static void Main line from Hello World but keep the rest in the file
+            const deletedLine = lines.splice(cutOffLine, 1)[0];
+            const finalFileContent = lines.join('\n');
+            const MY_FILE = vscode_languageserver_textdocument_1.TextDocument.create('file:///rightContext.cs', 'csharp', 1, finalFileContent);
+            features.openDocument(MY_FILE);
+            const insertText = deletedLine.concat('\n    ');
+            // reference range covers portion of string that will be removed
+            const EXPECTED_REFERENCE_WITH_OUTER_RANGE = {
+                ...testUtils_1.EXPECTED_REFERENCE,
+                recommendationContentSpan: { start: insertText.length, end: recommendation.length },
+            };
+            const EXPECTED_SUGGESTION = [
+                { itemId: 'cwspr-item-id', content: recommendation, references: [EXPECTED_REFERENCE_WITH_OUTER_RANGE] },
+            ];
+            const EXPECTED_RESULT = {
+                sessionId: testUtils_1.EXPECTED_SESSION_ID,
+                items: [
+                    {
+                        itemId: EXPECTED_SUGGESTION[0].itemId,
+                        insertText: insertText,
+                        range: undefined,
+                        references: undefined,
+                    },
+                ],
+            };
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            const result = await features.openDocument(MY_FILE).doInlineCompletionWithReferences({
+                textDocument: { uri: MY_FILE.uri },
+                position: { line: cutOffLine, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.deepEqual(result, EXPECTED_RESULT);
+        });
+        describe('With session management', () => {
+            it('should close session if code references are disabled and all suggestions had references', async () => {
+                const EXPECTED_SUGGESTION_WITH_REFERENCES = [
+                    {
+                        itemId: 'cwspr-item-id-1',
+                        content: 'recommendation with reference',
+                        references: [testUtils_1.EXPECTED_REFERENCE],
+                    },
+                ];
+                service.generateSuggestions.returns(Promise.resolve({
+                    suggestions: EXPECTED_SUGGESTION_WITH_REFERENCES,
+                    responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+                }));
+                features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: false }));
+                await features.start(server);
+                const result = await features.openDocument(testUtils_1.SOME_FILE).doInlineCompletionWithReferences({
+                    textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                    position: { line: 0, character: 0 },
+                    context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+                }, vscode_languageserver_1.CancellationToken.None);
+                // Check the completion result
+                assert.deepEqual(result, testUtils_1.EMPTY_RESULT);
+                // There is no active session
+                assert.equal(sessionManager.getActiveSession(), undefined);
+                assert.equal(sessionManagerSpy.createSession.callCount, 1);
+                assert.equal(sessionManagerSpy.closeSession.callCount, 1);
+            });
+        });
+    });
+    describe('With auto-triggers', async () => {
+        const AUTO_TRIGGER_POSITION = { line: 2, character: 21 };
+        const LEFT_FILE_CONTEXT = testUtils_1.HELLO_WORLD_IN_CSHARP.substring(0, 40);
+        const RIGHT_FILE_CONTEXT = testUtils_1.HELLO_WORLD_IN_CSHARP.substring(40);
+        let features;
+        let server;
+        // TODO move more of the service code out of the stub and into the testable realm
+        // See: https://aws.amazon.com/blogs/developer/mocking-modular-aws-sdk-for-javascript-v3-in-unit-tests/
+        // for examples on how to mock just the SDK client
+        let service;
+        beforeEach(async () => {
+            // Set up the server with a mock service, returning predefined recommendations
+            service = (0, ts_sinon_1.stubInterface)();
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: testUtils_1.EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            server = (0, codeWhispererServer_1.CodewhispererServerFactory)(_auth => service);
+            // Initialize the features, but don't start server yet
+            features = new testing_1.TestFeatures();
+            // Return no specific configuration for CodeWhisperer
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({}));
+            // Start the server and open a document
+            await features.start(server);
+            features.openDocument(testUtils_1.SOME_FILE);
+        });
+        afterEach(() => {
+            features.dispose();
+        });
+        it('should return recommendations on an above-threshold auto-trigger position', async () => {
+            // Similar to test from above, this test case also depends on file contents not starting with a new line
+            const HELLO_WORLD_IN_CSHARP_WITHOUT_NEWLINE = testUtils_1.HELLO_WORLD_IN_CSHARP.trimStart();
+            const SOME_FILE = vscode_languageserver_textdocument_1.TextDocument.create('file:///test.cs', 'csharp', 1, HELLO_WORLD_IN_CSHARP_WITHOUT_NEWLINE);
+            features.openDocument(SOME_FILE);
+            const LEFT_FILE_CONTEXT = HELLO_WORLD_IN_CSHARP_WITHOUT_NEWLINE.substring(0, 40);
+            const RIGHT_FILE_CONTEXT = HELLO_WORLD_IN_CSHARP_WITHOUT_NEWLINE.substring(40);
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: SOME_FILE.uri },
+                position: AUTO_TRIGGER_POSITION,
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT);
+            const expectedGenerateSuggestionsRequest = {
+                fileContext: {
+                    filename: SOME_FILE.uri,
+                    programmingLanguage: { languageName: 'csharp' },
+                    leftFileContent: LEFT_FILE_CONTEXT,
+                    rightFileContent: RIGHT_FILE_CONTEXT,
+                },
+                maxResults: 1,
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(service.generateSuggestions, expectedGenerateSuggestionsRequest);
+        });
+        it('shoud not return recommendations on a below-threshold auto-trigger position', async () => {
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Check the completion result
+            assert.deepEqual(result, testUtils_1.EMPTY_RESULT);
+        });
+    });
+    describe('Log Inline Completion Session Results', () => {
+        const requestContext = {
+            maxResults: 5,
+            fileContext: {
+                filename: 'SomeFile',
+                programmingLanguage: { languageName: 'csharp' },
+                leftFileContent: 'LeftFileContent',
+                rightFileContent: 'RightFileContent',
+            },
+        };
+        const sessionData = {
+            startPosition: { line: 0, character: 0 },
+            triggerType: 'OnDemand',
+            language: 'csharp',
+            requestContext: requestContext,
+        };
+        const sessionResultData = {
+            sessionId: 'some-random-session-uuid-0',
+            completionSessionResult: {
+                'cwspr-item-id': {
+                    seen: true,
+                    accepted: false,
+                    discarded: false,
+                },
+            },
+            firstCompletionDisplayLatency: 50,
+            totalSessionDisplayTime: 1000,
+        };
+        let features;
+        let server;
+        // TODO move more of the service code out of the stub and into the testable realm
+        // See: https://aws.amazon.com/blogs/developer/mocking-modular-aws-sdk-for-javascript-v3-in-unit-tests/
+        // for examples on how to mock just the SDK client
+        let service;
+        beforeEach(async () => {
+            // Set up the server with a mock service, returning predefined recommendations
+            service = (0, ts_sinon_1.stubInterface)();
+            server = (0, codeWhispererServer_1.CodewhispererServerFactory)(_auth => service);
+            // Initialize the features, but don't start server yet
+            features = new testing_1.TestFeatures();
+            // Start the server and open a document
+            await features.start(server);
+            features.openDocument(testUtils_1.SOME_FILE);
+        });
+        afterEach(() => {
+            features.dispose();
+        });
+        it('should deactivate current session when session result for current session is sent', async () => {
+            const manager = sessionManager_1.SessionManager.getInstance();
+            const session = manager.createSession(sessionData);
+            manager.activateSession(session);
+            assert.equal(session.state, 'ACTIVE');
+            await features.doLogInlineCompletionSessionResults(sessionResultData);
+            assert.equal(session.state, 'CLOSED');
+        });
+        it('should not close current session when session result for different session is sent', async () => {
+            const manager = sessionManager_1.SessionManager.getInstance();
+            const session = manager.createSession(sessionData);
+            manager.activateSession(session);
+            const session2 = manager.createSession(sessionData);
+            manager.activateSession(session2);
+            assert.equal(session.state, 'CLOSED');
+            assert.equal(session2.state, 'ACTIVE');
+            await features.doLogInlineCompletionSessionResults(sessionResultData);
+            assert.equal(session2.state, 'ACTIVE');
+        });
+        it('should store session result data', async () => {
+            const manager = sessionManager_1.SessionManager.getInstance();
+            const session = manager.createSession(sessionData);
+            manager.activateSession(session);
+            await features.doLogInlineCompletionSessionResults(sessionResultData);
+            assert.equal(session.completionSessionResult, sessionResultData.completionSessionResult);
+            assert.equal(session.firstCompletionDisplayLatency, sessionResultData.firstCompletionDisplayLatency);
+            assert.equal(session.totalSessionDisplayTime, sessionResultData.totalSessionDisplayTime);
+        });
+        it('should store session result data with only completion state provided', async () => {
+            const sessionResultData = {
+                sessionId: 'some-random-session-uuid-0',
+                completionSessionResult: {
+                    'cwspr-item-id': {
+                        seen: true,
+                        accepted: false,
+                        discarded: false,
+                    },
+                },
+            };
+            const manager = sessionManager_1.SessionManager.getInstance();
+            const session = manager.createSession(sessionData);
+            manager.activateSession(session);
+            await features.doLogInlineCompletionSessionResults(sessionResultData);
+            assert.equal(session.completionSessionResult, sessionResultData.completionSessionResult);
+            assert.equal(session.firstCompletionDisplayLatency, undefined);
+            assert.equal(session.totalSessionDisplayTime, undefined);
+        });
+    });
+    describe('Telemetry', () => {
+        const EXPECTED_RESPONSE_CONTEXT = {
+            requestId: 'cwspr-request-id',
+            codewhispererSessionId: 'cwspr-session-id',
+        };
+        const sessionResultData = {
+            sessionId: 'some-random-session-uuid-0',
+            completionSessionResult: {
+                'cwspr-item-id': {
+                    seen: true,
+                    accepted: false,
+                    discarded: false,
+                },
+            },
+            firstCompletionDisplayLatency: 50,
+            totalSessionDisplayTime: 1000,
+        };
+        let features;
+        let server;
+        // TODO move more of the service code out of the stub and into the testable realm
+        // See: https://aws.amazon.com/blogs/developer/mocking-modular-aws-sdk-for-javascript-v3-in-unit-tests/
+        // for examples on how to mock just the SDK client
+        let service;
+        let clock;
+        beforeEach(async () => {
+            clock = ts_sinon_1.default.useFakeTimers({
+                now: 1483228800000,
+            });
+            // Set up the server with a mock service, returning predefined recommendations
+            service = (0, ts_sinon_1.stubInterface)();
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: testUtils_1.EXPECTED_SUGGESTION,
+                responseContext: EXPECTED_RESPONSE_CONTEXT,
+            }));
+            server = (0, codeWhispererServer_1.CodewhispererServerFactory)(_auth => service);
+            // Initialize the features, but don't start server yet
+            features = new testing_1.TestFeatures();
+            // Return no specific configuration for CodeWhisperer
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({}));
+            // Start the server and open a document
+            await features.start(server);
+            features.openDocument(testUtils_1.SOME_FILE);
+        });
+        afterEach(async () => {
+            clock.restore();
+            features.dispose();
+        });
+        it('should emit Success ServiceInvocation telemetry on successful response', async () => {
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            const expectedServiceInvocationMetric = {
+                name: 'codewhisperer_serviceInvocation',
+                result: 'Succeeded',
+                data: {
+                    codewhispererRequestId: 'cwspr-request-id',
+                    codewhispererSessionId: 'cwspr-session-id',
+                    codewhispererLastSuggestionIndex: 0,
+                    codewhispererCompletionType: 'Line',
+                    codewhispererTriggerType: 'OnDemand',
+                    codewhispererAutomatedTriggerType: undefined,
+                    duration: 0,
+                    codewhispererLineNumber: 0,
+                    codewhispererCursorOffset: 0,
+                    codewhispererLanguage: 'csharp',
+                    credentialStartUrl: undefined,
+                },
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(features.telemetry.emitMetric, expectedServiceInvocationMetric);
+        });
+        it('should emit Success ServiceInvocation telemetry on successful response with completionType block when first suggestion has new lines', async () => {
+            const recommendation = ['multi', 'line', ' suggestion'].join('\n');
+            const EXPECTED_SUGGESTIONS = [
+                { itemId: 'cwspr-item-id-1', content: recommendation },
+                { itemId: 'cwspr-item-id-2', content: recommendation },
+                { itemId: 'cwspr-item-id-3', content: recommendation },
+            ];
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: EXPECTED_SUGGESTIONS,
+                responseContext: EXPECTED_RESPONSE_CONTEXT,
+            }));
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            const expectedServiceInvocationMetric = {
+                name: 'codewhisperer_serviceInvocation',
+                result: 'Succeeded',
+                data: {
+                    codewhispererRequestId: 'cwspr-request-id',
+                    codewhispererSessionId: 'cwspr-session-id',
+                    codewhispererLastSuggestionIndex: 2,
+                    codewhispererCompletionType: 'Block',
+                    codewhispererTriggerType: 'OnDemand',
+                    codewhispererAutomatedTriggerType: undefined,
+                    duration: 0,
+                    codewhispererLineNumber: 0,
+                    codewhispererCursorOffset: 0,
+                    codewhispererLanguage: 'csharp',
+                    credentialStartUrl: undefined,
+                },
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(features.telemetry.emitMetric, expectedServiceInvocationMetric);
+        });
+        it('should emit Failure ServiceInvocation telemetry on failed response', async () => {
+            const error = new Error('UNEXPECTED EXCEPTION');
+            error.name = 'TestError';
+            service.generateSuggestions.returns(Promise.reject(error));
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            const expectedServiceInvocationMetric = {
+                name: 'codewhisperer_serviceInvocation',
+                result: 'Failed',
+                data: {
+                    codewhispererRequestId: undefined,
+                    codewhispererSessionId: undefined,
+                    codewhispererLastSuggestionIndex: -1,
+                    codewhispererTriggerType: 'OnDemand',
+                    codewhispererAutomatedTriggerType: undefined,
+                    reason: 'CodeWhisperer Invocation Exception: TestError',
+                    duration: 0,
+                    codewhispererLineNumber: 0,
+                    codewhispererCursorOffset: 0,
+                    codewhispererLanguage: 'csharp',
+                    credentialStartUrl: undefined,
+                },
+                errorData: {
+                    reason: 'TestError',
+                    errorCode: undefined,
+                    httpStatusCode: undefined,
+                },
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(features.telemetry.emitMetric, expectedServiceInvocationMetric);
+        });
+        it('should emit error with UnknownError reason if error name is not present', async () => {
+            service.generateSuggestions.returns(Promise.reject('UNEXPECTED EXCEPTION'));
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            const expectedServiceInvocationMetric = {
+                name: 'codewhisperer_serviceInvocation',
+                result: 'Failed',
+                data: {
+                    codewhispererRequestId: undefined,
+                    codewhispererSessionId: undefined,
+                    codewhispererLastSuggestionIndex: -1,
+                    codewhispererTriggerType: 'OnDemand',
+                    codewhispererAutomatedTriggerType: undefined,
+                    reason: 'CodeWhisperer Invocation Exception: UnknownError',
+                    duration: 0,
+                    codewhispererLineNumber: 0,
+                    codewhispererCursorOffset: 0,
+                    codewhispererLanguage: 'csharp',
+                    credentialStartUrl: undefined,
+                },
+                errorData: {
+                    reason: 'UnknownError',
+                    errorCode: undefined,
+                    httpStatusCode: undefined,
+                },
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(features.telemetry.emitMetric, expectedServiceInvocationMetric);
+        });
+        it('should emit Failure ServiceInvocation telemetry with request metadata on failed response with AWSError error type', async () => {
+            const error = new Error('Fake Error');
+            error.name = 'TestAWSError';
+            error.code = 'TestErrorStatusCode';
+            error.statusCode = 500;
+            error.time = new Date();
+            error.requestId = 'failed-request-id';
+            service.generateSuggestions.callsFake(_request => {
+                clock.tick(1000);
+                return Promise.reject(error);
+            });
+            const getCompletionsPromise = features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            await getCompletionsPromise;
+            const expectedServiceInvocationMetric = {
+                name: 'codewhisperer_serviceInvocation',
+                result: 'Failed',
+                data: {
+                    codewhispererRequestId: 'failed-request-id',
+                    codewhispererSessionId: undefined,
+                    codewhispererLastSuggestionIndex: -1,
+                    codewhispererTriggerType: 'OnDemand',
+                    codewhispererAutomatedTriggerType: undefined,
+                    reason: 'CodeWhisperer Invocation Exception: TestAWSError',
+                    duration: 1000,
+                    codewhispererLineNumber: 0,
+                    codewhispererCursorOffset: 0,
+                    codewhispererLanguage: 'csharp',
+                    credentialStartUrl: undefined,
+                },
+                errorData: {
+                    reason: 'TestAWSError',
+                    errorCode: 'TestErrorStatusCode',
+                    httpStatusCode: 500,
+                },
+            };
+            ts_sinon_1.default.assert.calledOnceWithExactly(features.telemetry.emitMetric, expectedServiceInvocationMetric);
+        });
+        it('should emit Perceived Latency metric when session result is received', async () => {
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            await features.doLogInlineCompletionSessionResults(sessionResultData);
+            const expectedPerceivedLatencyMetric = {
+                name: 'codewhisperer_perceivedLatency',
+                data: {
+                    codewhispererRequestId: EXPECTED_RESPONSE_CONTEXT.requestId,
+                    codewhispererSessionId: EXPECTED_RESPONSE_CONTEXT.codewhispererSessionId,
+                    codewhispererCompletionType: 'Line',
+                    codewhispererTriggerType: 'OnDemand',
+                    duration: 50,
+                    codewhispererLanguage: 'csharp',
+                    credentialStartUrl: undefined,
+                },
+            };
+            ts_sinon_1.default.assert.calledWithExactly(features.telemetry.emitMetric, expectedPerceivedLatencyMetric);
+        });
+        it('should not emit Perceived Latency metric when firstCompletionDisplayLatency is absent', async () => {
+            const sessionResultDataWithoutLatency = {
+                ...sessionResultData,
+                firstCompletionDisplayLatency: undefined,
+            };
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            await features.doLogInlineCompletionSessionResults(sessionResultDataWithoutLatency);
+            ts_sinon_1.default.assert.neverCalledWith(features.telemetry.emitMetric, ts_sinon_1.default.match.has('name', 'codewhisperer_perceivedLatency'));
+        });
+        describe('Connection metadata credentialStartUrl field', () => {
+            it('should attach credentialStartUrl field if available in credentialsProvider', async () => {
+                features.credentialsProvider.getConnectionMetadata.returns({
+                    sso: {
+                        startUrl: 'http://teststarturl',
+                    },
+                });
+                await features.doInlineCompletionWithReferences({
+                    textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                    position: { line: 0, character: 0 },
+                    context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+                }, vscode_languageserver_1.CancellationToken.None);
+                assert.equal(features.telemetry.emitMetric.getCall(0).args[0].data.credentialStartUrl, 'http://teststarturl');
+            });
+            it('should send empty credentialStartUrl field if not available in credentialsProvider', async () => {
+                features.credentialsProvider.getConnectionMetadata.returns(undefined);
+                await features.doInlineCompletionWithReferences({
+                    textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                    position: { line: 0, character: 0 },
+                    context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+                }, vscode_languageserver_1.CancellationToken.None);
+                assert.equal(features.telemetry.emitMetric.getCall(0).args[0].data.credentialStartUrl, undefined);
+            });
+        });
+    });
+    describe('Recommendations session management', () => {
+        const AUTO_TRIGGER_POSITION = { line: 2, character: 21 };
+        let features;
+        let server;
+        // TODO move more of the service code out of the stub and into the testable realm
+        // See: https://aws.amazon.com/blogs/developer/mocking-modular-aws-sdk-for-javascript-v3-in-unit-tests/
+        // for examples on how to mock just the SDK client
+        let service;
+        let clock;
+        beforeEach(async () => {
+            clock = ts_sinon_1.default.useFakeTimers({
+                now: 1483228800000,
+            });
+            // Set up the server with a mock service, returning predefined recommendations
+            service = (0, ts_sinon_1.stubInterface)();
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: testUtils_1.EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            server = (0, codeWhispererServer_1.CodewhispererServerFactory)(_auth => service);
+            // Initialize the features, but don't start server yet
+            features = new testing_1.TestFeatures();
+            // Return no specific configuration for CodeWhisperer
+            features.lsp.workspace.getConfiguration.returns(Promise.resolve({}));
+            // Start the server and open a document
+            await features.start(server);
+            features.openDocument(testUtils_1.SOME_FILE).openDocument(testUtils_1.SOME_FILE_WITH_ALT_CASED_LANGUAGE_ID);
+        });
+        afterEach(() => {
+            clock.restore();
+            features.dispose();
+        });
+        it('should cache new session on new request when no session exists', async () => {
+            let activeSession = sessionManager.getCurrentSession();
+            assert.equal(activeSession, undefined);
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: AUTO_TRIGGER_POSITION,
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Get session after call is done
+            activeSession = sessionManager.getCurrentSession();
+            const expectedSessionData = {
+                id: SESSION_IDS_LOG[0],
+                state: 'ACTIVE',
+                suggestions: [{ itemId: 'cwspr-item-id', content: 'recommendation' }],
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+                codewhispererSessionId: testUtils_1.EXPECTED_RESPONSE_CONTEXT.codewhispererSessionId,
+                timeToFirstRecommendation: 0,
+            };
+            assert(activeSession);
+            ts_sinon_1.default.assert.match({
+                id: activeSession.id,
+                state: activeSession.state,
+                suggestions: activeSession.suggestions,
+                responseContext: activeSession.responseContext,
+                codewhispererSessionId: activeSession.codewhispererSessionId,
+                timeToFirstRecommendation: activeSession.timeToFirstRecommendation,
+            }, expectedSessionData);
+        });
+        it('should discard inflight session on new request when cached session is in REQUESTING state on subsequent requests', async () => {
+            const getCompletionsResponses = await Promise.all([
+                features.doInlineCompletionWithReferences({
+                    textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                    position: AUTO_TRIGGER_POSITION,
+                    context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+                }, vscode_languageserver_1.CancellationToken.None),
+                features.doInlineCompletionWithReferences({
+                    textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                    position: AUTO_TRIGGER_POSITION,
+                    context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+                }, vscode_languageserver_1.CancellationToken.None),
+                features.doInlineCompletionWithReferences({
+                    textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                    position: AUTO_TRIGGER_POSITION,
+                    context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+                }, vscode_languageserver_1.CancellationToken.None),
+            ]);
+            // 3 requests were processed by server, but only first should return results
+            const EXPECTED_COMPLETION_RESPONSES = [
+                { sessionId: '', items: [] },
+                { sessionId: '', items: [] },
+                { sessionId: SESSION_IDS_LOG[2], items: testUtils_1.EXPECTED_RESULT.items }, // Last session wins
+            ];
+            // Only last request must return completion items
+            assert.deepEqual(getCompletionsResponses, EXPECTED_COMPLETION_RESPONSES);
+            assert.equal(sessionManagerSpy.createSession.callCount, 3);
+            // Get session after call is done
+            const activeSession = sessionManager.getCurrentSession();
+            // 3 sessions were created
+            assert.equal(SESSION_IDS_LOG.length, 3);
+            // Last session is ACTIVE stored in manager correctly
+            const expectedSessionData = {
+                id: SESSION_IDS_LOG[2],
+                state: 'ACTIVE',
+                suggestions: [{ itemId: 'cwspr-item-id', content: 'recommendation' }],
+            };
+            assert(activeSession);
+            ts_sinon_1.default.assert.match({
+                id: activeSession.id,
+                state: activeSession.state,
+                suggestions: activeSession.suggestions,
+            }, expectedSessionData);
+        });
+        it('should record all sessions that were created in session log', async () => {
+            // Start 3 session, 2 will be cancelled inflight
+            await Promise.all([
+                features.doInlineCompletionWithReferences({
+                    textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                    position: AUTO_TRIGGER_POSITION,
+                    context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+                }, vscode_languageserver_1.CancellationToken.None),
+                features.doInlineCompletionWithReferences({
+                    textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                    position: AUTO_TRIGGER_POSITION,
+                    context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+                }, vscode_languageserver_1.CancellationToken.None),
+                features.doInlineCompletionWithReferences({
+                    textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                    position: AUTO_TRIGGER_POSITION,
+                    context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+                }, vscode_languageserver_1.CancellationToken.None),
+            ]);
+            // Get session after call is done
+            const firstActiveSession = sessionManager.getCurrentSession();
+            // Do another request, which will close last ACTIVE session
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: AUTO_TRIGGER_POSITION,
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.equal(sessionManagerSpy.createSession.callCount, 4);
+            assert.equal(sessionManager.getSessionsLog().length, 4);
+            const latestSession = sessionManager.getCurrentSession();
+            assert.equal(latestSession, sessionManager.getActiveSession());
+            assert.equal(latestSession, sessionManager.getCurrentSession());
+            // All sessions
+            assert.equal(firstActiveSession?.id, 'some-random-session-uuid-2');
+        });
+        it('should close new session on new request when service returns empty list', async () => {
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: [],
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            const activeSession = sessionManager.getCurrentSession();
+            assert.equal(activeSession, undefined);
+            await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: AUTO_TRIGGER_POSITION,
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Automatic },
+            }, vscode_languageserver_1.CancellationToken.None);
+            // Get session after call is done
+            const currentSession = sessionManager.getCurrentSession();
+            assert(currentSession);
+            assert.equal(currentSession?.state, 'CLOSED');
+            ts_sinon_1.default.assert.calledOnceWithExactly(sessionManagerSpy.closeSession, currentSession);
+        });
+        it('Manual completion invocation should close previous session', async () => {
+            const TRIGGER_KIND = vscode_languageserver_1.InlineCompletionTriggerKind.Invoked;
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                // Manual trigger kind
+                context: { triggerKind: TRIGGER_KIND },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.deepEqual(result, testUtils_1.EXPECTED_RESULT);
+            const firstSession = sessionManager.getActiveSession();
+            // There is ACTIVE session
+            assert(firstSession);
+            assert.equal(sessionManager.getCurrentSession(), firstSession);
+            assert.equal(firstSession.state, 'ACTIVE');
+            const secondResult = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: testUtils_1.SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: TRIGGER_KIND },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.deepEqual(secondResult, { ...testUtils_1.EXPECTED_RESULT, sessionId: SESSION_IDS_LOG[1] });
+            ts_sinon_1.default.assert.called(sessionManagerSpy.closeCurrentSession);
+        });
+        it('should discard inflight session if merge right recommendations resulted in list of empty strings', async () => {
+            // The suggestion returned by generateSuggestions will be equal to the contents of the file
+            // This test fails when the file starts with a new line, probably due to the way we handle right context merge
+            // So let's use hello world without the newline in the beginning
+            const HELLO_WORLD_IN_CSHARP_WITHOUT_NEWLINE = testUtils_1.HELLO_WORLD_IN_CSHARP.trimStart();
+            const SOME_FILE = vscode_languageserver_textdocument_1.TextDocument.create('file:///test.cs', 'csharp', 1, HELLO_WORLD_IN_CSHARP_WITHOUT_NEWLINE);
+            features.openDocument(SOME_FILE);
+            const EXPECTED_SUGGESTION = [
+                { itemId: 'cwspr-item-id', content: HELLO_WORLD_IN_CSHARP_WITHOUT_NEWLINE },
+            ];
+            service.generateSuggestions.returns(Promise.resolve({
+                suggestions: EXPECTED_SUGGESTION,
+                responseContext: testUtils_1.EXPECTED_RESPONSE_CONTEXT,
+            }));
+            const result = await features.doInlineCompletionWithReferences({
+                textDocument: { uri: SOME_FILE.uri },
+                position: { line: 0, character: 0 },
+                context: { triggerKind: vscode_languageserver_1.InlineCompletionTriggerKind.Invoked },
+            }, vscode_languageserver_1.CancellationToken.None);
+            assert.deepEqual(result, testUtils_1.EMPTY_RESULT);
+            const session = sessionManager.getCurrentSession();
+            assert(session);
+            assert(session.state, 'CLOSED');
+            ts_sinon_1.default.assert.calledOnce(sessionManagerSpy.closeSession);
+        });
+    });
+});
+//# sourceMappingURL=codeWhispererServer.test.js.map