add tests

ctlai95 · ctlai95 · commit 58e4aa976594 · 2025-01-09T16:57:50.000-08:00
diff --git a/packages/amazonq/test/unit/codewhisperer/models/model.test.ts b/packages/amazonq/test/unit/codewhisperer/models/model.test.ts
@@ -4,7 +4,12 @@
  */
 import assert from 'assert'
 import sinon from 'sinon'
-import { SecurityIssueFilters, SecurityTreeViewFilterState } from 'aws-core-vscode/codewhisperer'
+import {
+    CodeIssueGroupingStrategy,
+    CodeIssueGroupingStrategyState,
+    SecurityIssueFilters,
+    SecurityTreeViewFilterState,
+} from 'aws-core-vscode/codewhisperer'
 import { globals } from 'aws-core-vscode/shared'
 
 describe('model', function () {
@@ -70,4 +75,113 @@ describe('model', function () {
             assert.deepStrictEqual(hiddenSeverities, ['High', 'Low'])
         })
     })
+
+    describe('CodeIssueGroupingStrategyState', function () {
+        let sandbox: sinon.SinonSandbox
+        let state: CodeIssueGroupingStrategyState
+
+        beforeEach(function () {
+            sandbox = sinon.createSandbox()
+            // Reset the singleton instance before each test
+            // @ts-ignore - accessing private static for testing
+            CodeIssueGroupingStrategyState['#instance'] = undefined
+            state = CodeIssueGroupingStrategyState.instance
+        })
+
+        afterEach(function () {
+            sandbox.restore()
+        })
+
+        describe('instance', function () {
+            it('should return the same instance when called multiple times', function () {
+                const instance1 = CodeIssueGroupingStrategyState.instance
+                const instance2 = CodeIssueGroupingStrategyState.instance
+                assert.strictEqual(instance1, instance2)
+            })
+        })
+
+        describe('getState', function () {
+            it('should return fallback when no state is stored', function () {
+                const tryGetStub = sandbox.stub(globals.globalState, 'tryGet').returns(undefined)
+                const result = state.getState()
+
+                sinon.assert.calledWith(tryGetStub, 'aws.amazonq.codescan.groupingStrategy', String)
+                assert.equal(result, CodeIssueGroupingStrategy.Severity)
+            })
+
+            it('should return stored state when valid', function () {
+                const validStrategy = CodeIssueGroupingStrategy.Severity
+                const tryGetStub = sandbox.stub(globals.globalState, 'tryGet').returns(validStrategy)
+
+                const result = state.getState()
+
+                assert.equal(result, validStrategy)
+            })
+
+            it('should return fallback when stored state is invalid', function () {
+                const invalidStrategy = 'invalid'
+                const tryGetStub = sandbox.stub(globals.globalState, 'tryGet').returns(invalidStrategy)
+
+                const result = state.getState()
+
+                assert.equal(result, CodeIssueGroupingStrategy.Severity)
+            })
+        })
+
+        describe('setState', function () {
+            it('should update state and fire change event for valid strategy', async function () {
+                const validStrategy = CodeIssueGroupingStrategy.FileLocation
+                const updateStub = sandbox.stub(globals.globalState, 'update').resolves()
+
+                // Create a spy to watch for event emissions
+                const eventSpy = sandbox.spy()
+                state.onDidChangeState(eventSpy)
+
+                await state.setState(validStrategy)
+
+                sinon.assert.calledWith(updateStub, 'aws.amazonq.codescan.groupingStrategy', validStrategy)
+                sinon.assert.calledWith(eventSpy, validStrategy)
+            })
+
+            it('should use fallback and fire change event for invalid strategy', async function () {
+                const invalidStrategy = 'invalid'
+                const updateStub = sandbox.stub(globals.globalState, 'update').resolves()
+
+                // Create a spy to watch for event emissions
+                const eventSpy = sandbox.spy()
+                state.onDidChangeState(eventSpy)
+
+                await state.setState(invalidStrategy)
+
+                sinon.assert.calledWith(
+                    updateStub,
+                    'aws.amazonq.codescan.groupingStrategy',
+                    CodeIssueGroupingStrategy.Severity
+                )
+                sinon.assert.calledWith(eventSpy, CodeIssueGroupingStrategy.Severity)
+            })
+        })
+
+        describe('reset', function () {
+            it('should set state to fallback value', async function () {
+                const setStateStub = sandbox.stub(state, 'setState').resolves()
+
+                await state.reset()
+
+                sinon.assert.calledWith(setStateStub, CodeIssueGroupingStrategy.Severity)
+            })
+        })
+
+        describe('onDidChangeState', function () {
+            it('should allow subscribing to state changes', async function () {
+                const listener = sandbox.spy()
+                const disposable = state.onDidChangeState(listener)
+
+                await state.setState(CodeIssueGroupingStrategy.Severity)
+
+                sinon.assert.calledWith(listener, CodeIssueGroupingStrategy.Severity)
+                disposable.dispose()
+            })
+        })
+    })
 })
