@aws/lsp-codewhisperer 0.0.26 → 0.0.28

package/out/language-server/telemetry/userTriggerDecision.test.js

@@ -1,1348 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const server_interface_1 = require("@aws/language-server-runtimes/server-interface");
-const testing_1 = require("@aws/language-server-runtimes/testing");
-const assert = require("assert");
-const ts_sinon_1 = require("ts-sinon");
-const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
-const codeWhispererServer_1 = require("../codeWhispererServer");
-const sessionManager_1 = require("../session/sessionManager");
-const telemetryService_1 = require("../telemetryService");
-describe('Telemetry', () => {
-    const sandbox = ts_sinon_1.default.createSandbox();
-    let SESSION_IDS_LOG = [];
-    let sessionManager;
-    let sessionManagerSpy;
-    let generateSessionIdStub;
-    let clock;
-    let telemetryServiceSpy;
-    beforeEach(() => {
-        const StubSessionIdGenerator = () => {
-            let 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_1.SessionManager.reset();
-        sessionManager = sessionManager_1.SessionManager.getInstance();
-        sessionManagerSpy = sandbox.spy(sessionManager);
-        SESSION_IDS_LOG = [];
-        clock = ts_sinon_1.default.useFakeTimers({
-            now: 1483228800000,
-        });
-        telemetryServiceSpy = ts_sinon_1.default.spy(telemetryService_1.TelemetryService.prototype, 'emitUserTriggerDecision');
-    });
-    afterEach(() => {
-        generateSessionIdStub.restore();
-        clock.restore();
-        sandbox.restore();
-        telemetryServiceSpy.restore();
-    });
-    describe('User Trigger Decision telemetry', () => {
-        const HELLO_WORLD_IN_CSHARP = `class HelloWorld
-{
-    static void Main()
-    {
-        Console.WriteLine("Hello World!");
-    }
-}
-`;
-        const AUTO_TRIGGER_POSITION = { line: 2, character: 21 };
-        const SOME_FILE = vscode_languageserver_textdocument_1.TextDocument.create('file:///test.cs', 'csharp', 1, HELLO_WORLD_IN_CSHARP);
-        const SOME_FILE_WITH_ALT_CASED_LANGUAGE_ID = vscode_languageserver_textdocument_1.TextDocument.create(
-        // Use unsupported extension, so that we can test that we get a match based on the LanguageId
-        'file:///test.seesharp', 'CSharp', 1, HELLO_WORLD_IN_CSHARP);
-        const EXPECTED_REFERENCE = {
-            licenseName: 'test license',
-            repository: 'test repository',
-            url: 'test url',
-            recommendationContentSpan: { start: 0, end: 1 },
-        };
-        const DEFAULT_SUGGESTIONS = [
-            { itemId: 'cwspr-item-id-1', content: 'recommendation' },
-            { itemId: 'cwspr-item-id-2', content: 'recommendation' },
-            { itemId: 'cwspr-item-id-3', content: 'recommendation' },
-        ];
-        const EXPECTED_RESULT = {
-            sessionId: 'some-random-session-uuid-0',
-            items: [
-                {
-                    itemId: DEFAULT_SUGGESTIONS[0].itemId,
-                    insertText: DEFAULT_SUGGESTIONS[0].content,
-                    range: undefined,
-                    references: undefined,
-                },
-                {
-                    itemId: DEFAULT_SUGGESTIONS[1].itemId,
-                    insertText: DEFAULT_SUGGESTIONS[1].content,
-                    range: undefined,
-                    references: undefined,
-                },
-                {
-                    itemId: DEFAULT_SUGGESTIONS[2].itemId,
-                    insertText: DEFAULT_SUGGESTIONS[2].content,
-                    range: undefined,
-                    references: undefined,
-                },
-            ],
-        };
-        const EXPECTED_RESPONSE_CONTEXT = {
-            requestId: 'cwspr-request-id',
-            codewhispererSessionId: 'cwspr-session-id',
-        };
-        const DEFAULT_SESSION_RESULT_DATA = {
-            sessionId: 'some-random-session-uuid-0',
-            completionSessionResult: {
-                'cwspr-item-id-1': {
-                    seen: true,
-                    accepted: false,
-                    discarded: false,
-                },
-                'cwspr-item-id-2': {
-                    seen: true,
-                    accepted: false,
-                    discarded: false,
-                },
-                'cwspr-item-id-3': {
-                    seen: true,
-                    accepted: false,
-                    discarded: false,
-                },
-            },
-        };
-        const EMPTY_RESULT = { items: [], sessionId: '' };
-        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;
-        const setServiceResponse = (suggestions, responseContext, time = 2000) => {
-            service.generateSuggestions.callsFake(_request => {
-                clock.tick(time);
-                return Promise.resolve({
-                    suggestions,
-                    responseContext,
-                });
-            });
-        };
-        const autoTriggerInlineCompletionWithReferences = async () => await features.doInlineCompletionWithReferences({
-            textDocument: { uri: SOME_FILE.uri },
-            position: AUTO_TRIGGER_POSITION,
-            context: { triggerKind: server_interface_1.InlineCompletionTriggerKind.Automatic },
-        }, server_interface_1.CancellationToken.None);
-        const manualTriggerInlineCompletionWithReferences = async () => await features.doInlineCompletionWithReferences({
-            textDocument: { uri: SOME_FILE.uri },
-            position: { line: 0, character: 0 },
-            context: { triggerKind: server_interface_1.InlineCompletionTriggerKind.Invoked },
-        }, server_interface_1.CancellationToken.None);
-        beforeEach(async () => {
-            // Set up the server with a mock service, returning predefined recommendations
-            service = (0, ts_sinon_1.stubInterface)();
-            setServiceResponse(DEFAULT_SUGGESTIONS, 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({}));
-            // Return credentialsStartUrl value
-            features.credentialsProvider.getConnectionMetadata.returns({
-                sso: {
-                    startUrl: 'teststarturl',
-                },
-            });
-            // Start the server and open a document
-            await features.start(server);
-            features.openDocument(SOME_FILE).openDocument(SOME_FILE_WITH_ALT_CASED_LANGUAGE_ID);
-        });
-        const aUserTriggerDecision = (override = {}) => {
-            return {
-                id: 'some-random-session-uuid-0',
-                document: {
-                    _uri: 'file:///test.cs',
-                    _languageId: 'csharp',
-                    _version: 1,
-                    _content: 'class HelloWorld\n' +
-                        '{\n' +
-                        '    static void Main()\n' +
-                        '    {\n' +
-                        '        Console.WriteLine("Hello World!");\n' +
-                        '    }\n' +
-                        '}\n',
-                    _lineOffsets: [0, 17, 19, 42, 48, 91, 97, 99],
-                },
-                startTime: 1483228800000,
-                closeTime: 1483228802000,
-                state: 'CLOSED',
-                codewhispererSessionId: 'cwspr-session-id',
-                startPosition: { line: 2, character: 21 },
-                suggestions: [
-                    { itemId: 'cwspr-item-id-1', content: '' },
-                    { itemId: 'cwspr-item-id-2', content: '' },
-                    { itemId: 'cwspr-item-id-3', content: '' },
-                ],
-                suggestionsStates: new Map([
-                    ['cwspr-item-id-1', 'Empty'],
-                    ['cwspr-item-id-2', 'Empty'],
-                    ['cwspr-item-id-3', 'Empty'],
-                ]),
-                acceptedSuggestionId: undefined,
-                responseContext: {
-                    requestId: 'cwspr-request-id',
-                    codewhispererSessionId: 'cwspr-session-id',
-                },
-                triggerType: 'AutoTrigger',
-                autoTriggerType: 'SpecialCharacters',
-                triggerCharacter: '(',
-                classifierResult: 0.46733811481459187,
-                classifierThreshold: 0.43,
-                language: 'csharp',
-                requestContext: {
-                    fileContext: {
-                        filename: 'file:///test.cs',
-                        programmingLanguage: {
-                            languageName: 'csharp',
-                        },
-                        leftFileContent: 'class HelloWorld\n{\n    static void Main(',
-                        rightFileContent: ')\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
-                    },
-                    maxResults: 1,
-                },
-                supplementalMetadata: undefined,
-                timeToFirstRecommendation: 2000,
-                credentialStartUrl: 'teststarturl',
-                completionSessionResult: undefined,
-                firstCompletionDisplayLatency: undefined,
-                totalSessionDisplayTime: undefined,
-                typeaheadLength: undefined,
-                previousTriggerDecision: undefined,
-                previousTriggerDecisionTime: undefined,
-                reportedUserDecision: true,
-                customizationArn: undefined,
-                ...override,
-            };
-        };
-        describe('Case 1. Session is processed by server without sending results', () => {
-            it('should send Empty user desicion when Codewhisperer returned list of empty suggestions and close session', async () => {
-                const SUGGESTIONS = [
-                    { itemId: 'cwspr-item-id-1', content: '' },
-                    { itemId: 'cwspr-item-id-2', content: '' },
-                    { itemId: 'cwspr-item-id-3', content: '' },
-                ];
-                setServiceResponse(SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-                await autoTriggerInlineCompletionWithReferences();
-                const currentSession = sessionManager.getCurrentSession();
-                assert(currentSession);
-                assert.equal(currentSession.state, 'CLOSED');
-                ts_sinon_1.default.assert.calledOnceWithExactly(sessionManagerSpy.closeSession, currentSession);
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision();
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
-            });
-            it('should send Empty User Decision when Codewhisperer returned empty list of suggestions', async () => {
-                const SUGGESTIONS = [];
-                setServiceResponse(SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-                await autoTriggerInlineCompletionWithReferences();
-                const currentSession = sessionManager.getCurrentSession();
-                assert(currentSession);
-                assert.equal(currentSession.state, 'CLOSED');
-                ts_sinon_1.default.assert.calledOnceWithExactly(sessionManagerSpy.closeSession, currentSession);
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    suggestions: [],
-                    suggestionsStates: new Map([]),
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
-            });
-            it('should send Discard User Decision when all suggestions are filtered out by includeSuggestionsWithCodeReferences setting filter', async () => {
-                features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: false }));
-                const SUGGESTIONS = [
-                    {
-                        itemId: 'cwspr-item-id-1',
-                        content: 'recommendation with reference',
-                        references: [EXPECTED_REFERENCE],
-                    },
-                    {
-                        itemId: 'cwspr-item-id-2',
-                        content: 'recommendation with reference',
-                        references: [EXPECTED_REFERENCE],
-                    },
-                    {
-                        itemId: 'cwspr-item-id-3',
-                        content: 'recommendation with reference',
-                        references: [EXPECTED_REFERENCE],
-                    },
-                ];
-                setServiceResponse(SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-                await autoTriggerInlineCompletionWithReferences();
-                const currentSession = sessionManager.getCurrentSession();
-                assert(currentSession);
-                assert.equal(currentSession.state, 'CLOSED');
-                ts_sinon_1.default.assert.calledOnceWithExactly(sessionManagerSpy.closeSession, currentSession);
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    suggestions: [
-                        {
-                            itemId: 'cwspr-item-id-1',
-                            content: 'recommendation with reference',
-                            references: [EXPECTED_REFERENCE],
-                        },
-                        {
-                            itemId: 'cwspr-item-id-2',
-                            content: 'recommendation with reference',
-                            references: [EXPECTED_REFERENCE],
-                        },
-                        {
-                            itemId: 'cwspr-item-id-3',
-                            content: 'recommendation with reference',
-                            references: [EXPECTED_REFERENCE],
-                        },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Filter'],
-                        ['cwspr-item-id-2', 'Filter'],
-                        ['cwspr-item-id-3', 'Filter'],
-                    ]),
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
-            });
-            it('should send Discard User Decision when all suggestions are discarded after right context merge', async () => {
-                const SUGGESTIONS = [
-                    { itemId: 'cwspr-item-id-1', content: HELLO_WORLD_IN_CSHARP },
-                    { itemId: 'cwspr-item-id-2', content: HELLO_WORLD_IN_CSHARP },
-                    { itemId: 'cwspr-item-id-3', content: HELLO_WORLD_IN_CSHARP },
-                ];
-                setServiceResponse(SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-                await manualTriggerInlineCompletionWithReferences();
-                const currentSession = sessionManager.getCurrentSession();
-                assert(currentSession);
-                assert.equal(currentSession?.state, 'CLOSED');
-                ts_sinon_1.default.assert.calledOnceWithExactly(sessionManagerSpy.closeSession, currentSession);
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    startPosition: { line: 0, character: 0 },
-                    suggestions: [
-                        {
-                            itemId: 'cwspr-item-id-1',
-                            content: 'class HelloWorld\n' +
-                                '{\n' +
-                                '    static void Main()\n' +
-                                '    {\n' +
-                                '        Console.WriteLine("Hello World!");\n' +
-                                '    }\n' +
-                                '}\n',
-                        },
-                        {
-                            itemId: 'cwspr-item-id-2',
-                            content: 'class HelloWorld\n' +
-                                '{\n' +
-                                '    static void Main()\n' +
-                                '    {\n' +
-                                '        Console.WriteLine("Hello World!");\n' +
-                                '    }\n' +
-                                '}\n',
-                        },
-                        {
-                            itemId: 'cwspr-item-id-3',
-                            content: 'class HelloWorld\n' +
-                                '{\n' +
-                                '    static void Main()\n' +
-                                '    {\n' +
-                                '        Console.WriteLine("Hello World!");\n' +
-                                '    }\n' +
-                                '}\n',
-                        },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Discard'],
-                        ['cwspr-item-id-2', 'Discard'],
-                        ['cwspr-item-id-3', 'Discard'],
-                    ]),
-                    triggerType: 'OnDemand',
-                    autoTriggerType: undefined,
-                    triggerCharacter: '',
-                    classifierResult: -0.8524073111924992,
-                    requestContext: {
-                        fileContext: {
-                            filename: 'file:///test.cs',
-                            programmingLanguage: {
-                                languageName: 'csharp',
-                            },
-                            leftFileContent: '',
-                            rightFileContent: 'class HelloWorld\n' +
-                                '{\n' +
-                                '    static void Main()\n' +
-                                '    {\n' +
-                                '        Console.WriteLine("Hello World!");\n' +
-                                '    }\n' +
-                                '}\n',
-                        },
-                        maxResults: 5,
-                    },
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
-            });
-        });
-        describe('Case 2. Session returns recommendation to client and is closed by LogInlineCompletionSessionResults notification', () => {
-            it('should emit User Decision event for active completion session when session results are received', async () => {
-                setServiceResponse(DEFAULT_SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-                await autoTriggerInlineCompletionWithReferences();
-                const currentSession = sessionManager.getCurrentSession();
-                assert(currentSession);
-                assert.equal(currentSession?.state, 'ACTIVE');
-                ts_sinon_1.default.assert.notCalled(sessionManagerSpy.closeSession);
-                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
-                await features.doLogInlineCompletionSessionResults(DEFAULT_SESSION_RESULT_DATA);
-                ts_sinon_1.default.assert.called(telemetryServiceSpy);
-            });
-            it('should emit User Decision event with correct typeaheadLength value when session results are received', async () => {
-                setServiceResponse(DEFAULT_SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-                await autoTriggerInlineCompletionWithReferences();
-                const currentSession = sessionManager.getCurrentSession();
-                assert(currentSession);
-                assert.equal(currentSession?.state, 'ACTIVE');
-                ts_sinon_1.default.assert.notCalled(sessionManagerSpy.closeSession);
-                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
-                await features.doLogInlineCompletionSessionResults({
-                    ...DEFAULT_SESSION_RESULT_DATA,
-                    typeaheadLength: 20,
-                });
-                ts_sinon_1.default.assert.called(telemetryServiceSpy);
-            });
-            it('should not emit User Decision event when session results are received after session was closed', async () => {
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                const firstSession = sessionManager.getCurrentSession();
-                assert(firstSession);
-                assert.equal(firstSession.state, 'ACTIVE');
-                ts_sinon_1.default.assert.notCalled(sessionManagerSpy.closeSession);
-                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
-                // Send second completion request to close first one
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                assert.equal(firstSession.state, 'DISCARD');
-                assert.notEqual(firstSession, sessionManager.getCurrentSession());
-                ts_sinon_1.default.assert.calledWithExactly(sessionManagerSpy.closeSession, firstSession);
-                // Test that session reports it's status when second request is received
-                const expectedEvent = aUserTriggerDecision({
-                    state: 'DISCARD',
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Discard'],
-                        ['cwspr-item-id-2', 'Discard'],
-                        ['cwspr-item-id-3', 'Discard'],
-                    ]),
-                    responseContext: {
-                        requestId: 'cwspr-request-id',
-                        codewhispererSessionId: 'cwspr-session-id-1',
-                    },
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedEvent, 0);
-                telemetryServiceSpy.resetHistory();
-                // Send session results for closed first session
-                await features.doLogInlineCompletionSessionResults({
-                    ...DEFAULT_SESSION_RESULT_DATA,
-                    sessionId: firstSession.id,
-                });
-                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
-            });
-            it('should not emit User Decision event when session results received for session that does not exist', async () => {
-                // Send session results for closed first session
-                await features.doLogInlineCompletionSessionResults({
-                    ...DEFAULT_SESSION_RESULT_DATA,
-                    sessionId: 'cwspr-session-id-never-created',
-                });
-                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
-            });
-            it('should emit Accept User Decision event for current active completion session when session results are received with accepted suggestion', async () => {
-                setServiceResponse(DEFAULT_SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-                const SESSION_RESULT_DATA = {
-                    sessionId: 'some-random-session-uuid-0',
-                    completionSessionResult: {
-                        'cwspr-item-id-1': {
-                            seen: true,
-                            accepted: false,
-                            discarded: false,
-                        },
-                        'cwspr-item-id-2': {
-                            seen: true,
-                            accepted: true, // Second suggestion was accepted
-                            discarded: false,
-                        },
-                        'cwspr-item-id-3': {
-                            seen: true,
-                            accepted: false,
-                            discarded: false,
-                        },
-                    },
-                };
-                await autoTriggerInlineCompletionWithReferences();
-                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
-                // Send session results for closed first session
-                await features.doLogInlineCompletionSessionResults(SESSION_RESULT_DATA);
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    completionSessionResult: {
-                        'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
-                        'cwspr-item-id-2': { seen: true, accepted: true, discarded: false },
-                        'cwspr-item-id-3': { seen: true, accepted: false, discarded: false },
-                    },
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Ignore'],
-                        ['cwspr-item-id-2', 'Accept'],
-                        ['cwspr-item-id-3', 'Ignore'],
-                    ]),
-                    acceptedSuggestionId: 'cwspr-item-id-2',
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
-            });
-            it('should emit Reject User Decision event for current active completion session when session results are received without accepted suggestion', async () => {
-                setServiceResponse(DEFAULT_SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-                const SESSION_RESULT_DATA = {
-                    sessionId: 'some-random-session-uuid-0',
-                    completionSessionResult: {
-                        'cwspr-item-id-1': {
-                            seen: true, // Reject
-                            accepted: false,
-                            discarded: false,
-                        },
-                        'cwspr-item-id-2': {
-                            seen: false, // Unseen
-                            accepted: false,
-                            discarded: true,
-                        },
-                        'cwspr-item-id-3': {
-                            seen: false, // Discard
-                            accepted: false,
-                            discarded: true,
-                        },
-                    },
-                };
-                await autoTriggerInlineCompletionWithReferences();
-                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
-                // Send session results for closed first session
-                await features.doLogInlineCompletionSessionResults(SESSION_RESULT_DATA);
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Reject'],
-                        ['cwspr-item-id-2', 'Discard'],
-                        ['cwspr-item-id-3', 'Discard'],
-                    ]),
-                    completionSessionResult: {
-                        'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
-                        'cwspr-item-id-2': { seen: false, accepted: false, discarded: true },
-                        'cwspr-item-id-3': { seen: false, accepted: false, discarded: true },
-                    },
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
-            });
-            it('should send Discard User Decision when all suggestions have Discard state', async () => {
-                setServiceResponse(DEFAULT_SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-                const SESSION_RESULT_DATA = {
-                    sessionId: 'some-random-session-uuid-0',
-                    completionSessionResult: {
-                        'cwspr-item-id-1': {
-                            seen: false, // Discard
-                            accepted: false,
-                            discarded: true,
-                        },
-                        'cwspr-item-id-2': {
-                            seen: false, // Discard
-                            accepted: false,
-                            discarded: true,
-                        },
-                        'cwspr-item-id-3': {
-                            seen: false, // Discard
-                            accepted: false,
-                            discarded: true,
-                        },
-                    },
-                };
-                await autoTriggerInlineCompletionWithReferences();
-                ts_sinon_1.default.assert.notCalled(telemetryServiceSpy);
-                // Send session results for closed first session
-                await features.doLogInlineCompletionSessionResults(SESSION_RESULT_DATA);
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Discard'],
-                        ['cwspr-item-id-2', 'Discard'],
-                        ['cwspr-item-id-3', 'Discard'],
-                    ]),
-                    completionSessionResult: {
-                        'cwspr-item-id-1': { seen: false, accepted: false, discarded: true },
-                        'cwspr-item-id-2': { seen: false, accepted: false, discarded: true },
-                        'cwspr-item-id-3': { seen: false, accepted: false, discarded: true },
-                    },
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
-            });
-            it('should set codewhispererTimeSinceLastDocumentChange as difference between 2 any document changes', async () => {
-                const typeSomething = async () => await features.doChangeTextDocument({
-                    textDocument: { uri: SOME_FILE.uri, version: 1 },
-                    contentChanges: [
-                        {
-                            range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
-                            text: 'f',
-                        },
-                    ],
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                await typeSomething();
-                clock.tick(1234);
-                await typeSomething();
-                clock.tick(5678);
-                await typeSomething();
-                await features.doLogInlineCompletionSessionResults(DEFAULT_SESSION_RESULT_DATA);
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    completionSessionResult: {
-                        'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
-                        'cwspr-item-id-2': { seen: true, accepted: false, discarded: false },
-                        'cwspr-item-id-3': { seen: true, accepted: false, discarded: false },
-                    },
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Reject'],
-                        ['cwspr-item-id-2', 'Reject'],
-                        ['cwspr-item-id-3', 'Reject'],
-                    ]),
-                    closeTime: clock.now,
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 5678);
-            });
-        });
-        describe('Case 3. Active session is closed by subsequent trigger', function () {
-            it('should close ACTIVE session and emit Discard user trigger decision event on Manual trigger', async () => {
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                });
-                await manualTriggerInlineCompletionWithReferences();
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    state: 'DISCARD',
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Discard'],
-                        ['cwspr-item-id-2', 'Discard'],
-                        ['cwspr-item-id-3', 'Discard'],
-                    ]),
-                    responseContext: {
-                        requestId: 'cwspr-request-id',
-                        codewhispererSessionId: 'cwspr-session-id-1',
-                    },
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
-                ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy, {
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                }, 0);
-            });
-            it('should close ACTIVE session and emit Discard user trigger decision event on Auto trigger', async () => {
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                const expectedUserTriggerDecisionMetric = aUserTriggerDecision({
-                    state: 'DISCARD',
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Discard'],
-                        ['cwspr-item-id-2', 'Discard'],
-                        ['cwspr-item-id-3', 'Discard'],
-                    ]),
-                    responseContext: {
-                        requestId: 'cwspr-request-id',
-                        codewhispererSessionId: 'cwspr-session-id-1',
-                    },
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, expectedUserTriggerDecisionMetric, 0);
-                ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy, {
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                }, 0);
-            });
-            it('should attach previous session trigger decision', async () => {
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                const firstSession = sessionManager.getCurrentSession();
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-3',
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                ts_sinon_1.default.assert.calledTwice(telemetryServiceSpy);
-                const firstCallArgs = telemetryServiceSpy.getCall(0).args[0];
-                const secondCallArgs = telemetryServiceSpy.getCall(1).args[0];
-                ts_sinon_1.default.assert.match(firstCallArgs, {
-                    id: 'some-random-session-uuid-0',
-                    document: {
-                        _uri: 'file:///test.cs',
-                        _languageId: 'csharp',
-                        _version: 1,
-                        _content: 'class HelloWorld\n{\n    static void Main()\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
-                        _lineOffsets: [0, 17, 19, 42, 48, 91, 97, 99],
-                    },
-                    startTime: 1483228800000,
-                    closeTime: 1483228802000,
-                    state: 'DISCARD',
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                    startPosition: { line: 2, character: 21 },
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: {},
-                    responseContext: { requestId: 'cwspr-request-id', codewhispererSessionId: 'cwspr-session-id-1' },
-                    triggerType: 'AutoTrigger',
-                    autoTriggerType: 'SpecialCharacters',
-                    triggerCharacter: '(',
-                    classifierResult: 0.46733811481459187,
-                    classifierThreshold: 0.43,
-                    language: 'csharp',
-                    requestContext: {
-                        fileContext: {
-                            filename: 'file:///test.cs',
-                            programmingLanguage: { languageName: 'csharp' },
-                            leftFileContent: 'class HelloWorld\n{\n    static void Main(',
-                            rightFileContent: ')\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
-                        },
-                        maxResults: 1,
-                    },
-                    timeToFirstRecommendation: 2000,
-                    credentialStartUrl: 'teststarturl',
-                    reportedUserDecision: true,
-                });
-                ts_sinon_1.default.assert.match(secondCallArgs, aUserTriggerDecision({
-                    previousTriggerDecision: 'Discard',
-                    previousTriggerDecisionTime: 1483228802000,
-                    responseContext: {
-                        requestId: 'cwspr-request-id',
-                        codewhispererSessionId: 'cwspr-session-id-2',
-                    },
-                    id: 'some-random-session-uuid-1',
-                    startTime: 1483228802000,
-                    closeTime: 1483228804000,
-                    state: 'DISCARD',
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Discard'],
-                        ['cwspr-item-id-2', 'Discard'],
-                        ['cwspr-item-id-3', 'Discard'],
-                    ]),
-                }));
-                ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy, aUserTriggerDecision({
-                    codewhispererSessionId: 'cwspr-session-id-3',
-                }), 0);
-            });
-            it('should set correct values for past trigger result fields', async () => {
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                const firstSession = sessionManager.getCurrentSession();
-                await features.doLogInlineCompletionSessionResults(DEFAULT_SESSION_RESULT_DATA);
-                clock.tick(1234);
-                setServiceResponse(DEFAULT_SUGGESTIONS, {
-                    ...EXPECTED_RESPONSE_CONTEXT,
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                });
-                await autoTriggerInlineCompletionWithReferences();
-                // Trigger 3rd session to close second one
-                await autoTriggerInlineCompletionWithReferences();
-                // For first session previous data does not exist
-                ts_sinon_1.default.assert.calledTwice(telemetryServiceSpy);
-                const firstCallArgs = telemetryServiceSpy.getCall(0).args[0];
-                const secondCallArgs = telemetryServiceSpy.getCall(1).args[0];
-                ts_sinon_1.default.assert.match(firstCallArgs, aUserTriggerDecision({
-                    previousTriggerDecision: undefined,
-                    previousTriggerDecisionTime: undefined,
-                    responseContext: {
-                        requestId: 'cwspr-request-id',
-                        codewhispererSessionId: 'cwspr-session-id-1',
-                    },
-                    id: 'some-random-session-uuid-0',
-                    startTime: 1483228800000,
-                    closeTime: 1483228802000,
-                    state: 'CLOSED',
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Reject'],
-                        ['cwspr-item-id-2', 'Reject'],
-                        ['cwspr-item-id-3', 'Reject'],
-                    ]),
-                    completionSessionResult: {
-                        'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
-                        'cwspr-item-id-2': { seen: true, accepted: false, discarded: false },
-                        'cwspr-item-id-3': { seen: true, accepted: false, discarded: false },
-                    },
-                }));
-                ts_sinon_1.default.assert.match(secondCallArgs, {
-                    id: 'some-random-session-uuid-1',
-                    document: {
-                        _uri: 'file:///test.cs',
-                        _languageId: 'csharp',
-                        _version: 1,
-                        _content: 'class HelloWorld\n{\n    static void Main()\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
-                        _lineOffsets: [0, 17, 19, 42, 48, 91, 97, 99],
-                    },
-                    startTime: 1483228803234,
-                    closeTime: 1483228805234,
-                    state: 'DISCARD',
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                    startPosition: {
-                        line: 2,
-                        character: 21,
-                    },
-                    suggestions: [
-                        {
-                            itemId: 'cwspr-item-id-1',
-                            content: 'recommendation',
-                            insertText: 'recommendation',
-                        },
-                        {
-                            itemId: 'cwspr-item-id-2',
-                            content: 'recommendation',
-                            insertText: 'recommendation',
-                        },
-                        {
-                            itemId: 'cwspr-item-id-3',
-                            content: 'recommendation',
-                            insertText: 'recommendation',
-                        },
-                    ],
-                    suggestionsStates: {},
-                    responseContext: {
-                        requestId: 'cwspr-request-id',
-                        codewhispererSessionId: 'cwspr-session-id-2',
-                    },
-                    triggerType: 'AutoTrigger',
-                    autoTriggerType: 'SpecialCharacters',
-                    triggerCharacter: '(',
-                    classifierResult: 0.30173811481459184,
-                    classifierThreshold: 0.43,
-                    language: 'csharp',
-                    requestContext: {
-                        fileContext: {
-                            filename: 'file:///test.cs',
-                            programmingLanguage: {
-                                languageName: 'csharp',
-                            },
-                            leftFileContent: 'class HelloWorld\n{\n    static void Main(',
-                            rightFileContent: ')\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
-                        },
-                        maxResults: 1,
-                    },
-                    timeToFirstRecommendation: 2000,
-                    credentialStartUrl: 'teststarturl',
-                    previousTriggerDecision: 'Reject',
-                    previousTriggerDecisionTime: 1483228802000,
-                    reportedUserDecision: true,
-                });
-            });
-        });
-        describe('Case 4. Inflight session is closed by subsequent completion request', function () {
-            it('should emit Discard user trigger decision event when REQUESTING session is closed before becoming ACTIVE', async () => {
-                // Chain requests in a callbacks
-                let concurrentCount = 0;
-                let requests = [];
-                service.generateSuggestions.callsFake(_request => {
-                    clock.tick(1000);
-                    let i = concurrentCount;
-                    if (concurrentCount < 2) {
-                        // Trigger second request before first one was resolved
-                        concurrentCount++;
-                        const req = autoTriggerInlineCompletionWithReferences();
-                        requests.push(req);
-                        clock.tick(10);
-                    }
-                    clock.tick(250);
-                    return Promise.resolve({
-                        suggestions: DEFAULT_SUGGESTIONS,
-                        responseContext: {
-                            ...EXPECTED_RESPONSE_CONTEXT,
-                            codewhispererSessionId: `cwspr-session-id-${i}`,
-                        },
-                    });
-                });
-                const result = [await autoTriggerInlineCompletionWithReferences(), ...(await Promise.all(requests))];
-                assert.deepEqual(result, [
-                    EMPTY_RESULT,
-                    EMPTY_RESULT,
-                    { ...EXPECTED_RESULT, sessionId: 'some-random-session-uuid-2' },
-                ]);
-                // 3 sessions were created, each one closes previous one in REQUESTING state
-                assert.equal(SESSION_IDS_LOG.length, 3);
-                ts_sinon_1.default.assert.calledTwice(telemetryServiceSpy);
-                const firstCallArgs = telemetryServiceSpy.getCall(0).args[0];
-                const secondCallArgs = telemetryServiceSpy.getCall(1).args[0];
-                ts_sinon_1.default.assert.match(firstCallArgs, aUserTriggerDecision({
-                    codewhispererSessionId: 'cwspr-session-id-0',
-                    state: 'DISCARD',
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Discard'],
-                        ['cwspr-item-id-2', 'Discard'],
-                        ['cwspr-item-id-3', 'Discard'],
-                    ]),
-                    responseContext: {
-                        requestId: 'cwspr-request-id',
-                        codewhispererSessionId: 'cwspr-session-id-0',
-                    },
-                    timeToFirstRecommendation: 1260,
-                    closeTime: 1483228801000,
-                }));
-                ts_sinon_1.default.assert.match(secondCallArgs, {
-                    id: 'some-random-session-uuid-1',
-                    document: {
-                        _uri: 'file:///test.cs',
-                        _languageId: 'csharp',
-                        _version: 1,
-                        _content: 'class HelloWorld\n{\n    static void Main()\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
-                        _lineOffsets: [0, 17, 19, 42, 48, 91, 97, 99],
-                    },
-                    startTime: 1483228801260,
-                    closeTime: 1483228802260,
-                    state: 'DISCARD',
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                    startPosition: { line: 2, character: 21 },
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: {},
-                    responseContext: { requestId: 'cwspr-request-id', codewhispererSessionId: 'cwspr-session-id-1' },
-                    triggerType: 'AutoTrigger',
-                    autoTriggerType: 'SpecialCharacters',
-                    triggerCharacter: '(',
-                    classifierResult: 0.46733811481459187,
-                    classifierThreshold: 0.43,
-                    language: 'csharp',
-                    requestContext: {
-                        fileContext: {
-                            filename: 'file:///test.cs',
-                            programmingLanguage: { languageName: 'csharp' },
-                            leftFileContent: 'class HelloWorld\n{\n    static void Main(',
-                            rightFileContent: ')\n    {\n        Console.WriteLine("Hello World!");\n    }\n}\n',
-                        },
-                        maxResults: 1,
-                    },
-                    timeToFirstRecommendation: 1260,
-                    credentialStartUrl: 'teststarturl',
-                    previousTriggerDecision: 'Discard',
-                    previousTriggerDecisionTime: 1483228801000,
-                    reportedUserDecision: true,
-                });
-                ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy, {
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                });
-                telemetryServiceSpy.resetHistory();
-                const activeSession = sessionManager.getActiveSession();
-                assert.equal(activeSession?.id, SESSION_IDS_LOG[2]);
-                await features.doLogInlineCompletionSessionResults({
-                    ...DEFAULT_SESSION_RESULT_DATA,
-                    sessionId: SESSION_IDS_LOG[2],
-                });
-                ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, aUserTriggerDecision({
-                    id: 'some-random-session-uuid-2',
-                    startTime: 1483228802520,
-                    closeTime: 1483228803770,
-                    codewhispererSessionId: 'cwspr-session-id-2',
-                    suggestions: [
-                        { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                        { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                    ],
-                    suggestionsStates: new Map([
-                        ['cwspr-item-id-1', 'Reject'],
-                        ['cwspr-item-id-2', 'Reject'],
-                        ['cwspr-item-id-3', 'Reject'],
-                    ]),
-                    previousTriggerDecision: 'Discard',
-                    previousTriggerDecisionTime: 1483228802260,
-                    timeToFirstRecommendation: 1250,
-                    completionSessionResult: {
-                        'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
-                        'cwspr-item-id-2': { seen: true, accepted: false, discarded: false },
-                        'cwspr-item-id-3': { seen: true, accepted: false, discarded: false },
-                    },
-                    responseContext: {
-                        requestId: 'cwspr-request-id',
-                        codewhispererSessionId: 'cwspr-session-id-2',
-                    },
-                }), 0);
-            });
-        });
-        it('should report user trigger decision only once for a session', async () => {
-            setServiceResponse(DEFAULT_SUGGESTIONS, {
-                ...EXPECTED_RESPONSE_CONTEXT,
-                codewhispererSessionId: 'cwspr-session-id-1',
-            });
-            await autoTriggerInlineCompletionWithReferences();
-            const firstSession = sessionManager.getCurrentSession();
-            ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy);
-            // Record session results and close the session
-            await features.doLogInlineCompletionSessionResults(DEFAULT_SESSION_RESULT_DATA);
-            ts_sinon_1.default.assert.calledWithMatch(telemetryServiceSpy, aUserTriggerDecision({
-                codewhispererSessionId: 'cwspr-session-id-1',
-                suggestions: [
-                    { itemId: 'cwspr-item-id-1', content: 'recommendation', insertText: 'recommendation' },
-                    { itemId: 'cwspr-item-id-2', content: 'recommendation', insertText: 'recommendation' },
-                    { itemId: 'cwspr-item-id-3', content: 'recommendation', insertText: 'recommendation' },
-                ],
-                suggestionsStates: new Map([
-                    ['cwspr-item-id-1', 'Reject'],
-                    ['cwspr-item-id-2', 'Reject'],
-                    ['cwspr-item-id-3', 'Reject'],
-                ]),
-                responseContext: {
-                    requestId: 'cwspr-request-id',
-                    codewhispererSessionId: 'cwspr-session-id-1',
-                },
-                completionSessionResult: {
-                    'cwspr-item-id-1': { seen: true, accepted: false, discarded: false },
-                    'cwspr-item-id-2': { seen: true, accepted: false, discarded: false },
-                    'cwspr-item-id-3': { seen: true, accepted: false, discarded: false },
-                },
-            }), 0);
-            assert.equal(firstSession?.state, 'CLOSED');
-            telemetryServiceSpy.resetHistory();
-            // Triggering new completion request creates new session
-            // and should not emit telemetry for previous session, which was closed earlier
-            setServiceResponse(DEFAULT_SUGGESTIONS, {
-                ...EXPECTED_RESPONSE_CONTEXT,
-                codewhispererSessionId: 'cwspr-session-id-2',
-            });
-            await autoTriggerInlineCompletionWithReferences();
-            // Or attempt to record data
-            await features.doLogInlineCompletionSessionResults(DEFAULT_SESSION_RESULT_DATA);
-            ts_sinon_1.default.assert.neverCalledWithMatch(telemetryServiceSpy, {
-                codewhispererSessionId: 'cwspr-session-id-1',
-            }, 0);
-        });
-    });
-    describe('User Decision Telemetry', () => {
-        const HELLO_WORLD_IN_CSHARP = `class HelloWorld
-{
-    static void Main()
-    {
-        Console.WriteLine("Hello World!");
-    }
-}
-`;
-        const AUTO_TRIGGER_POSITION = { line: 2, character: 21 };
-        const SOME_FILE = vscode_languageserver_textdocument_1.TextDocument.create('file:///test.cs', 'csharp', 1, HELLO_WORLD_IN_CSHARP);
-        const SOME_FILE_WITH_ALT_CASED_LANGUAGE_ID = vscode_languageserver_textdocument_1.TextDocument.create(
-        // Use unsupported extension, so that we can test that we get a match based on the LanguageId
-        'file:///test.seesharp', 'CSharp', 1, HELLO_WORLD_IN_CSHARP);
-        const REFERENCE = [
-            {
-                licenseName: 'test license 1',
-                repository: 'test repository 1',
-                url: 'test url 1',
-                recommendationContentSpan: { start: 0, end: 1 },
-            },
-            {
-                licenseName: 'test license 2',
-                repository: 'test repository 2',
-                url: 'test url 2',
-                recommendationContentSpan: { start: 0, end: 1 },
-            },
-            {
-                licenseName: 'test license 1',
-                repository: 'test repository 3',
-                url: 'test url 3',
-                recommendationContentSpan: { start: 0, end: 1 },
-            },
-        ];
-        const DEFAULT_SUGGESTIONS = [
-            { itemId: 'cwspr-item-id-1', content: 'recommendation' },
-            { itemId: 'cwspr-item-id-2', content: 'recommendation' },
-            { itemId: 'cwspr-item-id-3', content: 'recommendation' },
-        ];
-        const EXPECTED_RESPONSE_CONTEXT = {
-            requestId: 'cwspr-request-id',
-            codewhispererSessionId: 'cwspr-session-id',
-        };
-        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;
-        const setServiceResponse = (suggestions, responseContext, time = 2000) => {
-            service.generateSuggestions.callsFake(_request => {
-                clock.tick(time);
-                return Promise.resolve({
-                    suggestions,
-                    responseContext,
-                });
-            });
-        };
-        const autoTriggerInlineCompletionWithReferences = async () => await features.doInlineCompletionWithReferences({
-            textDocument: { uri: SOME_FILE.uri },
-            position: AUTO_TRIGGER_POSITION,
-            context: { triggerKind: server_interface_1.InlineCompletionTriggerKind.Automatic },
-        }, server_interface_1.CancellationToken.None);
-        beforeEach(async () => {
-            // Set up the server with a mock service, returning predefined recommendations
-            service = (0, ts_sinon_1.stubInterface)();
-            setServiceResponse(DEFAULT_SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-            server = (0, codeWhispererServer_1.CodewhispererServerFactory)(_auth => service);
-            // Initialize the features, but don't start server yet
-            features = new testing_1.TestFeatures();
-            features.lsp.workspace.getConfiguration.returns(Promise.resolve({ includeSuggestionsWithCodeReferences: true }));
-            // Return credentialsStartUrl value
-            features.credentialsProvider.getConnectionMetadata.returns({
-                sso: {
-                    startUrl: 'teststarturl',
-                },
-            });
-            // Start the server and open a document
-            await features.start(server);
-            features.openDocument(SOME_FILE).openDocument(SOME_FILE_WITH_ALT_CASED_LANGUAGE_ID);
-        });
-        const aUserDecision = (override = {}) => {
-            return {
-                name: 'codewhisperer_userDecision',
-                data: {
-                    codewhispererRequestId: 'cwspr-request-id',
-                    codewhispererSessionId: 'cwspr-session-id',
-                    credentialStartUrl: 'teststarturl',
-                    codewhispererCompletionType: 'Line',
-                    codewhispererLanguage: 'csharp',
-                    codewhispererTriggerType: 'AutoTrigger',
-                    codewhispererSuggestionIndex: 0,
-                    codewhispererSuggestionState: 'Discard',
-                    codewhispererSuggestionReferences: ['MIT'],
-                    codewhispererSuggestionReferenceCount: 1,
-                    ...override,
-                },
-            };
-        };
-        it('should send correct empty reference when suggestion does not have any', async () => {
-            const SESSION_RESULT_DATA = {
-                sessionId: 'some-random-session-uuid-0',
-                completionSessionResult: {
-                    'cwspr-item-id-1': {
-                        accepted: true, // 'Accept'
-                        seen: true,
-                        discarded: false,
-                    },
-                },
-            };
-            const SUGGESTIONS = [
-                {
-                    itemId: 'cwspr-item-id-1',
-                    content: 'recommendation with reference',
-                    references: undefined,
-                },
-            ];
-            setServiceResponse(SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-            await autoTriggerInlineCompletionWithReferences();
-            ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                name: 'codewhisperer_userDecision',
-            });
-            await features.doLogInlineCompletionSessionResults(SESSION_RESULT_DATA);
-            const expectedUserDecisionMetric = aUserDecision({
-                codewhispererSuggestionIndex: 0,
-                codewhispererSuggestionState: 'Accept',
-                codewhispererSuggestionReferences: [],
-                codewhispererSuggestionReferenceCount: 0,
-            });
-            ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserDecisionMetric);
-        });
-        it('should send correct reference when suggestion has any', async () => {
-            const SESSION_RESULT_DATA = {
-                sessionId: 'some-random-session-uuid-0',
-                completionSessionResult: {
-                    'cwspr-item-id-1-y': {
-                        accepted: true, // 'Accept'
-                        seen: true,
-                        discarded: false,
-                    },
-                },
-            };
-            const SUGGESTIONS = [
-                {
-                    itemId: 'cwspr-item-id-1-y',
-                    content: 'recommendation with reference',
-                    references: [REFERENCE[0]],
-                },
-            ];
-            setServiceResponse(SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-            await autoTriggerInlineCompletionWithReferences();
-            ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                name: 'codewhisperer_userDecision',
-            });
-            await features.doLogInlineCompletionSessionResults(SESSION_RESULT_DATA);
-            const expectedUserDecisionMetric = aUserDecision({
-                codewhispererSuggestionIndex: 0,
-                codewhispererSuggestionState: 'Accept',
-                codewhispererSuggestionReferences: ['test license 1'],
-                codewhispererSuggestionReferenceCount: 1,
-            });
-            ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserDecisionMetric);
-        });
-        it('should send unique licenses when suggestion has any that overlaps', async () => {
-            const SESSION_RESULT_DATA = {
-                sessionId: 'some-random-session-uuid-0',
-                completionSessionResult: {
-                    'cwspr-item-id-1': {
-                        accepted: true, // 'Accept'
-                        seen: true,
-                        discarded: false,
-                    },
-                },
-            };
-            const SUGGESTIONS = [
-                {
-                    itemId: 'cwspr-item-id-1',
-                    content: 'recommendation with reference',
-                    references: REFERENCE,
-                },
-            ];
-            setServiceResponse(SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-            await autoTriggerInlineCompletionWithReferences();
-            ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                name: 'codewhisperer_userDecision',
-            });
-            await features.doLogInlineCompletionSessionResults(SESSION_RESULT_DATA);
-            const expectedUserDecisionMetric = aUserDecision({
-                codewhispererSuggestionIndex: 0,
-                codewhispererSuggestionState: 'Accept',
-                codewhispererSuggestionReferences: ['test license 1', 'test license 2'],
-                codewhispererSuggestionReferenceCount: 3,
-            });
-            ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, expectedUserDecisionMetric);
-        });
-        it('should send multiple metrics on all suggestions returned', async () => {
-            const SESSION_RESULT_DATA = {
-                sessionId: 'some-random-session-uuid-0',
-                completionSessionResult: {
-                    'cwspr-item-id-1': {
-                        accepted: true, // 'Accept'
-                        seen: true,
-                        discarded: false,
-                    },
-                    'cwspr-item-id-2': {
-                        accepted: false, // Discard
-                        seen: false,
-                        discarded: true,
-                    },
-                    'cwspr-item-id-3': {
-                        accepted: false, // 'Unseen'
-                        seen: false,
-                        discarded: false,
-                    },
-                },
-            };
-            const SUGGESTIONS = [
-                {
-                    itemId: 'cwspr-item-id-1',
-                    content: 'recommendation with reference',
-                    references: REFERENCE,
-                },
-                {
-                    itemId: 'cwspr-item-id-2',
-                    content: 'recommendation with reference',
-                    references: REFERENCE,
-                },
-                {
-                    itemId: 'cwspr-item-id-3',
-                    content: 'recommendation with reference',
-                    references: REFERENCE,
-                },
-            ];
-            setServiceResponse(SUGGESTIONS, EXPECTED_RESPONSE_CONTEXT);
-            await autoTriggerInlineCompletionWithReferences();
-            ts_sinon_1.default.assert.neverCalledWithMatch(features.telemetry.emitMetric, {
-                name: 'codewhisperer_userDecision',
-            });
-            await features.doLogInlineCompletionSessionResults(SESSION_RESULT_DATA);
-            const expectedStates = ['Accept', 'Discard', 'Unseen'];
-            const expectedUserDecisionMetrics = new Array();
-            SUGGESTIONS.forEach((_, i) => {
-                expectedUserDecisionMetrics.push(aUserDecision({
-                    codewhispererSuggestionIndex: i,
-                    codewhispererSuggestionState: expectedStates[i],
-                    codewhispererSuggestionReferences: ['test license 1', 'test license 2'],
-                    codewhispererSuggestionReferenceCount: 3,
-                }));
-            });
-            expectedUserDecisionMetrics.forEach(metric => {
-                ts_sinon_1.default.assert.calledWithMatch(features.telemetry.emitMetric, metric);
-            });
-        });
-    });
-});
-//# sourceMappingURL=userTriggerDecision.test.js.map