- |
+ |
No results found.
|
@@ -65,7 +69,8 @@
:disabled="credentialsLoading"
data-test="scv-drawer-cancel-button"
@click="drawerOpen = false"
- >Cancel
+ >Cancel
@@ -108,7 +113,7 @@ const onItemSelected = (item: ScvSearchItem) => {
emit('item-selected', item)
}
-watch (() => props.isOpen, (newVal) => {
+watch(() => props.isOpen, (newVal) => {
drawerOpen.value = newVal
})
@@ -138,7 +143,7 @@ watch (() => props.isOpen, (newVal) => {
@include table.table-condensed;
border: 1px solid var(variables.$border-on-surface);
- > thead {
+ >thead {
background-color: var(variables.$border-on-surface);
padding: 1em;
text-transform: uppercase;
@@ -163,3 +168,4 @@ watch (() => props.isOpen, (newVal) => {
}
}
+
diff --git a/ui/src/components/TrapConfiguration/CreateSnmpV3User.vue b/ui/src/components/TrapConfiguration/CreateSnmpV3User.vue
deleted file mode 100644
index 9eddeda31578..000000000000
--- a/ui/src/components/TrapConfiguration/CreateSnmpV3User.vue
+++ /dev/null
@@ -1,235 +0,0 @@
-
-
-
-
-
-
-
Credential properties
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Use an existing credential
-
-
-
Finding existing credentials based on search
-
-
-
-
-
- Search
-
-
-
-
-
-
- | Alias |
- Key |
-
-
-
-
- | {{ user.alias }} |
- {{ user.value }} |
-
-
-
-
-
-
-
-
-
-
+
+
+
Credential properties
+
+
+
+
+
+
+
+
Are you sure you want to delete this SNMPv3 user with security name "{{ store.snmpV3Users[props.index]?.securityName }}"?
+
Note: This action cannot be undone.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
{{ user.username }} |
+ {{ user.securityName }} |
{{ user.securityLevel }} |
- {{ user.authenticationProtocol }} |
+ {{ user.authProtocol }} |
{{ user.privacyProtocol }} |
@@ -74,12 +76,21 @@
+
-
diff --git a/ui/src/containers/TrapdConfiguration.vue b/ui/src/containers/TrapdConfiguration.vue
new file mode 100644
index 000000000000..243387962c91
--- /dev/null
+++ b/ui/src/containers/TrapdConfiguration.vue
@@ -0,0 +1,143 @@
+
+
+
+
+
+
+
+ General Configuration
+ SNMPv3 User Management
+
+
+
+
+
+
+
+
+
+
+
'
+ },
+ FeatherIcon: true,
+ FeatherInput: FeatherInputStub,
+ 'feather-input': FeatherInputStub,
+ FeatherSelect: true,
+ 'feather-select': true,
+ ScvInputIcon: {
+ emits: ['click'],
+ template: ''
+ },
+ ScvSearchDrawer: ScvSearchDrawerStub,
+ FeatherButton: {
+ props: ['dataTest', 'disabled'],
+ emits: ['click'],
+ template: ''
+ },
+ 'feather-button': {
+ props: ['dataTest', 'disabled'],
+ emits: ['click'],
+ template: ''
+ }
+ }
+ }
+ })
+ }
+
+ const setInputValue = async (wrapper: ReturnType, dataTest: string, value: string) => {
+ const input = wrapper.find(`input[data-test="${dataTest}"]`)
+ expect(input.exists()).toBe(true)
+ await input.setValue(value)
+ }
+
+ const setBindingValue = async (wrapper: ReturnType, key: string, value: any) => {
+ ;(wrapper.vm as any)[key] = value
+ await nextTick()
+ }
+
+ const clickButton = async (wrapper: ReturnType, dataTest: string) => {
+ const button = wrapper.findComponent(`[data-test="${dataTest}"]`)
+ expect(button.exists()).toBe(true)
+ await (button as any).vm.$emit('click')
+ await flushPromises()
+ }
+
+ beforeEach(() => {
+ vi.clearAllMocks()
+ setActivePinia(
+ createTestingPinia({
+ stubActions: false,
+ createSpy: vi.fn
+ })
+ )
+
+ store = useTrapdConfigStore()
+ store.createUserDrawerState.visible = true
+ store.createUserDrawerState.mode = CreateEditMode.Create
+ store.createUserDrawerState.selectedUserIndex = -1
+ store.snmpV3Users = [selectedUser]
+ store.trapdConfig = {
+ ...getDefaultTrapdConfig(),
+ snmpv3User: [selectedUser]
+ }
+
+ store.fetchTrapConfig = vi.fn().mockResolvedValue(undefined)
+ store.closeCreateUserDrawer = vi.fn()
+ store.openCredentialDrawer = vi.fn()
+ store.closeCredentialDrawer = vi.fn()
+
+ mapUserToServerMock.mockImplementation((payload) => payload as SnmpV3User)
+ updateTrapdConfigurationMock.mockResolvedValue(undefined)
+ })
+
+ it('calls scvStore.populate on mount', () => {
+ mountComponent()
+
+ expect(useScvStoreMock).toHaveBeenCalledTimes(1)
+ expect(populateScvMock).toHaveBeenCalledTimes(1)
+ })
+
+ it('does not render when drawer is hidden', () => {
+ store.createUserDrawerState.visible = false
+ const wrapper = mountComponent()
+
+ expect(wrapper.find('[data-test="create-snmpv3-user"]').exists()).toBe(false)
+ })
+
+ it('renders create mode with heading and action buttons', () => {
+ const wrapper = mountComponent()
+
+ expect(wrapper.find('h3').text()).toBe('New SNMPv3 User Management')
+ expect(wrapper.find('[data-test="create-user-button"]').text()).toContain('Create User')
+ expect(wrapper.find('[data-test="cancel-button"]').exists()).toBe(true)
+ })
+
+ it('renders update label and preloads security name in edit mode', async () => {
+ store.createUserDrawerState.mode = CreateEditMode.Edit
+ store.createUserDrawerState.selectedUserIndex = 0
+
+ const wrapper = mountComponent()
+ await nextTick()
+ await nextTick()
+
+ expect(wrapper.find('[data-test="create-user-button"]').text()).toContain('Update User')
+ expect((wrapper.find('input[data-test="security-name-input"]').element as HTMLInputElement).value).toBe(
+ 'existing-user'
+ )
+ })
+
+ it('calls closeCreateUserDrawer from back and cancel buttons', async () => {
+ const wrapper = mountComponent()
+
+ await wrapper.findAll('button')[0].trigger('click')
+ await wrapper.find('[data-test="cancel-button"]').trigger('click')
+
+ expect(store.closeCreateUserDrawer).toHaveBeenCalledTimes(2)
+ })
+
+ it('opens credential drawer from auth passphrase button in edit mode', async () => {
+ store.createUserDrawerState.mode = CreateEditMode.Edit
+ store.createUserDrawerState.selectedUserIndex = 0
+
+ const wrapper = mountComponent()
+ await nextTick()
+
+ await wrapper.find('[data-test="auth-passphrase-save-button"]').trigger('click')
+
+ expect(store.openCredentialDrawer).toHaveBeenCalledWith('auth')
+ })
+
+ it('opens credential drawer from privacy passphrase button when privacy row is visible', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[2])
+ await wrapper.find('[data-test="privacy-passphrase-save-button"]').trigger('click')
+
+ expect(store.openCredentialDrawer).toHaveBeenCalledWith('privacy')
+ })
+
+ it('toggles auth/privacy rows based on security level', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[0])
+ expect(wrapper.find('[data-test="auth-passphrase-input"]').exists()).toBe(false)
+ expect(wrapper.find('[data-test="privacy-passphrase-input"]').exists()).toBe(false)
+
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[1])
+ expect(wrapper.find('[data-test="auth-passphrase-input"]').exists()).toBe(true)
+ expect(wrapper.find('[data-test="privacy-passphrase-input"]').exists()).toBe(false)
+
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[2])
+ expect(wrapper.find('[data-test="auth-passphrase-input"]').exists()).toBe(true)
+ expect(wrapper.find('[data-test="privacy-passphrase-input"]').exists()).toBe(true)
+ })
+
+ it('clears dependent values when security level is lowered to noAuthNoPriv', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[2])
+ await setBindingValue(wrapper, 'authProtocol', AUTH_PROTOCOL_OPTIONS[0])
+ await setBindingValue(wrapper, 'privacyProtocol', PRIVACY_PROTOCOL_OPTIONS[0])
+ await setBindingValue(wrapper, 'authPassphrase', 'auth-secret')
+ await setBindingValue(wrapper, 'privacyPassphrase', 'privacy-secret')
+
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[0])
+
+ expect((wrapper.vm as any).authProtocol).toBeUndefined()
+ expect((wrapper.vm as any).privacyProtocol).toBeUndefined()
+ expect((wrapper.vm as any).authPassphrase).toBe('')
+ expect((wrapper.vm as any).privacyPassphrase).toBe('')
+ })
+
+ it('fills auth passphrase from SCV selection and closes SCV drawer', async () => {
+ const wrapper = mountComponent()
+ store.credentialDrawerState.key = 'auth'
+ ;(wrapper.vm as any).scvItemSelected({ alias: 'vault', key: 'auth-key' })
+ await nextTick()
+
+ expect((wrapper.vm as any).authPassphrase).toBe('${scv:vault:auth-key}')
+ expect(store.closeCredentialDrawer).toHaveBeenCalledTimes(1)
+ })
+
+ it('fills privacy passphrase from SCV selection and closes SCV drawer', async () => {
+ const wrapper = mountComponent()
+ store.credentialDrawerState.key = 'privacy'
+ ;(wrapper.vm as any).scvItemSelected({ alias: 'vault', key: 'privacy-key' })
+ await nextTick()
+
+ expect((wrapper.vm as any).privacyPassphrase).toBe('${scv:vault:privacy-key}')
+ expect(store.closeCredentialDrawer).toHaveBeenCalledTimes(1)
+ })
+
+ it('closes SCV drawer when ScvSearchDrawer emits hidden', async () => {
+ const wrapper = mountComponent()
+
+ await wrapper.findComponent(ScvSearchDrawerStub).vm.$emit('hidden')
+
+ expect(store.closeCredentialDrawer).toHaveBeenCalledTimes(1)
+ })
+
+ it('closes SCV drawer without changing passphrases when SCV key is unknown', async () => {
+ const wrapper = mountComponent()
+ store.credentialDrawerState.key = 'other'
+ await setBindingValue(wrapper, 'authPassphrase', 'existing-auth')
+ await setBindingValue(wrapper, 'privacyPassphrase', 'existing-privacy')
+
+ ;(wrapper.vm as any).scvItemSelected({ alias: 'vault', key: 'some-key' })
+ await nextTick()
+
+ expect((wrapper.vm as any).authPassphrase).toBe('existing-auth')
+ expect((wrapper.vm as any).privacyPassphrase).toBe('existing-privacy')
+ expect(store.closeCredentialDrawer).toHaveBeenCalledTimes(1)
+ })
+
+ it('onSecurityLevelChange sets default auth protocol for AuthNoPriv', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[1])
+ await (wrapper.vm as any).onSecurityLevelChange()
+ await nextTick()
+
+ expect((wrapper.vm as any).authProtocol).toEqual(
+ AUTH_PROTOCOL_OPTIONS.find(option => option._value === DEFAULT_SNMP_V3_AUTH_PROTOCOL)
+ )
+ expect((wrapper.vm as any).authPassphrase).toBe('')
+ })
+
+ it('onSecurityLevelChange sets default auth/privacy protocols for AuthPriv', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[2])
+ await (wrapper.vm as any).onSecurityLevelChange()
+ await nextTick()
+
+ expect((wrapper.vm as any).authProtocol).toEqual(
+ AUTH_PROTOCOL_OPTIONS.find(option => option._value === DEFAULT_SNMP_V3_AUTH_PROTOCOL)
+ )
+ expect((wrapper.vm as any).privacyProtocol).toEqual(
+ PRIVACY_PROTOCOL_OPTIONS.find(option => option._value === DEFAULT_SNMP_V3_PRIVACY_PROTOCOL)
+ )
+ expect((wrapper.vm as any).authPassphrase).toBe('')
+ expect((wrapper.vm as any).privacyPassphrase).toBe('')
+ })
+
+ it('loads create mode defaults with NoAuthNoPriv selected', async () => {
+ const wrapper = mountComponent()
+
+ store.createUserDrawerState.mode = CreateEditMode.Create
+ store.createUserDrawerState.selectedUserIndex = -1
+ await nextTick()
+ await nextTick()
+
+ expect((wrapper.vm as any).securityLevel).toEqual(SECURITY_LEVEL_OPTIONS[0])
+ expect((wrapper.vm as any).securityName).toBe(DEFAULT_SNMP_V3_SECURITY_NAME)
+ expect((wrapper.vm as any).engineId).toBe('')
+ })
+
+ it('creates user successfully in create mode', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'new-user')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[0])
+ await clickButton(wrapper, 'create-user-button')
+
+ expect(mapUserToServerMock).toHaveBeenCalledWith(
+ expect.objectContaining({
+ securityName: 'new-user',
+ securityLevel: expect.any(Number)
+ })
+ )
+ expect(updateTrapdConfigurationMock).toHaveBeenCalledTimes(1)
+ expect(updateTrapdConfigurationMock).toHaveBeenCalledWith(
+ expect.objectContaining({
+ snmpv3User: expect.arrayContaining([expect.objectContaining({ securityName: 'new-user' })])
+ })
+ )
+ expect(store.fetchTrapConfig).toHaveBeenCalledTimes(1)
+ expect(store.closeCreateUserDrawer).toHaveBeenCalledTimes(1)
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'SNMPv3 user created successfully.' })
+ })
+
+ it('updates user successfully in edit mode', async () => {
+ store.createUserDrawerState.mode = CreateEditMode.Edit
+ store.createUserDrawerState.selectedUserIndex = 0
+
+ const wrapper = mountComponent()
+ await nextTick()
+
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[1])
+ await setBindingValue(wrapper, 'authProtocol', AUTH_PROTOCOL_OPTIONS[0])
+ await setBindingValue(wrapper, 'authPassphrase', 'masked-auth')
+ await clickButton(wrapper, 'create-user-button')
+
+ expect(updateTrapdConfigurationMock).toHaveBeenCalledTimes(1)
+ expect(updateTrapdConfigurationMock).toHaveBeenCalledWith(
+ expect.objectContaining({
+ snmpv3User: expect.arrayContaining([expect.objectContaining({ securityName: 'existing-user' })])
+ })
+ )
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'SNMPv3 user updated successfully.' })
+ })
+
+ it('shows explicit edit error when selected user cannot be found', async () => {
+ store.snmpV3Users = []
+ store.createUserDrawerState.mode = CreateEditMode.Edit
+ store.createUserDrawerState.selectedUserIndex = 0
+
+ const wrapper = mountComponent()
+ await nextTick()
+
+ await setInputValue(wrapper, 'security-name-input', 'replacement-name')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[1])
+ await setBindingValue(wrapper, 'authProtocol', AUTH_PROTOCOL_OPTIONS[0])
+ await setBindingValue(wrapper, 'authPassphrase', 'masked-auth')
+ await clickButton(wrapper, 'create-user-button')
+
+ expect(updateTrapdConfigurationMock).not.toHaveBeenCalled()
+ expect(store.fetchTrapConfig).not.toHaveBeenCalled()
+ expect(store.closeCreateUserDrawer).not.toHaveBeenCalled()
+ expect(showSnackBarMock).toHaveBeenCalledWith({
+ msg: 'Unable to determine the selected SNMPv3 user to update.',
+ error: true
+ })
+ })
+
+ it('does not require security level to match backend optional behaviour', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'new-user')
+ await setBindingValue(wrapper, 'securityLevel', createEmptySelectItem())
+
+ expect((wrapper.vm as any).error.securityLevel).toBeUndefined()
+ })
+
+ it('shows validation error when level 1 has auth credentials (backend cross-field rule)', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'new-user')
+ // Manually set auth protocol with NoAuthNoPriv level to simulate dirty state
+ ;(wrapper.vm as any).securityLevel = SECURITY_LEVEL_OPTIONS[0]
+ ;(wrapper.vm as any).authProtocol = AUTH_PROTOCOL_OPTIONS[0]
+ await nextTick()
+
+ expect((wrapper.vm as any).error.securityLevel).toBe(
+ 'Security level 1 does not allow auth or privacy credentials'
+ )
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('shows validation error when level 1 has privacy credentials (backend cross-field rule)', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'new-user')
+ ;(wrapper.vm as any).securityLevel = SECURITY_LEVEL_OPTIONS[0]
+ ;(wrapper.vm as any).privacyProtocol = PRIVACY_PROTOCOL_OPTIONS[0]
+ await nextTick()
+
+ expect((wrapper.vm as any).error.securityLevel).toBe(
+ 'Security level 1 does not allow auth or privacy credentials'
+ )
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('shows validation error when level 2 has privacy credentials (backend cross-field rule)', async () => {
+ const wrapper = mountComponent()
+
+ // Set level 2 and await so the watcher fires and clears privacyProtocol normally
+ ;(wrapper.vm as any).securityLevel = SECURITY_LEVEL_OPTIONS[1]
+ await nextTick()
+
+ // Now inject dirty privacy state AFTER the watcher ran, and call validateInputs
+ // directly before the Vue scheduler has a chance to run watchEffect again
+ ;(wrapper.vm as any).privacyProtocol = PRIVACY_PROTOCOL_OPTIONS[0]
+ const errors = (wrapper.vm as any).validateInputs()
+
+ expect(errors.privacyProtocol).toBe('Security level 2 does not allow privacy credentials')
+ })
+
+ it('requires auth protocol and auth passphrase for auth-only security level', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'auth-only-user')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[1])
+ await setBindingValue(wrapper, 'authProtocol', createEmptySelectItem())
+ await setBindingValue(wrapper, 'authPassphrase', '')
+ await clickButton(wrapper, 'create-user-button')
+
+ expect(updateTrapdConfigurationMock).not.toHaveBeenCalled()
+ expect(showSnackBarMock).toHaveBeenCalledWith({
+ msg: 'Please fix validation errors before saving.',
+ error: true
+ })
+ })
+
+ it('shows auth protocol error with passphrase-specific message when passphrase is set but protocol is cleared', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'auth-user')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[1])
+ await setBindingValue(wrapper, 'authProtocol', createEmptySelectItem())
+ await setBindingValue(wrapper, 'authPassphrase', 'some-passphrase')
+
+ expect((wrapper.vm as any).error.authProtocol).toBe('Auth Passphrase requires an Auth Protocol to be selected')
+ })
+
+ it('shows generic auth protocol error when passphrase is also missing', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'auth-user')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[1])
+ await setBindingValue(wrapper, 'authProtocol', createEmptySelectItem())
+ await setBindingValue(wrapper, 'authPassphrase', '')
+
+ expect((wrapper.vm as any).error.authProtocol).toBe('Auth Protocol is required for selected security level')
+ })
+
+ it('requires privacy protocol and privacy passphrase for auth-priv security level', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'auth-priv-user')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[2])
+ await setBindingValue(wrapper, 'authProtocol', AUTH_PROTOCOL_OPTIONS[0])
+ await setBindingValue(wrapper, 'authPassphrase', 'auth-secret')
+ await clickButton(wrapper, 'create-user-button')
+
+ expect(updateTrapdConfigurationMock).not.toHaveBeenCalled()
+ expect(showSnackBarMock).toHaveBeenCalledWith({
+ msg: 'Please fix validation errors before saving.',
+ error: true
+ })
+ })
+
+ it('shows privacy protocol error with passphrase-specific message when privacy passphrase is set but protocol is cleared', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'priv-user')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[2])
+ await setBindingValue(wrapper, 'authProtocol', AUTH_PROTOCOL_OPTIONS[0])
+ await setBindingValue(wrapper, 'authPassphrase', 'auth-secret')
+ await setBindingValue(wrapper, 'privacyProtocol', createEmptySelectItem())
+ await setBindingValue(wrapper, 'privacyPassphrase', 'privacy-secret')
+
+ expect((wrapper.vm as any).error.privacyProtocol).toBe('Privacy Passphrase requires a Privacy Protocol to be selected')
+ })
+
+ it('shows generic privacy protocol error when privacy passphrase is also missing', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'priv-user')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[2])
+ await setBindingValue(wrapper, 'authProtocol', AUTH_PROTOCOL_OPTIONS[0])
+ await setBindingValue(wrapper, 'authPassphrase', 'auth-secret')
+ await setBindingValue(wrapper, 'privacyProtocol', createEmptySelectItem())
+ await setBindingValue(wrapper, 'privacyPassphrase', '')
+
+ expect((wrapper.vm as any).error.privacyProtocol).toBe('Privacy Protocol is required for selected security level')
+ })
+
+ it('shows service error when updateTrapdConfiguration throws Error', async () => {
+ updateTrapdConfigurationMock.mockRejectedValue(new Error('save failed'))
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'new-user')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[0])
+ await clickButton(wrapper, 'create-user-button')
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'save failed', error: true })
+ })
+
+ it('shows generic service error when updateTrapdConfiguration throws non-Error', async () => {
+ updateTrapdConfigurationMock.mockRejectedValue('boom')
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'new-user')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[0])
+ await clickButton(wrapper, 'create-user-button')
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'Failed to save SNMPv3 user.', error: true })
+ })
+
+ it('prevents duplicate create requests while saving is in progress', async () => {
+ let resolveSave: () => void = () => undefined
+ updateTrapdConfigurationMock.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ resolveSave = resolve
+ })
+ )
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', 'new-user')
+ await setBindingValue(wrapper, 'securityLevel', SECURITY_LEVEL_OPTIONS[0])
+
+ await clickButton(wrapper, 'create-user-button')
+ await clickButton(wrapper, 'create-user-button')
+
+ expect(updateTrapdConfigurationMock).toHaveBeenCalledTimes(1)
+
+ resolveSave()
+ await flushPromises()
+ })
+
+ it('shows validation message when trying to save with empty security name', async () => {
+ const wrapper = mountComponent()
+
+ await setInputValue(wrapper, 'security-name-input', '')
+
+ await clickButton(wrapper, 'create-user-button')
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({
+ msg: 'Please fix validation errors before saving.',
+ error: true
+ })
+ expect(updateTrapdConfigurationMock).not.toHaveBeenCalled()
+ })
+})
diff --git a/ui/tests/components/TrapdConfiguration/GeneralConfiguration.test.ts b/ui/tests/components/TrapdConfiguration/GeneralConfiguration.test.ts
new file mode 100644
index 000000000000..9031e9b8a229
--- /dev/null
+++ b/ui/tests/components/TrapdConfiguration/GeneralConfiguration.test.ts
@@ -0,0 +1,376 @@
+import GeneralConfiguration from '@/components/TrapdConfiguration/GeneralConfiguration.vue'
+import { MAX_PORT, MIN_PORT } from '@/lib/trapdValidator'
+import { updateTrapdConfiguration } from '@/services/trapdConfigurationService'
+import { useTrapdConfigStore } from '@/stores/trapdConfigStore'
+import type { TrapConfig } from '@/types/trapConfig'
+import { createTestingPinia } from '@pinia/testing'
+import { flushPromises, mount } from '@vue/test-utils'
+import { cloneDeep } from 'lodash'
+import { setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { nextTick } from 'vue'
+
+const { showSnackBarMock } = vi.hoisted(() => ({
+ showSnackBarMock: vi.fn()
+}))
+
+vi.mock('@/composables/useSnackbar', () => ({
+ default: () => ({
+ showSnackBar: showSnackBarMock
+ })
+}))
+
+vi.mock('@/services/trapdConfigurationService', () => ({
+ updateTrapdConfiguration: vi.fn()
+}))
+
+describe('GeneralConfiguration.vue', () => {
+ let store: ReturnType
+ const updateTrapdConfigurationMock = vi.mocked(updateTrapdConfiguration)
+
+ const baseTrapConfig: TrapConfig = {
+ snmpTrapAddress: '192.168.1.10',
+ snmpTrapPort: 162,
+ newSuspectOnTrap: true,
+ includeRawMessage: false,
+ threads: 4,
+ queueSize: 5000,
+ batchSize: 250,
+ batchInterval: 750,
+ useAddressFromVarbind: true,
+ snmpv3User: []
+ }
+
+ const mountComponent = () => {
+ return mount(GeneralConfiguration, {
+ global: {
+ stubs: {
+ TableCard: {
+ template: '
'
+ },
+ FeatherExpansionPanel: {
+ props: ['title'],
+ template: '
'
+ },
+ FeatherInput: true,
+ 'feather-input': true,
+ FeatherButton: true,
+ 'feather-button': true,
+ SwitchRender: true,
+ 'switch-render': true
+ }
+ }
+ })
+ }
+
+ const setBindingValue = async (
+ wrapper: ReturnType,
+ key: string,
+ value: string | number | boolean
+ ) => {
+ ;(wrapper.vm as any)[key] = value
+ await nextTick()
+ }
+
+ beforeEach(() => {
+ vi.clearAllMocks()
+ setActivePinia(
+ createTestingPinia({
+ stubActions: false,
+ createSpy: vi.fn
+ })
+ )
+
+ store = useTrapdConfigStore()
+ store.trapdConfig = cloneDeep(baseTrapConfig)
+ store.fetchTrapConfig = vi.fn().mockResolvedValue(undefined)
+
+ updateTrapdConfigurationMock.mockResolvedValue(undefined)
+ })
+
+ it('renders the section labels and loads the current trap configuration values from the store', () => {
+ const wrapper = mountComponent()
+
+ expect(wrapper.text()).toContain('Trap Listener Settings')
+ expect(wrapper.text()).toContain('Update Changes')
+ expect((wrapper.vm as any).port).toBe(162)
+ expect((wrapper.vm as any).bindAddress).toBe('192.168.1.10')
+ expect((wrapper.vm as any).status).toBe(true)
+ expect((wrapper.vm as any).trapMessageStatus).toBe(false)
+ expect((wrapper.vm as any).trapSourceAddressStatus).toBe(true)
+ expect((wrapper.vm as any).threads).toBe(4)
+ expect((wrapper.vm as any).queueSize).toBe(5000)
+ expect((wrapper.vm as any).batchSize).toBe(250)
+ expect((wrapper.vm as any).batchInterval).toBe(750)
+ expect((wrapper.vm as any).trapConfigError).toEqual({})
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('reloads form state when trapdConfig changes in the store', async () => {
+ const wrapper = mountComponent()
+
+ store.trapdConfig = {
+ ...cloneDeep(baseTrapConfig),
+ snmpTrapPort: 10162,
+ snmpTrapAddress: '*',
+ newSuspectOnTrap: false,
+ includeRawMessage: true,
+ useAddressFromVarbind: false,
+ threads: 0,
+ queueSize: 10000,
+ batchSize: 1000,
+ batchInterval: 500
+ }
+ await nextTick()
+ await nextTick()
+
+ expect((wrapper.vm as any).port).toBe(10162)
+ expect((wrapper.vm as any).bindAddress).toBe('*')
+ expect((wrapper.vm as any).status).toBe(false)
+ expect((wrapper.vm as any).trapMessageStatus).toBe(true)
+ expect((wrapper.vm as any).trapSourceAddressStatus).toBe(false)
+ expect((wrapper.vm as any).threads).toBe(0)
+ expect((wrapper.vm as any).queueSize).toBe(10000)
+ expect((wrapper.vm as any).batchSize).toBe(1000)
+ expect((wrapper.vm as any).batchInterval).toBe(500)
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('enables save when a valid field changes and disables it again when reverted', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'port', 163)
+ expect((wrapper.vm as any).isSaveDisabled).toBe(false)
+
+ await setBindingValue(wrapper, 'port', 162)
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('toggles all switch values through the component handlers', () => {
+ const wrapper = mountComponent()
+
+ ;(wrapper.vm as any).onChangeStatus()
+ ;(wrapper.vm as any).onChangeTrapMessageStatus()
+ ;(wrapper.vm as any).onChangeTrapSourceAddressStatus()
+
+ expect((wrapper.vm as any).status).toBe(false)
+ expect((wrapper.vm as any).trapMessageStatus).toBe(true)
+ expect((wrapper.vm as any).trapSourceAddressStatus).toBe(false)
+ })
+
+ it('submits the updated payload successfully and refreshes the store', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'port', '10162')
+ await setBindingValue(wrapper, 'bindAddress', '*')
+ await setBindingValue(wrapper, 'status', false)
+ await setBindingValue(wrapper, 'trapMessageStatus', true)
+ await setBindingValue(wrapper, 'trapSourceAddressStatus', false)
+ await setBindingValue(wrapper, 'threads', '2')
+ await setBindingValue(wrapper, 'queueSize', '6000')
+ await setBindingValue(wrapper, 'batchSize', '300')
+ await setBindingValue(wrapper, 'batchInterval', '900')
+
+ await (wrapper.vm as any).updateConfig()
+ await flushPromises()
+
+ expect(updateTrapdConfigurationMock).toHaveBeenCalledWith({
+ snmpTrapPort: 10162,
+ snmpTrapAddress: '*',
+ newSuspectOnTrap: false,
+ useAddressFromVarbind: false,
+ includeRawMessage: true,
+ threads: 2,
+ queueSize: 6000,
+ batchSize: 300,
+ batchInterval: 900,
+ snmpv3User: []
+ })
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'Trap configuration updated successfully.' })
+ expect(store.fetchTrapConfig).toHaveBeenCalledTimes(1)
+ expect((wrapper.vm as any).isSaving).toBe(false)
+ })
+
+ it('shows the service error message when update fails with an Error', async () => {
+ updateTrapdConfigurationMock.mockRejectedValue(new Error('update failed'))
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'port', 163)
+ await (wrapper.vm as any).updateConfig()
+ await flushPromises()
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'update failed', error: true })
+ expect(store.fetchTrapConfig).not.toHaveBeenCalled()
+ expect((wrapper.vm as any).isSaving).toBe(false)
+ })
+
+ it('shows a generic error message when update fails with a non-Error value', async () => {
+ updateTrapdConfigurationMock.mockRejectedValue('boom')
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'port', 163)
+ await (wrapper.vm as any).updateConfig()
+ await flushPromises()
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'Failed to update trap configuration.', error: true })
+ expect(store.fetchTrapConfig).not.toHaveBeenCalled()
+ expect((wrapper.vm as any).isSaving).toBe(false)
+ })
+
+ it('includes store snmpV3Users in the update payload', async () => {
+ store.snmpV3Users = [{
+ securityName: 'sec-user-1',
+ securityLevel: 1,
+ authProtocol: null,
+ authPassphrase: null,
+ privacyProtocol: null,
+ privacyPassphrase: null,
+ engineId: null
+ }]
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'port', 163)
+ await (wrapper.vm as any).updateConfig()
+ await flushPromises()
+
+ expect(updateTrapdConfigurationMock).toHaveBeenCalledWith(expect.objectContaining({
+ snmpv3User: [
+ expect.objectContaining({ securityName: 'sec-user-1' })
+ ]
+ }))
+ })
+
+ it('sets isSaving during an in-flight request and clears it after completion', async () => {
+ let resolveRequest: (() => void) | undefined
+ updateTrapdConfigurationMock.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ resolveRequest = resolve
+ })
+ )
+
+ const wrapper = mountComponent()
+ await setBindingValue(wrapper, 'port', 163)
+
+ const pendingSave = (wrapper.vm as any).updateConfig()
+ await nextTick()
+
+ expect((wrapper.vm as any).isSaving).toBe(true)
+
+ resolveRequest?.()
+ await pendingSave
+ await flushPromises()
+
+ expect((wrapper.vm as any).isSaving).toBe(false)
+ })
+
+ it(`shows a validation error when port is less than ${MIN_PORT}`, async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'port', 0)
+
+ expect((wrapper.vm as any).trapConfigError.port).toBe(`Port must be between ${MIN_PORT} and ${MAX_PORT}.`)
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it(`shows a validation error when port is greater than ${MAX_PORT}`, async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'port', 65536)
+
+ expect((wrapper.vm as any).trapConfigError.port).toBe(`Port must be between ${MIN_PORT} and ${MAX_PORT}.`)
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('shows a validation error when bind address is empty', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'bindAddress', '')
+
+ expect((wrapper.vm as any).trapConfigError.bindAddress).toBe('Bind Address cannot be empty.')
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('shows a validation error when bind address is not * or a valid IPv4 address', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'bindAddress', 'localhost')
+
+ expect((wrapper.vm as any).trapConfigError.bindAddress).toBe('Bind Address must be * or a valid IP address.')
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('accepts wildcard bind address as a valid value', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'bindAddress', '*')
+
+ expect((wrapper.vm as any).trapConfigError.bindAddress).toBeUndefined()
+ expect((wrapper.vm as any).isSaveDisabled).toBe(false)
+ })
+
+ it('shows a validation error when threads is negative', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'threads', -1)
+
+ expect((wrapper.vm as any).trapConfigError.threads).toBe('Threads cannot be negative.')
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('shows a validation error when queue size is negative', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'queueSize', -1)
+
+ expect((wrapper.vm as any).trapConfigError.queueSize).toBe('Queue Size must be greater than 0.')
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('shows a validation error when queue size is zero', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'queueSize', 0)
+
+ expect((wrapper.vm as any).trapConfigError.queueSize).toBe('Queue Size must be greater than 0.')
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('shows a validation error when batch size is negative', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'batchSize', -1)
+
+ expect((wrapper.vm as any).trapConfigError.batchSize).toBe('Batch Size must be greater than 0.')
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('shows a validation error when batch size is zero', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'batchSize', 0)
+
+ expect((wrapper.vm as any).trapConfigError.batchSize).toBe('Batch Size must be greater than 0.')
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('shows a validation error when batch interval is negative', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'batchInterval', -1)
+
+ expect((wrapper.vm as any).trapConfigError.batchInterval).toBe('Batch Interval cannot be negative.')
+ expect((wrapper.vm as any).isSaveDisabled).toBe(true)
+ })
+
+ it('does not call the update service when the form is invalid', async () => {
+ const wrapper = mountComponent()
+
+ await setBindingValue(wrapper, 'bindAddress', '')
+ await (wrapper.vm as any).updateConfig()
+ await flushPromises()
+
+ expect(updateTrapdConfigurationMock).not.toHaveBeenCalled()
+ expect(showSnackBarMock).not.toHaveBeenCalled()
+ })
+})
\ No newline at end of file
diff --git a/ui/tests/components/TrapdConfiguration/SnmpV3UserManagement.test.ts b/ui/tests/components/TrapdConfiguration/SnmpV3UserManagement.test.ts
new file mode 100644
index 000000000000..97c2569a75a1
--- /dev/null
+++ b/ui/tests/components/TrapdConfiguration/SnmpV3UserManagement.test.ts
@@ -0,0 +1,401 @@
+import SnmpV3UserManagement from '@/components/TrapdConfiguration/SnmpV3UserManagement.vue'
+import { updateTrapdConfiguration } from '@/services/trapdConfigurationService'
+import { useTrapdConfigStore } from '@/stores/trapdConfigStore'
+import { CreateEditMode } from '@/types'
+import type { SnmpV3User } from '@/types/trapConfig'
+import { FeatherSortHeader, SORT } from '@featherds/table'
+import { createTestingPinia } from '@pinia/testing'
+import { flushPromises, mount } from '@vue/test-utils'
+import { setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { defineComponent, nextTick } from 'vue'
+
+const { showSnackBarMock } = vi.hoisted(() => ({
+ showSnackBarMock: vi.fn()
+}))
+
+vi.mock('@/composables/useSnackbar', () => ({
+ default: () => ({
+ showSnackBar: showSnackBarMock
+ })
+}))
+
+vi.mock('@/services/trapdConfigurationService', () => ({
+ updateTrapdConfiguration: vi.fn()
+}))
+
+const FeatherButtonStub = defineComponent({
+ name: 'FeatherButton',
+ props: {
+ dataTest: {
+ type: String,
+ default: ''
+ },
+ disabled: {
+ type: Boolean,
+ default: false
+ },
+ icon: {
+ type: String,
+ default: ''
+ }
+ },
+ emits: ['click'],
+ template:
+ ''
+})
+
+const FeatherSortHeaderStub = defineComponent({
+ name: 'FeatherSortHeader',
+ props: {
+ property: {
+ type: String,
+ default: ''
+ },
+ sort: {
+ type: String,
+ default: ''
+ }
+ },
+ emits: ['sort-changed'],
+ template: ' | '
+})
+
+const DeleteDialogStub = defineComponent({
+ name: 'DeleteUserConfirmationDialog',
+ props: {
+ visible: {
+ type: Boolean,
+ default: false
+ }
+ },
+ emits: ['close', 'confirm'],
+ template: `
+
+ {{ String(visible) }}
+
+
+
'
+ },
+ EmptyList: {
+ props: ['content'],
+ template: '{{ content.msg }} '
+ },
+ DeleteUserConfirmationDialog: DeleteDialogStub,
+ FeatherButton: FeatherButtonStub,
+ 'feather-button': FeatherButtonStub,
+ FeatherSortHeader: FeatherSortHeaderStub,
+ 'feather-sort-header': FeatherSortHeaderStub,
+ FeatherIcon: true,
+ 'feather-icon': true,
+ TransitionGroup: {
+ template: ''
+ }
+ }
+ }
+ })
+ }
+
+ const clickByDataTest = async (wrapper: ReturnType, dataTest: string, index = 0) => {
+ const elements = wrapper.findAll(`[data-test="${dataTest}"]`)
+ expect(elements[index]?.exists()).toBe(true)
+ await elements[index].trigger('click')
+ await flushPromises()
+ }
+
+ beforeEach(() => {
+ vi.clearAllMocks()
+ setActivePinia(
+ createTestingPinia({
+ stubActions: false,
+ createSpy: vi.fn
+ })
+ )
+
+ store = useTrapdConfigStore()
+ store.createUserDrawerState.visible = false
+ store.snmpV3Users = [...users]
+ store.trapdConfig = {
+ snmpTrapAddress: '127.0.0.1',
+ snmpTrapPort: 162,
+ newSuspectOnTrap: false,
+ includeRawMessage: false,
+ threads: 0,
+ queueSize: 10000,
+ batchSize: 1000,
+ batchInterval: 500,
+ useAddressFromVarbind: false,
+ snmpv3User: [...users]
+ }
+ store.fetchTrapConfig = vi.fn().mockResolvedValue(undefined)
+ store.openCreateUserDrawer = vi.fn()
+
+ updateTrapdConfigurationMock.mockResolvedValue(undefined)
+ })
+
+ it('does not render when the create user drawer is visible', () => {
+ store.createUserDrawerState.visible = true
+ const wrapper = mountComponent()
+
+ expect(wrapper.find('[data-test="snmpv3-user-management"]').exists()).toBe(false)
+ })
+
+ it('renders the heading, add button, column headers, and user rows', () => {
+ const wrapper = mountComponent()
+
+ expect(wrapper.text()).toContain('SNMPv3 User Management')
+ expect(wrapper.text()).toContain('List SNMPv3 users credentials')
+ expect(wrapper.find('[data-test="add-user-button"]').exists()).toBe(true)
+ expect(wrapper.text()).toContain('SnmpV3 Username')
+ expect(wrapper.text()).toContain('Security Level')
+ expect(wrapper.text()).toContain('Authentication Protocol')
+ expect(wrapper.text()).toContain('Privacy Protocol')
+ expect(wrapper.text()).toContain('Action')
+ expect(wrapper.text()).toContain('user-one')
+ expect(wrapper.text()).toContain('user-two')
+ expect((wrapper.vm as any).tableRecords).toEqual(users)
+ })
+
+ it('renders the empty state when there are no users', async () => {
+ store.snmpV3Users = []
+ const wrapper = mountComponent()
+ await nextTick()
+
+ expect(wrapper.find('[data-test="empty-list"]').text()).toBe('No SNMPv3 users found')
+ expect(wrapper.findAll('tbody tr')).toHaveLength(0)
+ })
+
+ it('opens create user drawer in create mode from the add user button', async () => {
+ const wrapper = mountComponent()
+
+ await clickByDataTest(wrapper, 'add-user-button')
+
+ expect(store.openCreateUserDrawer).toHaveBeenCalledWith(CreateEditMode.Create, -1)
+ })
+
+ it('opens create user drawer in edit mode for the selected row', async () => {
+ const wrapper = mountComponent()
+
+ await clickByDataTest(wrapper, 'edit-user-button', 1)
+
+ expect(store.openCreateUserDrawer).toHaveBeenCalledWith(CreateEditMode.Edit, 1)
+ })
+
+ it('opens the delete dialog with the selected index', async () => {
+ const wrapper = mountComponent()
+
+ await clickByDataTest(wrapper, 'delete-user-button', 1)
+
+ expect((wrapper.vm as any).deleteUserIndex).toBe(1)
+ expect((wrapper.vm as any).deleteDialogVisible).toBe(true)
+ expect(wrapper.find('[data-test="delete-dialog-visible"]').text()).toBe('true')
+ })
+
+ it('cancels delete and resets dialog state', async () => {
+ const wrapper = mountComponent()
+ ;(wrapper.vm as any).openDeleteUserDialog(0)
+ await nextTick()
+
+ await clickByDataTest(wrapper, 'close-delete-dialog')
+
+ expect((wrapper.vm as any).deleteUserIndex).toBe(null)
+ expect((wrapper.vm as any).deleteDialogVisible).toBe(false)
+ })
+
+ it('deletes the selected user successfully, refreshes config, and closes the dialog', async () => {
+ const wrapper = mountComponent()
+ ;(wrapper.vm as any).openDeleteUserDialog(0)
+ await nextTick()
+
+ await clickByDataTest(wrapper, 'confirm-delete-dialog')
+
+ expect(updateTrapdConfigurationMock).toHaveBeenCalledTimes(1)
+ expect(updateTrapdConfigurationMock).toHaveBeenCalledWith(expect.objectContaining({
+ snmpv3User: [expect.objectContaining({ securityName: 'user-two' })]
+ }))
+ expect(store.fetchTrapConfig).toHaveBeenCalledTimes(1)
+ expect((wrapper.vm as any).deleteUserIndex).toBe(null)
+ expect((wrapper.vm as any).deleteDialogVisible).toBe(false)
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'SNMPv3 user deleted successfully.' })
+ expect((wrapper.vm as any).isDeleting).toBe(false)
+ })
+
+ it('shows the service error when delete fails with an Error', async () => {
+ updateTrapdConfigurationMock.mockRejectedValue(new Error('delete failed'))
+ const wrapper = mountComponent()
+ ;(wrapper.vm as any).openDeleteUserDialog(0)
+ await nextTick()
+
+ await clickByDataTest(wrapper, 'confirm-delete-dialog')
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'delete failed', error: true })
+ expect(store.fetchTrapConfig).not.toHaveBeenCalled()
+ expect((wrapper.vm as any).deleteUserIndex).toBe(0)
+ expect((wrapper.vm as any).deleteDialogVisible).toBe(true)
+ expect((wrapper.vm as any).isDeleting).toBe(false)
+ })
+
+ it('shows a generic error when delete fails with a non-Error value', async () => {
+ updateTrapdConfigurationMock.mockRejectedValue('boom')
+ const wrapper = mountComponent()
+ ;(wrapper.vm as any).openDeleteUserDialog(0)
+ await nextTick()
+
+ await clickByDataTest(wrapper, 'confirm-delete-dialog')
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'Failed to delete SNMPv3 user.', error: true })
+ })
+
+ it('does not call delete when no selected index exists', async () => {
+ const wrapper = mountComponent()
+
+ await (wrapper.vm as any).confirmDeleteUser()
+ await flushPromises()
+
+ expect(updateTrapdConfigurationMock).not.toHaveBeenCalled()
+ expect((wrapper.vm as any).deleteUserIndex).toBe(null)
+ expect((wrapper.vm as any).deleteDialogVisible).toBe(false)
+ expect(showSnackBarMock).not.toHaveBeenCalled()
+ })
+
+ it('does not call delete again while a delete request is already in progress', async () => {
+ let resolveDelete: (() => void) | undefined
+ updateTrapdConfigurationMock.mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ resolveDelete = resolve
+ })
+ )
+
+ const wrapper = mountComponent()
+ ;(wrapper.vm as any).openDeleteUserDialog(0)
+ await nextTick()
+
+ const pendingDelete = (wrapper.vm as any).confirmDeleteUser()
+ await nextTick()
+ await (wrapper.vm as any).confirmDeleteUser()
+
+ expect(updateTrapdConfigurationMock).toHaveBeenCalledTimes(1)
+ expect((wrapper.vm as any).isDeleting).toBe(true)
+
+ resolveDelete?.()
+ await pendingDelete
+ await flushPromises()
+
+ expect((wrapper.vm as any).isDeleting).toBe(false)
+ })
+
+ it('updates tableRecords when the store users list changes', async () => {
+ const wrapper = mountComponent()
+ const nextUsers: SnmpV3User[] = [
+ {
+ engineId: null,
+ securityName: 'replacement-user',
+ securityLevel: 2,
+ authProtocol: 'MD5',
+ authPassphrase: 'masked',
+ privacyProtocol: null,
+ privacyPassphrase: null
+ }
+ ]
+
+ store.snmpV3Users = nextUsers
+ await nextTick()
+ await nextTick()
+
+ expect((wrapper.vm as any).tableRecords).toEqual(nextUsers)
+ expect(wrapper.text()).toContain('replacement-user')
+ expect(wrapper.text()).not.toContain('user-one')
+ })
+
+ it('falls back to an empty records list when store users become undefined', async () => {
+ const wrapper = mountComponent()
+
+ ;(store as any).snmpV3Users = undefined
+ await nextTick()
+ await nextTick()
+
+ expect((wrapper.vm as any).tableRecords).toEqual([])
+ })
+
+ it('shows user-not-found error and closes dialog when selected index is out of range', async () => {
+ const wrapper = mountComponent()
+ ;(wrapper.vm as any).openDeleteUserDialog(99)
+ await nextTick()
+
+ await (wrapper.vm as any).confirmDeleteUser()
+ await flushPromises()
+
+ expect(updateTrapdConfigurationMock).not.toHaveBeenCalled()
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'SNMPv3 user not found.', error: true })
+ expect((wrapper.vm as any).deleteUserIndex).toBe(null)
+ expect((wrapper.vm as any).deleteDialogVisible).toBe(false)
+ })
+
+ it('updates sort state when a sort header emits sort-changed', async () => {
+ const wrapper = mountComponent()
+ const sortHeaders = wrapper.findAllComponents(FeatherSortHeader)
+
+ expect(sortHeaders).toHaveLength(4)
+ await sortHeaders[1].vm.$emit('sort-changed', {
+ property: 'securityLevel',
+ value: SORT.ASCENDING
+ })
+ await nextTick()
+
+ expect((wrapper.vm as any).sort.username).toBe(SORT.NONE)
+ expect((wrapper.vm as any).sort.securityLevel).toBe(SORT.ASCENDING)
+ expect((wrapper.vm as any).sort.authenticationProtocol).toBe(SORT.NONE)
+ expect((wrapper.vm as any).sort.privacyProtocol).toBe(SORT.NONE)
+ })
+
+ it('sortChanged resets previous sort values before applying the next property', () => {
+ const wrapper = mountComponent()
+
+ ;(wrapper.vm as any).sort.username = SORT.DESCENDING
+ ;(wrapper.vm as any).sort.securityLevel = SORT.ASCENDING
+ ;(wrapper.vm as any).sortChanged({
+ property: 'privacyProtocol',
+ value: SORT.ASCENDING
+ })
+
+ expect((wrapper.vm as any).sort.username).toBe(SORT.NONE)
+ expect((wrapper.vm as any).sort.securityLevel).toBe(SORT.NONE)
+ expect((wrapper.vm as any).sort.authenticationProtocol).toBe(SORT.NONE)
+ expect((wrapper.vm as any).sort.privacyProtocol).toBe(SORT.ASCENDING)
+ })
+})
diff --git a/ui/tests/containers/TrapdConfiguration.test.ts b/ui/tests/containers/TrapdConfiguration.test.ts
new file mode 100644
index 000000000000..848385fd893f
--- /dev/null
+++ b/ui/tests/containers/TrapdConfiguration.test.ts
@@ -0,0 +1,252 @@
+import BreadCrumbs from '@/components/Layout/BreadCrumbs.vue'
+import TrapdConfiguration from '@/containers/TrapdConfiguration.vue'
+import { validateTrapdXml } from '@/lib/trapdValidator'
+import { uploadTrapdConfiguration } from '@/services/trapdConfigurationService'
+import { useMenuStore } from '@/stores/menuStore'
+import { useTrapdConfigStore } from '@/stores/trapdConfigStore'
+import { createTestingPinia } from '@pinia/testing'
+import { mount } from '@vue/test-utils'
+import { setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { showSnackBarMock } = vi.hoisted(() => ({
+ showSnackBarMock: vi.fn()
+}))
+
+vi.mock('@/composables/useSnackbar', () => ({
+ default: () => ({
+ showSnackBar: showSnackBarMock
+ })
+}))
+
+vi.mock('@/lib/trapdValidator', async (importOriginal) => {
+ const actual = await importOriginal()
+ return {
+ ...actual,
+ validateTrapdXml: vi.fn()
+ }
+})
+
+vi.mock('@/services/trapdConfigurationService', () => ({
+ uploadTrapdConfiguration: vi.fn()
+}))
+
+describe('TrapdConfiguration.vue', () => {
+ let trapStore: ReturnType
+ let menuStore: ReturnType
+
+ const validateTrapdXmlMock = vi.mocked(validateTrapdXml)
+ const uploadTrapdConfigurationMock = vi.mocked(uploadTrapdConfiguration)
+
+ const mountComponent = () => {
+ return mount(TrapdConfiguration, {
+ global: {
+ stubs: {
+ GeneralConfiguration: true,
+ SnmpV3UserManagement: true,
+ CreateSnmpV3User: true,
+ FeatherTabContainer: {
+ template: '
'
+ },
+ FeatherTab: {
+ template: '
'
+ },
+ FeatherTabPanel: {
+ template: '
'
+ },
+ FeatherButton: {
+ template: ''
+ },
+ BreadCrumbs: true
+ }
+ }
+ })
+ }
+
+ const createXmlFile = (name = 'trapd.xml', content = '') => {
+ const file = new File([content], name, { type: 'text/xml' })
+ vi.spyOn(file, 'text').mockResolvedValue(content)
+ return file
+ }
+
+ const triggerUpload = async (wrapper: ReturnType, file?: File) => {
+ const input = wrapper.find('input[type="file"]')
+ Object.defineProperty(input.element, 'files', {
+ value: file ? [file] : [],
+ configurable: true
+ })
+ await input.trigger('change')
+ }
+
+ beforeEach(() => {
+ vi.clearAllMocks()
+ setActivePinia(createTestingPinia({ stubActions: true }))
+ trapStore = useTrapdConfigStore()
+ menuStore = useMenuStore()
+ menuStore.mainMenu = { homeUrl: '/home' } as any
+ trapStore.fetchTrapConfig = vi.fn().mockResolvedValue(undefined)
+ validateTrapdXmlMock.mockReturnValue({ valid: true, errors: [] })
+ uploadTrapdConfigurationMock.mockResolvedValue(undefined)
+ })
+
+ it('renders heading and child sections', () => {
+ const wrapper = mountComponent()
+
+ expect(wrapper.find('h1').text()).toBe('Trap Listener Configuration')
+ expect(wrapper.findComponent(BreadCrumbs).exists()).toBe(true)
+ expect(wrapper.find('input[type="file"]').exists()).toBe(true)
+ })
+
+ it('renders breadcrumbs with home and trap configuration entries', () => {
+ const wrapper = mountComponent()
+ const breadcrumbs = wrapper.findComponent(BreadCrumbs)
+ const items = breadcrumbs.props('items')
+
+ expect(items).toHaveLength(2)
+ expect(items[0]).toEqual({ label: 'Home', to: '/home', isAbsoluteLink: true })
+ expect(items[1]).toEqual({ label: 'Trap Listener Configuration', to: '#', position: 'last' })
+ })
+
+ it('calls fetchTrapConfig on mount', () => {
+ mountComponent()
+ expect(trapStore.fetchTrapConfig).toHaveBeenCalledTimes(1)
+ })
+
+ it('shows snackbar when initial fetch fails with Error', async () => {
+ trapStore.fetchTrapConfig = vi.fn().mockRejectedValue(new Error('initial fetch failed'))
+
+ mountComponent()
+ await Promise.resolve()
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'initial fetch failed', error: true })
+ })
+
+ it('shows snackbar when initial fetch fails with non-Error', async () => {
+ trapStore.fetchTrapConfig = vi.fn().mockRejectedValue('boom')
+
+ mountComponent()
+ await Promise.resolve()
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'Failed to retrieve trapd configuration.', error: true })
+ })
+
+ it('opens file chooser when upload button is clicked', async () => {
+ const wrapper = mountComponent()
+ const input = wrapper.find('input[type="file"]').element as HTMLInputElement
+ const clickSpy = vi.spyOn(input, 'click').mockImplementation(() => undefined)
+
+ const uploadButton = wrapper.findAll('button').find((button) => button.text().includes('Upload Configuration'))
+ expect(uploadButton).toBeDefined()
+
+ await uploadButton!.trigger('click')
+ expect(clickSpy).toHaveBeenCalledTimes(1)
+ })
+
+ it('returns early when no file is selected', async () => {
+ const wrapper = mountComponent()
+ await triggerUpload(wrapper)
+
+ expect(validateTrapdXmlMock).not.toHaveBeenCalled()
+ expect(uploadTrapdConfigurationMock).not.toHaveBeenCalled()
+ })
+
+ it('rejects non-xml files before validation', async () => {
+ const wrapper = mountComponent()
+ const invalidFile = createXmlFile('trapd.txt', 'not xml')
+
+ await triggerUpload(wrapper, invalidFile)
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'Only .xml files are supported.', error: true })
+ expect(validateTrapdXmlMock).not.toHaveBeenCalled()
+ expect(uploadTrapdConfigurationMock).not.toHaveBeenCalled()
+ })
+
+ it('shows read error when file.text fails', async () => {
+ const wrapper = mountComponent()
+ const file = new File(['x'], 'trapd.xml', { type: 'text/xml' })
+ vi.spyOn(file, 'text').mockRejectedValue(new Error('read failed'))
+
+ await triggerUpload(wrapper, file)
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'Failed to read XML file.', error: true })
+ expect(validateTrapdXmlMock).not.toHaveBeenCalled()
+ expect(uploadTrapdConfigurationMock).not.toHaveBeenCalled()
+ })
+
+ it('blocks upload and shows validation errors when XML is invalid (<=3 errors)', async () => {
+ const wrapper = mountComponent()
+ const file = createXmlFile('trapd.xml', '')
+ validateTrapdXmlMock.mockReturnValue({
+ valid: false,
+ errors: [
+ { field: 'root', message: 'Root mismatch' },
+ { field: 'xmlns', message: 'Namespace invalid' },
+ { field: 'snmp-trap-port', message: 'Port invalid' }
+ ]
+ })
+
+ await triggerUpload(wrapper, file)
+
+ expect(validateTrapdXmlMock).toHaveBeenCalledWith('')
+ expect(showSnackBarMock).toHaveBeenCalledWith({
+ msg: 'Invalid trap configuration XML: Root mismatch | Namespace invalid | Port invalid',
+ error: true
+ })
+ expect(uploadTrapdConfigurationMock).not.toHaveBeenCalled()
+ })
+
+ it('shows +N more suffix for validation errors beyond first 3', async () => {
+ const wrapper = mountComponent()
+ const file = createXmlFile('trapd.xml', '')
+ validateTrapdXmlMock.mockReturnValue({
+ valid: false,
+ errors: [
+ { field: 'a', message: 'e1' },
+ { field: 'b', message: 'e2' },
+ { field: 'c', message: 'e3' },
+ { field: 'd', message: 'e4' },
+ { field: 'e', message: 'e5' }
+ ]
+ })
+
+ await triggerUpload(wrapper, file)
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({
+ msg: 'Invalid trap configuration XML: e1 | e2 | e3 (+2 more)',
+ error: true
+ })
+ expect(uploadTrapdConfigurationMock).not.toHaveBeenCalled()
+ })
+
+ it('uploads file and refreshes store when XML is valid', async () => {
+ const wrapper = mountComponent()
+ const file = createXmlFile('trapd.xml', '')
+
+ await triggerUpload(wrapper, file)
+
+ expect(validateTrapdXmlMock).toHaveBeenCalledWith('')
+ expect(uploadTrapdConfigurationMock).toHaveBeenCalledWith(file)
+ expect(trapStore.fetchTrapConfig).toHaveBeenCalledTimes(2)
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'Trap configuration uploaded successfully.' })
+ })
+
+ it('shows upload error message from Error instance', async () => {
+ const wrapper = mountComponent()
+ const file = createXmlFile('trapd.xml', '')
+ uploadTrapdConfigurationMock.mockRejectedValue(new Error('upload failed'))
+
+ await triggerUpload(wrapper, file)
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'upload failed', error: true })
+ })
+
+ it('shows generic upload error message for non-Error throw', async () => {
+ const wrapper = mountComponent()
+ const file = createXmlFile('trapd.xml', '')
+ uploadTrapdConfigurationMock.mockRejectedValue('bad')
+
+ await triggerUpload(wrapper, file)
+
+ expect(showSnackBarMock).toHaveBeenCalledWith({ msg: 'Failed to upload trap configuration.', error: true })
+ })
+})
diff --git a/ui/tests/lib/trapdValidator.test.ts b/ui/tests/lib/trapdValidator.test.ts
new file mode 100644
index 000000000000..0ef301f7c39c
--- /dev/null
+++ b/ui/tests/lib/trapdValidator.test.ts
@@ -0,0 +1,694 @@
+import { XMLParser, XMLValidator } from 'fast-xml-parser'
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
+import {
+ AUTH_PROTOCOL_OPTIONS,
+ AuthProtocol,
+ AuthProtocols,
+ MAX_PORT,
+ MIN_PORT,
+ PRIVACY_PROTOCOL_OPTIONS,
+ PrivacyProtocol,
+ PrivacyProtocols,
+ SECURITY_LEVEL_OPTIONS,
+ SecurityLevel,
+ TRAPD_XML_NAMESPACE,
+ getDefaultTrapdConfig,
+ isValidIP,
+ isValidPort,
+ isValidSnmpSecurityLevel,
+ validateTrapdXml
+} from '@/lib/trapdValidator'
+
+// ---------------------------------------------------------------------------
+// DOMParser polyfill (fast-xml-parser backed)
+//
+// happy-dom v9 parses ALL MIME types as HTML, so root.namespaceURI is always
+// the XHTML namespace. We replace window.DOMParser with a minimal but correct
+// implementation for the subset of the DOM API that validateTrapdXml uses.
+// ---------------------------------------------------------------------------
+
+class FakeElement {
+ localName: string
+ namespaceURI: string | null
+ textContent: string | null = null
+ private attrs: Record
+ private children: FakeElement[]
+
+ constructor(localName: string, attrs: Record, children: FakeElement[] = []) {
+ this.localName = localName
+ this.attrs = attrs
+ this.children = children
+ this.namespaceURI = attrs['xmlns'] ?? null
+ }
+
+ getAttribute(name: string): string | null {
+ return Object.prototype.hasOwnProperty.call(this.attrs, name) ? this.attrs[name] : null
+ }
+
+ getElementsByTagName(tagName: string): FakeElement[] {
+ const results: FakeElement[] = []
+ for (const child of this.children) {
+ if (child.localName === tagName) results.push(child)
+ results.push(...child.getElementsByTagName(tagName))
+ }
+ return results
+ }
+}
+
+class FakeDocument {
+ documentElement: FakeElement
+ private parseError: FakeElement | null
+
+ constructor(root: FakeElement, parseError: FakeElement | null = null) {
+ this.documentElement = root
+ this.parseError = parseError
+ }
+
+ querySelector(selector: string): FakeElement | null {
+ return selector === 'parsererror' ? this.parseError : null
+ }
+}
+
+function buildElement(tagName: string, node: Record): FakeElement {
+ const attrs: Record = {}
+ const children: FakeElement[] = []
+
+ for (const [key, value] of Object.entries(node)) {
+ if (key.startsWith('@_')) {
+ attrs[key.slice(2)] = String(value)
+ } else if (Array.isArray(value)) {
+ for (const child of value as Record[]) {
+ children.push(buildElement(key, child))
+ }
+ } else if (typeof value === 'object' && value !== null) {
+ children.push(buildElement(key, value as Record))
+ }
+ }
+
+ return new FakeElement(tagName, attrs, children)
+}
+
+const fxpParser = new XMLParser({
+ ignoreAttributes: false,
+ attributeNamePrefix: '@_',
+ isArray: (name) => name === 'snmpv3-user',
+ parseAttributeValue: false,
+ trimValues: false
+})
+
+class FakeDOMParser {
+ parseFromString(xmlString: string, _mimeType: string): FakeDocument {
+ void _mimeType
+ const validation = XMLValidator.validate(xmlString)
+ if (validation !== true) {
+ const errEl = new FakeElement('parsererror', {})
+ errEl.textContent = (validation as { err: { msg: string } }).err?.msg ?? 'parse error'
+ const dummyRoot = new FakeElement('parsererror', {})
+ return new FakeDocument(dummyRoot, errEl)
+ }
+
+ const parsed = fxpParser.parse(xmlString) as Record>
+ const rootTagName = Object.keys(parsed)[0]
+ const rootNode = parsed[rootTagName] ?? {}
+ const root = buildElement(rootTagName, rootNode)
+ return new FakeDocument(root)
+ }
+}
+
+beforeAll(() => {
+ vi.stubGlobal('DOMParser', FakeDOMParser)
+})
+
+afterAll(() => {
+ vi.unstubAllGlobals()
+})
+
+const VALID_NS = TRAPD_XML_NAMESPACE
+
+/** Build a minimal valid trapd XML string, overriding individual attributes. */
+const buildXml = (overrides: {
+ root?: string
+ xmlns?: string | null
+ address?: string | null
+ port?: string | null
+ suspect?: string | null
+ users?: string
+} = {}): string => {
+ const {
+ root = 'trapd-configuration',
+ xmlns = VALID_NS,
+ address = '*',
+ port = '162',
+ suspect = null,
+ users = ''
+ } = overrides
+
+ const nsAttr = xmlns === null ? '' : ` xmlns="${xmlns}"`
+ const addrAttr = address === null ? '' : ` snmp-trap-address="${address}"`
+ const portAttr = port === null ? '' : ` snmp-trap-port="${port}"`
+ const suspectAttr = suspect === null ? '' : ` new-suspect-on-trap="${suspect}"`
+
+ if (users) {
+ return `<${root}${nsAttr}${addrAttr}${portAttr}${suspectAttr}>${users}`
+ }
+ return `<${root}${nsAttr}${addrAttr}${portAttr}${suspectAttr} />`
+}
+
+/** Build a element string from an attribute map. */
+const buildUser = (attrs: Record = {}): string => {
+ const attrStr = Object.entries(attrs)
+ .map(([k, v]) => `${k}="${v}"`)
+ .join(' ')
+ return ``
+}
+
+describe('isValidPort', () => {
+ it.each([MIN_PORT, MAX_PORT, 162, 10162, 1024])('returns true for valid port %i', (port) => {
+ expect(isValidPort(port)).toBe(true)
+ })
+
+ it('returns false for undefined', () => {
+ expect(isValidPort(undefined)).toBe(false)
+ })
+
+ it('returns false for 0 (below MIN_PORT)', () => {
+ expect(isValidPort(0)).toBe(false)
+ })
+
+ it('returns false for MAX_PORT + 1', () => {
+ expect(isValidPort(MAX_PORT + 1)).toBe(false)
+ })
+
+ it('returns false for negative port', () => {
+ expect(isValidPort(-1)).toBe(false)
+ })
+
+ it('returns false for NaN', () => {
+ expect(isValidPort(NaN)).toBe(false)
+ })
+})
+
+describe('isValidIP', () => {
+ it.each(['0.0.0.0', '192.168.1.1', '255.255.255.255', '10.0.0.1'])(
+ 'returns true for valid IPv4 %s',
+ (ip) => {
+ expect(isValidIP(ip)).toBe(true)
+ }
+ )
+
+ it('returns false for too few octets', () => {
+ expect(isValidIP('192.168.1')).toBe(false)
+ })
+
+ it('returns false for too many octets', () => {
+ expect(isValidIP('192.168.1.1.1')).toBe(false)
+ })
+
+ it('returns false for octet > 255', () => {
+ expect(isValidIP('192.168.1.256')).toBe(false)
+ })
+
+ it('returns false for non-numeric octet', () => {
+ expect(isValidIP('abc.def.ghi.jkl')).toBe(false)
+ })
+
+ it('returns false for empty string', () => {
+ expect(isValidIP('')).toBe(false)
+ })
+
+ it('returns false for wildcard *', () => {
+ expect(isValidIP('*')).toBe(false)
+ })
+})
+
+describe('isValidSnmpSecurityLevel', () => {
+ it.each([SecurityLevel.NoAuthNoPriv, SecurityLevel.AuthNoPriv, SecurityLevel.AuthPriv])(
+ 'returns true for valid level %i',
+ (level) => {
+ expect(isValidSnmpSecurityLevel(level)).toBe(true)
+ }
+ )
+
+ it('returns false for SecurityLevel.None (0)', () => {
+ expect(isValidSnmpSecurityLevel(SecurityLevel.None)).toBe(false)
+ })
+
+ it('returns false for level 4 (out of range)', () => {
+ expect(isValidSnmpSecurityLevel(4)).toBe(false)
+ })
+
+ it('returns false for undefined', () => {
+ expect(isValidSnmpSecurityLevel(undefined)).toBe(false)
+ })
+})
+
+describe('getDefaultTrapdConfig', () => {
+ it('returns expected default values', () => {
+ const config = getDefaultTrapdConfig()
+ expect(config.snmpTrapAddress).toBe('*')
+ expect(config.snmpTrapPort).toBe(10162)
+ expect(config.newSuspectOnTrap).toBe(false)
+ expect(config.includeRawMessage).toBe(false)
+ expect(config.threads).toBe(0)
+ expect(config.queueSize).toBe(10000)
+ expect(config.batchSize).toBe(1000)
+ expect(config.batchInterval).toBe(500)
+ expect(config.useAddressFromVarbind).toBe(false)
+ expect(config.snmpv3User).toEqual([])
+ })
+
+ it('returns a fresh object each call (no shared reference)', () => {
+ const a = getDefaultTrapdConfig()
+ const b = getDefaultTrapdConfig()
+ a.snmpv3User.push({ securityName: 'x' } as any)
+ expect(b.snmpv3User).toHaveLength(0)
+ })
+})
+
+describe('SECURITY_LEVEL_OPTIONS', () => {
+ it('contains exactly three entries', () => {
+ expect(SECURITY_LEVEL_OPTIONS).toHaveLength(3)
+ })
+
+ it('has correct _value strings for all three levels', () => {
+ const values = SECURITY_LEVEL_OPTIONS.map((o) => o._value)
+ expect(values).toContain(String(SecurityLevel.NoAuthNoPriv))
+ expect(values).toContain(String(SecurityLevel.AuthNoPriv))
+ expect(values).toContain(String(SecurityLevel.AuthPriv))
+ })
+})
+
+describe('AUTH_PROTOCOL_OPTIONS', () => {
+ it('contains exactly as many entries as AuthProtocols', () => {
+ expect(AUTH_PROTOCOL_OPTIONS).toHaveLength(AuthProtocols.length)
+ })
+
+ it('maps protocol values correctly', () => {
+ const values = AUTH_PROTOCOL_OPTIONS.map((o) => o._value)
+ expect(values).toContain(AuthProtocol.MD5)
+ expect(values).toContain(AuthProtocol.SHA)
+ expect(values).toContain(AuthProtocol.SHA256)
+ expect(values).toContain(AuthProtocol.SHA512)
+ })
+})
+
+describe('PRIVACY_PROTOCOL_OPTIONS', () => {
+ it('contains exactly as many entries as PrivacyProtocols', () => {
+ expect(PRIVACY_PROTOCOL_OPTIONS).toHaveLength(PrivacyProtocols.length)
+ })
+
+ it('maps protocol values correctly', () => {
+ const values = PRIVACY_PROTOCOL_OPTIONS.map((o) => o._value)
+ expect(values).toContain(PrivacyProtocol.DES)
+ expect(values).toContain(PrivacyProtocol.AES)
+ expect(values).toContain(PrivacyProtocol.AES256)
+ })
+})
+
+describe('validateTrapdXml – XML structure', () => {
+ it('returns invalid for empty string', () => {
+ const result = validateTrapdXml('')
+ expect(result.valid).toBe(false)
+ expect(result.errors[0].field).toBe('xml')
+ })
+
+ it('returns invalid for whitespace-only string', () => {
+ const result = validateTrapdXml(' \n ')
+ expect(result.valid).toBe(false)
+ expect(result.errors[0].field).toBe('xml')
+ })
+
+ it('returns invalid for malformed XML', () => {
+ const result = validateTrapdXml(' {
+ const result = validateTrapdXml(``)
+ expect(result.valid).toBe(false)
+ expect(result.errors[0].field).toBe('root')
+ expect(result.errors[0].message).toMatch(/trapd-configuration/)
+ })
+
+ it('returns invalid for wrong xmlns', () => {
+ const result = validateTrapdXml(buildXml({ xmlns: 'http://wrong.namespace' }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field === 'xmlns')).toBe(true)
+ })
+
+ it('returns invalid when xmlns is omitted', () => {
+ const result = validateTrapdXml(buildXml({ xmlns: null }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field === 'xmlns')).toBe(true)
+ })
+
+ it('returns valid for minimal correct XML', () => {
+ const result = validateTrapdXml(buildXml())
+ expect(result.valid).toBe(true)
+ expect(result.errors).toHaveLength(0)
+ })
+})
+
+describe('validateTrapdXml – snmp-trap-address', () => {
+ it('returns error when snmp-trap-address is missing', () => {
+ const result = validateTrapdXml(buildXml({ address: null }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field === 'snmp-trap-address')).toBe(true)
+ })
+
+ it('accepts wildcard "*"', () => {
+ const result = validateTrapdXml(buildXml({ address: '*' }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('accepts a valid IPv4 address', () => {
+ const result = validateTrapdXml(buildXml({ address: '192.168.1.1' }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('returns error for invalid IPv4 address', () => {
+ const result = validateTrapdXml(buildXml({ address: '999.0.0.1' }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field === 'snmp-trap-address')).toBe(true)
+ })
+
+ it('returns error for hostname (not IPv4)', () => {
+ const result = validateTrapdXml(buildXml({ address: 'localhost' }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field === 'snmp-trap-address')).toBe(true)
+ })
+})
+
+describe('validateTrapdXml – snmp-trap-port', () => {
+ it('returns error when snmp-trap-port is missing', () => {
+ const result = validateTrapdXml(buildXml({ port: null }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field === 'snmp-trap-port')).toBe(true)
+ })
+
+ it('accepts MIN_PORT boundary', () => {
+ const result = validateTrapdXml(buildXml({ port: String(MIN_PORT) }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('accepts MAX_PORT boundary', () => {
+ const result = validateTrapdXml(buildXml({ port: String(MAX_PORT) }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('returns error for port 0 (below MIN_PORT)', () => {
+ const result = validateTrapdXml(buildXml({ port: '0' }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field === 'snmp-trap-port')).toBe(true)
+ })
+
+ it('returns error for port 65536 (above MAX_PORT)', () => {
+ const result = validateTrapdXml(buildXml({ port: '65536' }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field === 'snmp-trap-port')).toBe(true)
+ })
+
+ it('returns error for non-numeric port', () => {
+ const result = validateTrapdXml(buildXml({ port: 'abc' }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field === 'snmp-trap-port')).toBe(true)
+ })
+})
+
+describe('validateTrapdXml – new-suspect-on-trap', () => {
+ it('accepts "true"', () => {
+ const result = validateTrapdXml(buildXml({ suspect: 'true' }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('accepts "false"', () => {
+ const result = validateTrapdXml(buildXml({ suspect: 'false' }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('is optional (absent is valid)', () => {
+ const result = validateTrapdXml(buildXml({ suspect: null }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('returns error for invalid value', () => {
+ const result = validateTrapdXml(buildXml({ suspect: 'yes' }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field === 'new-suspect-on-trap')).toBe(true)
+ })
+})
+
+describe('validateTrapdXml – snmpv3-user: security-name and security-level', () => {
+ it('returns error when security-name is missing', () => {
+ const user = buildUser({ 'security-level': '1' })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('security-name'))).toBe(true)
+ })
+
+ it('allows missing security-level (optional)', () => {
+ const user = buildUser({ 'security-name': 'user1' })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.valid).toBe(true)
+ expect(result.errors.some((e) => e.field.includes('security-level'))).toBe(false)
+ })
+
+ it('returns error for security-level 0 (None)', () => {
+ const user = buildUser({ 'security-name': 'user1', 'security-level': '0' })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('security-level'))).toBe(true)
+ })
+
+ it('returns error for security-level 4 (out of range)', () => {
+ const user = buildUser({ 'security-name': 'user1', 'security-level': '4' })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('security-level'))).toBe(true)
+ })
+})
+
+describe('validateTrapdXml – snmpv3-user: level 1 (NoAuthNoPriv)', () => {
+ it('is valid with only security-name and security-level=1', () => {
+ const user = buildUser({ 'security-name': 'user1', 'security-level': '1' })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('returns error when auth-protocol is present at level 1', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '1',
+ 'auth-protocol': 'MD5',
+ 'auth-passphrase': 'pass'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('auth-protocol'))).toBe(true)
+ })
+
+ it('returns error when auth-passphrase is present at level 1', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '1',
+ 'auth-passphrase': 'pass'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('auth-passphrase'))).toBe(true)
+ })
+
+ it('returns error when privacy-protocol is present at level 1', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '1',
+ 'privacy-protocol': 'DES',
+ 'privacy-passphrase': 'priv'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('privacy-protocol'))).toBe(true)
+ })
+
+ it('returns error when privacy-passphrase is present at level 1', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '1',
+ 'privacy-passphrase': 'priv'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('privacy-passphrase'))).toBe(true)
+ })
+})
+
+describe('validateTrapdXml – snmpv3-user: level 2 (AuthNoPriv)', () => {
+ it('is valid with auth-protocol and auth-passphrase at level 2', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '2',
+ 'auth-protocol': 'SHA',
+ 'auth-passphrase': 'secret'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('returns error when auth-protocol is missing at level 2', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '2',
+ 'auth-passphrase': 'secret'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('auth-protocol'))).toBe(true)
+ })
+
+ it('returns error when auth-passphrase is missing at level 2', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '2',
+ 'auth-protocol': 'MD5'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('auth-passphrase'))).toBe(true)
+ })
+
+ it('returns error when privacy-protocol is present at level 2', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '2',
+ 'auth-protocol': 'MD5',
+ 'auth-passphrase': 'secret',
+ 'privacy-protocol': 'DES',
+ 'privacy-passphrase': 'priv'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('privacy-protocol'))).toBe(true)
+ })
+
+ it('returns error when privacy-passphrase is present at level 2', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '2',
+ 'auth-protocol': 'MD5',
+ 'auth-passphrase': 'secret',
+ 'privacy-passphrase': 'priv'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('privacy-passphrase'))).toBe(true)
+ })
+})
+
+describe('validateTrapdXml – snmpv3-user: level 3 (AuthPriv)', () => {
+ const validLevel3 = {
+ 'security-name': 'user1',
+ 'security-level': '3',
+ 'auth-protocol': 'SHA',
+ 'auth-passphrase': 'authsecret',
+ 'privacy-protocol': 'AES',
+ 'privacy-passphrase': 'privsecret'
+ }
+
+ it('is valid with all required fields at level 3', () => {
+ const result = validateTrapdXml(buildXml({ users: buildUser(validLevel3) }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('returns error when auth-protocol is missing at level 3', () => {
+ const { 'auth-protocol': omittedAuthProtocol, ...attrs } = validLevel3
+ void omittedAuthProtocol
+ const result = validateTrapdXml(buildXml({ users: buildUser(attrs) }))
+ expect(result.errors.some((e) => e.field.includes('auth-protocol'))).toBe(true)
+ })
+
+ it('returns error when auth-passphrase is missing at level 3', () => {
+ const { 'auth-passphrase': omittedAuthPassphrase, ...attrs } = validLevel3
+ void omittedAuthPassphrase
+ const result = validateTrapdXml(buildXml({ users: buildUser(attrs) }))
+ expect(result.errors.some((e) => e.field.includes('auth-passphrase'))).toBe(true)
+ })
+
+ it('returns error when privacy-protocol is missing at level 3', () => {
+ const { 'privacy-protocol': omittedPrivacyProtocol, ...attrs } = validLevel3
+ void omittedPrivacyProtocol
+ const result = validateTrapdXml(buildXml({ users: buildUser(attrs) }))
+ expect(result.errors.some((e) => e.field.includes('privacy-protocol'))).toBe(true)
+ })
+
+ it('returns error when privacy-passphrase is missing at level 3', () => {
+ const { 'privacy-passphrase': omittedPrivacyPassphrase, ...attrs } = validLevel3
+ void omittedPrivacyPassphrase
+ const result = validateTrapdXml(buildXml({ users: buildUser(attrs) }))
+ expect(result.errors.some((e) => e.field.includes('privacy-passphrase'))).toBe(true)
+ })
+})
+
+describe('validateTrapdXml – auth-protocol dash normalization', () => {
+ it('accepts "SHA-256" (dash form) as valid auth-protocol', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '2',
+ 'auth-protocol': 'SHA-256',
+ 'auth-passphrase': 'secret'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('auth-protocol'))).toBe(false)
+ })
+
+ it('rejects completely unknown auth-protocol value', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '2',
+ 'auth-protocol': 'UNKNOWN',
+ 'auth-passphrase': 'secret'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('auth-protocol'))).toBe(true)
+ })
+
+ it('rejects unknown privacy-protocol value', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '3',
+ 'auth-protocol': 'MD5',
+ 'auth-passphrase': 'secret',
+ 'privacy-protocol': 'UNKNOWN',
+ 'privacy-passphrase': 'priv'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('privacy-protocol'))).toBe(true)
+ })
+})
+
+describe('validateTrapdXml – privacy-protocol without auth-protocol', () => {
+ it('returns error when privacy-protocol set but auth-protocol absent', () => {
+ const user = buildUser({
+ 'security-name': 'user1',
+ 'security-level': '3',
+ 'privacy-protocol': 'AES',
+ 'privacy-passphrase': 'priv',
+ 'auth-passphrase': 'secret'
+ })
+ const result = validateTrapdXml(buildXml({ users: user }))
+ expect(result.errors.some((e) => e.field.includes('auth-protocol'))).toBe(true)
+ })
+})
+
+describe('validateTrapdXml – multiple snmpv3-user elements', () => {
+ it('is valid with multiple well-formed users', () => {
+ const user1 = buildUser({ 'security-name': 'userA', 'security-level': '1' })
+ const user2 = buildUser({
+ 'security-name': 'userB',
+ 'security-level': '2',
+ 'auth-protocol': 'MD5',
+ 'auth-passphrase': 'pass'
+ })
+ const result = validateTrapdXml(buildXml({ users: user1 + user2 }))
+ expect(result.valid).toBe(true)
+ })
+
+ it('accumulates errors across multiple invalid users', () => {
+ // user[1]: missing security-name; user[2]: invalid security-level
+ const user1 = buildUser({ 'security-level': '1' })
+ const user2 = buildUser({ 'security-name': 'userB', 'security-level': '99' })
+ const result = validateTrapdXml(buildXml({ users: user1 + user2 }))
+ expect(result.valid).toBe(false)
+ expect(result.errors.some((e) => e.field.includes('snmpv3-user[1]'))).toBe(true)
+ expect(result.errors.some((e) => e.field.includes('snmpv3-user[2]'))).toBe(true)
+ })
+})
diff --git a/ui/tests/services/snmpConfigService.test.ts b/ui/tests/services/snmpConfigService.test.ts
index b46d7063fd1d..ab67fce86024 100644
--- a/ui/tests/services/snmpConfigService.test.ts
+++ b/ui/tests/services/snmpConfigService.test.ts
@@ -317,6 +317,7 @@ describe('snmpConfigService', () => {
})
it('should handle exceptions and return failure result', async () => {
+ const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
vi.mocked(v2.post).mockRejectedValue(new Error('Network error'))
const config: SnmpBaseConfiguration = {
@@ -330,6 +331,11 @@ describe('snmpConfigService', () => {
expect(v2.post).toHaveBeenCalledWith('/snmp-config/defaults', config)
expect(result.success).toBe(false)
expect(result.message).toBe('Failed to save SNMP configuration defaults')
+ expect(consoleErrorSpy).toHaveBeenCalledWith(
+ 'Error saving SNMP config defaults:',
+ expect.any(Error)
+ )
+ consoleErrorSpy.mockRestore()
})
it('should work with SNMPv3 configuration', async () => {
diff --git a/ui/tests/stores/trapdConfigStore.test.ts b/ui/tests/stores/trapdConfigStore.test.ts
new file mode 100644
index 000000000000..23068c95257e
--- /dev/null
+++ b/ui/tests/stores/trapdConfigStore.test.ts
@@ -0,0 +1,126 @@
+import { getDefaultTrapdConfig } from '@/lib/trapdValidator'
+import { getTrapdConfiguration } from '@/services/trapdConfigurationService'
+import { useTrapdConfigStore } from '@/stores/trapdConfigStore'
+import { CreateEditMode } from '@/types'
+import type { TrapConfig } from '@/types/trapConfig'
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/services/trapdConfigurationService', () => ({
+ getTrapdConfiguration: vi.fn()
+}))
+
+describe('useTrapdConfigStore', () => {
+ let store: ReturnType
+
+ const trapConfigResponse: TrapConfig = {
+ snmpTrapAddress: '192.168.0.20',
+ snmpTrapPort: 1162,
+ newSuspectOnTrap: true,
+ includeRawMessage: true,
+ threads: 8,
+ queueSize: 12000,
+ batchSize: 1500,
+ batchInterval: 700,
+ useAddressFromVarbind: true,
+ snmpv3User: [
+ {
+ engineId: null,
+ securityName: 'alpha-user',
+ securityLevel: 2,
+ authProtocol: 'SHA256',
+ authPassphrase: 'masked-auth',
+ privacyProtocol: null,
+ privacyPassphrase: null
+ }
+ ]
+ }
+
+ beforeEach(() => {
+ vi.clearAllMocks()
+ setActivePinia(createPinia())
+ store = useTrapdConfigStore()
+ })
+
+ it('has the expected initial state', () => {
+ expect(store.isLoading).toBe(false)
+ expect(store.trapdConfig).toEqual(getDefaultTrapdConfig())
+ expect(store.snmpV3Users).toEqual([])
+ expect(store.activeTab).toBe(0)
+ expect(store.credentialDrawerState).toEqual({
+ visible: false,
+ key: null
+ })
+ expect(store.createUserDrawerState).toEqual({
+ visible: false,
+ mode: CreateEditMode.None,
+ selectedUserIndex: -1
+ })
+ })
+
+ it('fetchTrapConfig updates trapdConfig and snmpV3Users from service response', async () => {
+ vi.mocked(getTrapdConfiguration).mockResolvedValue(trapConfigResponse)
+
+ await store.fetchTrapConfig()
+
+ expect(getTrapdConfiguration).toHaveBeenCalledTimes(1)
+ expect(store.trapdConfig).toEqual(trapConfigResponse)
+ expect(store.snmpV3Users).toEqual(trapConfigResponse.snmpv3User)
+ })
+
+ it('fetchTrapConfig propagates errors and keeps prior state unchanged', async () => {
+ const previousConfig = store.trapdConfig
+ const previousUsers = store.snmpV3Users
+ const error = new Error('fetch failed')
+ vi.mocked(getTrapdConfiguration).mockRejectedValue(error)
+
+ await expect(store.fetchTrapConfig()).rejects.toThrow('fetch failed')
+ expect(store.trapdConfig).toBe(previousConfig)
+ expect(store.snmpV3Users).toBe(previousUsers)
+ })
+
+ it('openCredentialDrawer sets visibility and key', () => {
+ store.openCredentialDrawer('authPassphrase')
+
+ expect(store.credentialDrawerState.visible).toBe(true)
+ expect(store.credentialDrawerState.key).toBe('authPassphrase')
+ })
+
+ it('openCredentialDrawer replaces key when called again', () => {
+ store.openCredentialDrawer('authPassphrase')
+ store.openCredentialDrawer('privacyPassphrase')
+
+ expect(store.credentialDrawerState.visible).toBe(true)
+ expect(store.credentialDrawerState.key).toBe('privacyPassphrase')
+ })
+
+ it('closeCredentialDrawer hides drawer and clears key', () => {
+ store.openCredentialDrawer('authPassphrase')
+
+ store.closeCredentialDrawer()
+
+ expect(store.credentialDrawerState.visible).toBe(false)
+ expect(store.credentialDrawerState.key).toBe(null)
+ })
+
+ it('openCreateUserDrawer sets create drawer state', () => {
+ store.openCreateUserDrawer(CreateEditMode.Edit, 3)
+
+ expect(store.createUserDrawerState.visible).toBe(true)
+ expect(store.createUserDrawerState.mode).toBe(CreateEditMode.Edit)
+ expect(store.createUserDrawerState.selectedUserIndex).toBe(3)
+ })
+
+ it('closeCreateUserDrawer resets create drawer state to defaults', () => {
+ store.openCreateUserDrawer(CreateEditMode.Create, 0)
+
+ store.closeCreateUserDrawer()
+
+ expect(store.createUserDrawerState).toEqual({
+ visible: false,
+ mode: CreateEditMode.None,
+ selectedUserIndex: -1
+ })
+ })
+})
+
|