diff --git a/packages/amazonq/test/unit/codewhisperer/ui/prompters.test.ts b/packages/amazonq/test/unit/codewhisperer/ui/prompters.test.ts
@@ -0,0 +1,35 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createQuickPickPrompterTester, QuickPickPrompterTester } from 'aws-core-vscode/test'
+import {
+    CodeIssueGroupingStrategy,
+    CodeIssueGroupingStrategyState,
+    createCodeIssueGroupingStrategyPrompter,
+} from 'aws-core-vscode/codewhisperer'
+import sinon from 'sinon'
+
+const severity = { label: 'Severity', data: CodeIssueGroupingStrategy.Severity }
+const fileLocation = { label: 'File Location', data: CodeIssueGroupingStrategy.FileLocation }
+
+describe('createCodeIssueGroupingStrategyPrompter', function () {
+    let tester: QuickPickPrompterTester<CodeIssueGroupingStrategy>
+
+    beforeEach(function () {
+        tester = createQuickPickPrompterTester(createCodeIssueGroupingStrategyPrompter())
+    })
+
+    it('should list grouping strategies', function () {
+        tester.assertItems([severity, fileLocation])
+    })
+
+    it('should update state on selection', async function () {
+        const spy = sinon.spy(CodeIssueGroupingStrategyState.instance, 'setState')
+
+        tester.selectItems(fileLocation)
+        tester.assertSelectedItems(fileLocation)
+
+        spy.calledWith(CodeIssueGroupingStrategy.FileLocation)
+    })
+})
diff --git a/packages/core/src/codewhisperer/commands/basicCommands.ts b/packages/core/src/codewhisperer/commands/basicCommands.ts
@@ -70,6 +70,8 @@ import { startCodeFixGeneration } from './startCodeFixGeneration'
 import { DefaultAmazonQAppInitContext } from '../../amazonq/apps/initContext'
 import path from 'path'
 import { parsePatch } from 'diff'
+import { createQuickPick } from '../../shared/ui/pickerPrompter'
+import { createCodeIssueGroupingStrategyPrompter } from '../ui/prompters'
 
 const MessageTimeOut = 5_000
 
@@ -890,27 +892,8 @@ export const showSecurityIssueFilters = Commands.declare({ id: 'aws.amazonq.secu
 export const showCodeIssueGroupingQuickPick = Commands.declare(
     { id: 'aws.amazonq.codescan.showGroupingStrategy' },
     () => async () => {
-        const quickPick = vscode.window.createQuickPick()
-        quickPick.title = localize('aws.commands.amazonq.groupIssues', 'Group Issues')
-        quickPick.placeholder = localize(
-            'aws.amazonq.codescan.groupIssues.placeholder',
-            'Select how to group code issues'
-        )
-        quickPick.items = codeIssueGroupingStrategies.map((strategy) => ({
-            label: codeIssueGroupingStrategyLabel[strategy],
-        }))
-        const groupingStrategy = CodeIssueGroupingStrategyState.instance.getState()
-        quickPick.activeItems = quickPick.items.filter(
-            (item) => item.label === codeIssueGroupingStrategyLabel[groupingStrategy]
-        )
-        quickPick.show()
-        quickPick.onDidChangeSelection(async (items) => {
-            const [item] = items
-            await CodeIssueGroupingStrategyState.instance.setState(
-                Object.entries(codeIssueGroupingStrategyLabel).find(([, label]) => label === item.label)?.[0]
-            )
-            quickPick.hide()
-        })
+        const prompter = createCodeIssueGroupingStrategyPrompter()
+        await prompter.prompt()
     }
 )
 
diff --git a/packages/core/src/codewhisperer/index.ts b/packages/core/src/codewhisperer/index.ts
@@ -101,3 +101,4 @@ export * as CodeWhispererConstants from '../codewhisperer/models/constants'
 export { getSelectedCustomization } from './util/customizationUtil'
 export { Container } from './service/serviceContainer'
 export * from './util/gitUtil'
+export * from './ui/prompters'
diff --git a/packages/core/src/codewhisperer/ui/prompters.ts b/packages/core/src/codewhisperer/ui/prompters.ts
@@ -0,0 +1,34 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+    codeIssueGroupingStrategies,
+    CodeIssueGroupingStrategy,
+    codeIssueGroupingStrategyLabel,
+    CodeIssueGroupingStrategyState,
+} from '../models/model'
+import { createQuickPick, QuickPickPrompter } from '../../shared/ui/pickerPrompter'
+import { localize } from '../../shared/utilities/vsCodeUtils'
+
+export function createCodeIssueGroupingStrategyPrompter(): QuickPickPrompter<CodeIssueGroupingStrategy> {
+    const groupingStrategy = CodeIssueGroupingStrategyState.instance.getState()
+    const prompter = createQuickPick(
+        codeIssueGroupingStrategies.map((strategy) => ({
+            data: strategy,
+            label: codeIssueGroupingStrategyLabel[strategy],
+        })),
+        {
+            title: localize('aws.commands.amazonq.groupIssues', 'Group Issues'),
+            placeholder: localize('aws.amazonq.codescan.groupIssues.placeholder', 'Select how to group code issues'),
+        }
+    )
+    prompter.quickPick.activeItems = prompter.quickPick.items.filter((item) => item.data === groupingStrategy)
+    prompter.quickPick.onDidChangeSelection(async (items) => {
+        const [item] = items
+        await CodeIssueGroupingStrategyState.instance.setState(item.data)
+        prompter.quickPick.hide()
+    })
+    return prompter
+}
diff --git a/packages/core/src/test/index.ts b/packages/core/src/test/index.ts
@@ -24,3 +24,4 @@ export * from './credentials/testUtil'
 export * from './testUtil'
 export * from './amazonqFeatureDev/utils'
 export * from './fake/mockFeatureConfigData'
+export * from './shared/ui/testUtils'
