mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
3187 lines
106 KiB
JavaScript
3187 lines
106 KiB
JavaScript
// Licensed to the Apache Software Foundation (ASF) under one
|
|
// or more contributor license agreements. See the NOTICE file
|
|
// distributed with this work for additional information
|
|
// regarding copyright ownership. The ASF licenses this file
|
|
// to you under the Apache License, Version 2.0 (the
|
|
// "License"); you may not use this file except in compliance
|
|
// with the License. You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing,
|
|
// software distributed under the License is distributed on an
|
|
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
// KIND, either express or implied. See the License for the
|
|
// specific language governing permissions and limitations
|
|
// under the License.
|
|
|
|
import { flushPromises } from '@vue/test-utils'
|
|
import { ref } from 'vue'
|
|
|
|
import mockAxios from '../../mock/mockAxios'
|
|
import AutogenView from '@/views/AutogenView'
|
|
import user from '@/store/modules/user'
|
|
import common from '../../common'
|
|
import mockData from '../../mockData/AutogenView.mock.json'
|
|
|
|
jest.mock('axios', () => mockAxios)
|
|
jest.mock('@/vue-app', () => ({
|
|
vueProps: {
|
|
$localStorage: {
|
|
set: jest.fn((key, value) => {}),
|
|
get: jest.fn((key) => {
|
|
switch (key) {
|
|
case 'HEADER_NOTICES':
|
|
return []
|
|
default:
|
|
return null
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}))
|
|
user.state.apis = mockData.apis
|
|
|
|
let router = null
|
|
let store = null
|
|
let i18n = null
|
|
let mocks = null
|
|
let wrapper = null
|
|
let originalFunc = {}
|
|
|
|
const spyConsole = {
|
|
log: null,
|
|
warn: null
|
|
}
|
|
|
|
const state = {
|
|
user: {
|
|
apis: mockData.apis,
|
|
info: mockData.info,
|
|
defaultListViewPageSize: 20,
|
|
headerNotices: [],
|
|
customColumns: []
|
|
}
|
|
}
|
|
|
|
const mutations = {
|
|
SET_HEADER_NOTICES: (state, jobsJsonArray) => {
|
|
state.user.headerNotices = jobsJsonArray
|
|
},
|
|
SET_CUSTOM_COLUMNS: (state, customColumns) => {
|
|
state.user.customColumns = customColumns
|
|
}
|
|
}
|
|
|
|
const actions = {
|
|
SetProject: jest.fn(({ commit }, project) => {}),
|
|
ToggleTheme: jest.fn(({ commit }, theme) => {}),
|
|
SetCustomColumns: jest.fn(({ commit }, columns) => {})
|
|
}
|
|
|
|
mockData.routes.push({
|
|
name: 'testRouter15',
|
|
path: '/test-router-15',
|
|
meta: {
|
|
title: 'label.title',
|
|
icon: 'play-circle-outlined',
|
|
permission: ['testApiNameCase1'],
|
|
columns: [
|
|
'id',
|
|
'name',
|
|
{
|
|
column1: (record) => {
|
|
return record.name
|
|
}
|
|
}
|
|
]
|
|
},
|
|
component: {},
|
|
children: [{
|
|
name: 'testRouter15-1',
|
|
path: '/test-router-15/:id',
|
|
meta: {
|
|
title: 'label.title',
|
|
icon: 'play-circle-outlined'
|
|
},
|
|
component: {}
|
|
}]
|
|
})
|
|
|
|
router = common.createMockRouter(mockData.routes)
|
|
store = common.createMockStore(state, actions, mutations)
|
|
i18n = common.createMockI18n('en', mockData.messages)
|
|
|
|
mocks = {
|
|
$notifyError: jest.fn((error) => {
|
|
return error
|
|
}),
|
|
$notification: {
|
|
error: jest.fn((option) => {
|
|
return {
|
|
message: option.message,
|
|
description: 'test-description-error',
|
|
duration: option.duration
|
|
}
|
|
}),
|
|
info: jest.fn((option) => {
|
|
return {
|
|
message: option.message,
|
|
description: 'test-description-info',
|
|
duration: option.duration
|
|
}
|
|
}),
|
|
success: jest.fn((option) => {
|
|
return {
|
|
message: option.message,
|
|
description: 'test-description-success',
|
|
duration: option.duration
|
|
}
|
|
}),
|
|
warning: jest.fn((option) => {
|
|
return {
|
|
message: option.message,
|
|
description: 'test-description-warning',
|
|
duration: option.duration
|
|
}
|
|
})
|
|
},
|
|
$message: {
|
|
success: jest.fn((obj) => {
|
|
return obj
|
|
}),
|
|
error: jest.fn((obj) => {
|
|
return obj
|
|
}),
|
|
info: jest.fn((obj) => {
|
|
return obj
|
|
})
|
|
}
|
|
}
|
|
|
|
const factory = (opts = {}) => {
|
|
router = opts.router || router
|
|
i18n = opts.i18n || i18n
|
|
store = opts.store || store
|
|
mocks = opts.mocks || mocks
|
|
|
|
return common.createFactory(AutogenView, {
|
|
router,
|
|
i18n,
|
|
store,
|
|
mocks,
|
|
props: opts.props || {},
|
|
data: opts.data || {}
|
|
})
|
|
}
|
|
|
|
const { ResizeObserver, ls } = window
|
|
router.push('/')
|
|
|
|
describe('Views > AutogenView.vue', () => {
|
|
beforeEach(async () => {
|
|
jest.clearAllMocks()
|
|
jest.spyOn(console, 'warn').mockImplementation(() => {})
|
|
|
|
delete window.ResizeObserver
|
|
delete window.ls
|
|
|
|
if (!wrapper) {
|
|
await router.isReady()
|
|
wrapper = factory()
|
|
}
|
|
|
|
window.ResizeObserver = jest.fn().mockImplementation(() => ({
|
|
observe: jest.fn(),
|
|
unobserve: jest.fn(),
|
|
disconnect: jest.fn()
|
|
}))
|
|
|
|
window.ls = {
|
|
get: jest.fn((key) => []),
|
|
set: jest.fn()
|
|
}
|
|
|
|
state.user.info.roletype = 'Normal'
|
|
if (i18n.global.locale !== 'en') i18n.global.locale = 'en'
|
|
})
|
|
|
|
afterEach(() => {
|
|
window.ResizeObserver = ResizeObserver
|
|
window.ResizeObserver = ls
|
|
|
|
if (wrapper) {
|
|
wrapper.vm.currentAction = {}
|
|
wrapper.vm.resource = {}
|
|
wrapper.vm.searchParams = {}
|
|
wrapper.vm.actionData = {}
|
|
wrapper.vm.dataView = false
|
|
wrapper.vm.showAction = false
|
|
wrapper.vm.selectedRowKeys = []
|
|
wrapper.vm.selectedRowKeys = []
|
|
wrapper.vm.items = []
|
|
wrapper.vm.promises = []
|
|
wrapper.vm.form = {}
|
|
wrapper.vm.rules = {}
|
|
}
|
|
|
|
if (Object.keys(originalFunc).length > 0) {
|
|
Object.keys(originalFunc).forEach(key => {
|
|
switch (key) {
|
|
case 'fetchData':
|
|
wrapper.vm.fetchData = originalFunc[key]
|
|
break
|
|
case 'listUuidOpts':
|
|
wrapper.vm.listUuidOpts = originalFunc[key]
|
|
break
|
|
case 'fillEditFormFieldValues':
|
|
wrapper.vm.fillEditFormFieldValues = originalFunc[key]
|
|
break
|
|
case 'validateTwoPassword':
|
|
wrapper.vm.validateTwoPassword = originalFunc[key]
|
|
break
|
|
case 'handleResponse':
|
|
wrapper.vm.handleResponse = originalFunc[key]
|
|
break
|
|
case 'closeAction':
|
|
wrapper.vm.closeAction = originalFunc[key]
|
|
break
|
|
case 'getFirstIndexFocus':
|
|
wrapper.vm.getFirstIndexFocus = originalFunc[key]
|
|
break
|
|
case 'setRules':
|
|
wrapper.vm.setRules = originalFunc[key]
|
|
break
|
|
case 'RefValidateFields':
|
|
wrapper.vm.formRef.value.validateFields = originalFunc[key]
|
|
break
|
|
case 'formRef':
|
|
wrapper.vm.formRef = originalFunc[key]
|
|
break
|
|
case 'switchProject':
|
|
wrapper.vm.switchProject = originalFunc[key]
|
|
break
|
|
case 'execSubmit':
|
|
wrapper.vm.execSubmit = originalFunc[key]
|
|
break
|
|
case 'shouldNavigateBack':
|
|
wrapper.vm.shouldNavigateBack = originalFunc[key]
|
|
break
|
|
case 'routerGo':
|
|
wrapper.vm.$router.go = originalFunc[key]
|
|
break
|
|
}
|
|
})
|
|
|
|
originalFunc = {}
|
|
}
|
|
if (spyConsole.log) {
|
|
spyConsole.log.mockClear()
|
|
spyConsole.log.mockRestore()
|
|
}
|
|
if (spyConsole.warn) {
|
|
spyConsole.warn.mockClear()
|
|
spyConsole.warn.mockRestore()
|
|
}
|
|
})
|
|
|
|
describe('Navigation Guard', () => {
|
|
it('beforeRouteUpdate() should be called', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
const nextFun = jest.fn()
|
|
const beforeRouteUpdate = wrapper.vm.$options.beforeRouteUpdate
|
|
|
|
await router.push({ name: 'testRouter1' })
|
|
await beforeRouteUpdate.call(wrapper.vm, {}, {}, nextFun)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.currentPath).toEqual('/test-router-1')
|
|
expect(nextFun).toHaveBeenCalled()
|
|
done()
|
|
})
|
|
|
|
it('beforeRouteLeave() should be called', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
const nextFun = jest.fn()
|
|
const beforeRouteLeave = wrapper.vm.$options.beforeRouteLeave
|
|
|
|
await router.push({ name: 'testRouter2' })
|
|
await beforeRouteLeave.call(wrapper.vm, {}, {}, nextFun)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.currentPath).toEqual('/test-router-2')
|
|
expect(nextFun).toHaveBeenCalled()
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('Watchers', () => {
|
|
describe('$route', () => {
|
|
it('The wrapper data does not change when $router do not change', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
|
|
await wrapper.setData({ page: 2, itemCount: 10 })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.page).toEqual(2)
|
|
expect(wrapper.vm.itemCount).toEqual(10)
|
|
expect(fetchData).not.toBeCalled()
|
|
done()
|
|
})
|
|
|
|
it('The wrapper data changes when $router changes', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
|
|
await wrapper.setData({ page: 2, itemCount: 10 })
|
|
await router.push({ name: 'testRouter3' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.page).toEqual(1)
|
|
expect(wrapper.vm.itemCount).toEqual(0)
|
|
expect(fetchData).toBeCalled()
|
|
done()
|
|
})
|
|
|
|
it('switchProject() should be called when $route changes with projectid in query', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
originalFunc.switchProject = wrapper.vm.switchProject
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.switchProject = jest.fn((projectid) => {})
|
|
|
|
const switchProject = jest.spyOn(wrapper.vm, 'switchProject')
|
|
|
|
await router.push({ name: 'testRouter30', query: { projectid: 'test-project-id' } })
|
|
await flushPromises()
|
|
|
|
expect(switchProject).toHaveBeenCalledTimes(1)
|
|
expect(switchProject).toHaveBeenCalledWith('test-project-id')
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('$i18n.locale', () => {
|
|
it('Check language and fetchData() when not changing locale', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
|
|
expect(wrapper.vm.$t('labelname')).toEqual('test-name-en')
|
|
expect(fetchData).not.toBeCalled()
|
|
done()
|
|
})
|
|
|
|
it('Check languages and fetchData() when changing locale', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
|
|
i18n.global.locale = 'de'
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.$t('labelname')).toEqual('test-name-de')
|
|
expect(fetchData).toBeCalled()
|
|
done()
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('Methods', () => {
|
|
describe('switchProject', () => {
|
|
it('API not called when switchProject() is called with not have projectId', async (done) => {
|
|
await wrapper.vm.switchProject()
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).not.toBeCalled()
|
|
done()
|
|
})
|
|
|
|
it('API not called when switchProject() is called with projectId empty', async (done) => {
|
|
await wrapper.vm.switchProject('')
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).not.toBeCalled()
|
|
done()
|
|
})
|
|
|
|
it('API not called when switchProject() is called with projectId length not equal 36', async (done) => {
|
|
await wrapper.vm.switchProject('test-project-id')
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).not.toBeCalled()
|
|
done()
|
|
})
|
|
|
|
it('API will be called when switchProject() is called with projectId satisfying the condition', async (done) => {
|
|
mockAxios.mockResolvedValue({})
|
|
|
|
await router.push({ name: 'testRouter31' })
|
|
await wrapper.vm.switchProject('111111111111111111111111111111111111')
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'listProjects',
|
|
id: '111111111111111111111111111111111111',
|
|
listall: true,
|
|
details: 'min',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check $router not changes when API response with result empty', async (done) => {
|
|
mockAxios.mockResolvedValue({ listprojectsresponse: {} })
|
|
|
|
await router.push({ name: 'testRouter32' })
|
|
await wrapper.vm.switchProject('111111111111111111111111111111111111')
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-32')
|
|
expect(router.currentRoute.value.query).toEqual({})
|
|
done()
|
|
})
|
|
|
|
it('check $router, $store event when API response with result not empty', async (done) => {
|
|
mockAxios.mockResolvedValue({ listprojectsresponse: { project: [{ id: 'project-id' }] } })
|
|
|
|
await router.push({ name: 'testRouter33' })
|
|
await wrapper.vm.switchProject('111111111111111111111111111111111111')
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-33')
|
|
expect(router.currentRoute.value.query).toEqual({})
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('fetchData()', () => {
|
|
it('fetchData() should be return empty when $route.name equal `deployVirtualMachine`', async (done) => {
|
|
await router.push({ name: 'deployVirtualMachine' })
|
|
await wrapper.vm.fetchData()
|
|
|
|
expect(wrapper.vm.items).toEqual([])
|
|
done()
|
|
})
|
|
|
|
it('check routeName when fetchData() is called with $route.name is not empty', async (done) => {
|
|
await router.push({ name: 'testRouter4' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.routeName).toEqual('testRouter4')
|
|
expect(wrapper.vm.items).toEqual([])
|
|
done()
|
|
})
|
|
|
|
it('check routeName when fetchData() is called with $route.name is empty', async (done) => {
|
|
await router.replace('/test-router-5')
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.routeName).toEqual('testRouter5')
|
|
done()
|
|
})
|
|
|
|
it('check resource, dataView when fetchData() is called with $route.meta.params is not empty', async (done) => {
|
|
await router.push({ name: 'testRouter6', params: { id: 'test-id' } })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.resource).toEqual({})
|
|
expect(wrapper.vm.dataView).toBeTruthy()
|
|
done()
|
|
})
|
|
|
|
it('check columnKeys, actions when fetchData() is called with $route.meta.actions, route.meta.columns is not empty', async (done) => {
|
|
await mockAxios.mockResolvedValue({
|
|
testapinamecase1response: {
|
|
count: 0,
|
|
testapinamecase1: []
|
|
}
|
|
})
|
|
await router.push({ name: 'testRouter7' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.columnKeys.length).toEqual(3)
|
|
expect(wrapper.vm.actions.length).toEqual(1)
|
|
expect(wrapper.vm.columnKeys).toEqual(['column1', 'column2', 'column3'])
|
|
expect(wrapper.vm.actions).toEqual([{
|
|
label: 'labelname',
|
|
api: 'testApiNameCase1',
|
|
icon: 'plus-outlined',
|
|
listView: true
|
|
}])
|
|
done()
|
|
})
|
|
|
|
it('check columnKeys assign by store.getters.apis when fetchData() is called', async (done) => {
|
|
await mockAxios.mockResolvedValue({
|
|
testapinamecase4response: {
|
|
count: 0,
|
|
testapinamecase4: []
|
|
}
|
|
})
|
|
await router.push({ name: 'testRouter8' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.columnKeys.length).toEqual(3)
|
|
expect(wrapper.vm.columnKeys).toEqual(['column1', 'column2', 'column3'])
|
|
done()
|
|
})
|
|
|
|
it('check columnKeys assign by $route.meta.columns when fetchData() is called', async (done) => {
|
|
await mockAxios.mockResolvedValue({
|
|
testapinamecase1response: {
|
|
count: 0,
|
|
testapinamecase1: []
|
|
}
|
|
})
|
|
await router.push({ name: 'testRouter9' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.columns.length).toEqual(2)
|
|
expect(wrapper.vm.columns[0].key).toEqual('name')
|
|
expect(wrapper.vm.columns[0].title).toEqual('name-en')
|
|
expect(wrapper.vm.columns[0].dataIndex).toEqual('name')
|
|
expect(typeof wrapper.vm.columns[0].sorter).toBe('function')
|
|
expect(wrapper.vm.columns[1].key).toEqual('filtercolumn')
|
|
expect(wrapper.vm.columns[1].dataIndex).toEqual('filtercolumn')
|
|
expect(wrapper.vm.columns[1].customFilterDropdown).toBeTruthy()
|
|
done(0)
|
|
})
|
|
|
|
it('API should be called with params assign by $route.query', async (done) => {
|
|
await mockAxios.mockResolvedValue({
|
|
testapinamecase2response: {
|
|
count: 0,
|
|
testapinamecase2: []
|
|
}
|
|
})
|
|
await router.push({ name: 'testRouter10', query: { key: 'test-value' } })
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
data: new URLSearchParams(),
|
|
method: 'GET',
|
|
params: {
|
|
command: 'testApiNameCase2',
|
|
listall: true,
|
|
key: 'test-value',
|
|
page: 1,
|
|
pagesize: 20,
|
|
response: 'json'
|
|
},
|
|
url: '/'
|
|
})
|
|
|
|
done()
|
|
})
|
|
|
|
it('API should be called with params assign by $route.meta.params', async (done) => {
|
|
await mockAxios.mockResolvedValue({
|
|
testapinamecase3response: {
|
|
count: 0,
|
|
testapinamecase3: []
|
|
}
|
|
})
|
|
await router.push({ name: 'testRouter11' })
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
data: new URLSearchParams(),
|
|
method: 'GET',
|
|
params: {
|
|
command: 'testApiNameCase3',
|
|
listall: true,
|
|
key: 'test-value',
|
|
page: 1,
|
|
pagesize: 20,
|
|
response: 'json'
|
|
},
|
|
url: '/'
|
|
})
|
|
done()
|
|
})
|
|
|
|
// it('API should be called with params has item id, name when $route.path startWith /ssh/', async (done) => {
|
|
// await mockAxios.mockResolvedValue({
|
|
// testapinamecase1response: {
|
|
// count: 0,
|
|
// testapinamecase1: [{
|
|
// id: 'test-id-1',
|
|
// name: 'test-name-1'
|
|
// }]
|
|
// }
|
|
// })
|
|
// await router.push({ name: 'testRouter12', params: { id: 'test-id' } })
|
|
// await flushPromises()
|
|
|
|
// expect(mockAxios).toHaveBeenCalled()
|
|
// expect(mockAxios).toHaveBeenLastCalledWith({
|
|
// url: '/',
|
|
// method: 'GET',
|
|
// data: new URLSearchParams(),
|
|
// params: {
|
|
// command: 'testApiNameCase1',
|
|
// listall: true,
|
|
// id: 'test-id',
|
|
// name: 'test-id',
|
|
// page: 1,
|
|
// pagesize: 20,
|
|
// response: 'json'
|
|
// }
|
|
// })
|
|
// done()
|
|
// })
|
|
|
|
it('API should be called with params has item id, hostname when $route.path startWith /ldapsetting/', async (done) => {
|
|
await mockAxios.mockResolvedValue({
|
|
testapinamecase1response: {
|
|
count: 0,
|
|
testapinamecase1: [{
|
|
id: 'test-id-1',
|
|
name: 'test-name-1'
|
|
}]
|
|
}
|
|
})
|
|
await router.push({ name: 'testRouter13', params: { id: 'test-id' } })
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
listall: true,
|
|
id: 'test-id',
|
|
hostname: 'test-id',
|
|
page: 1,
|
|
pagesize: 20,
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check items, resource when api is called with result is not empty', async (done) => {
|
|
await mockAxios.mockResolvedValue({
|
|
listtemplatesresponse: {
|
|
count: 2,
|
|
templates: [{
|
|
id: 'uuid1',
|
|
templateid: 'templateid-1',
|
|
name: 'template-test-1'
|
|
}, {
|
|
id: 'uuid2',
|
|
templateid: 'templateid-2',
|
|
name: 'template-test-2'
|
|
}]
|
|
}
|
|
})
|
|
await router.push({ name: 'testRouter14' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.items.length).toEqual(2)
|
|
expect(wrapper.vm.items).toEqual([
|
|
{
|
|
id: 'uuid1',
|
|
templateid: 'templateid-1',
|
|
name: 'template-test-1',
|
|
key: 0
|
|
},
|
|
{
|
|
id: 'uuid2',
|
|
templateid: 'templateid-2',
|
|
name: 'template-test-2',
|
|
key: 1
|
|
}
|
|
])
|
|
expect(wrapper.vm.resource).toEqual({
|
|
id: 'uuid1',
|
|
templateid: 'templateid-1',
|
|
name: 'template-test-1',
|
|
key: 0
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check items, resource when api is called and $route.meta.columns has function', async (done) => {
|
|
await mockAxios.mockResolvedValue({
|
|
testapinamecase1response: {
|
|
count: 1,
|
|
testapinamecase1: [{
|
|
id: 'test-id',
|
|
name: 'test-name-value'
|
|
}]
|
|
}
|
|
})
|
|
await router.push({ name: 'testRouter15' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.items).toEqual([{
|
|
id: 'test-id',
|
|
name: 'test-name-value',
|
|
key: 0,
|
|
column1: 'test-name-value'
|
|
}])
|
|
expect(wrapper.vm.resource).toEqual({
|
|
id: 'test-id',
|
|
name: 'test-name-value',
|
|
key: 0,
|
|
column1: 'test-name-value'
|
|
})
|
|
done()
|
|
})
|
|
|
|
// it('check items, resource when api is called and $route.path startWith /ssh', async (done) => {
|
|
// await mockAxios.mockResolvedValue({
|
|
// testapinamecase1response: {
|
|
// count: 1,
|
|
// testapinamecase1: [{
|
|
// name: 'test-name-value'
|
|
// }]
|
|
// }
|
|
// })
|
|
// await router.push({ name: 'testRouter16' })
|
|
// await flushPromises()
|
|
//
|
|
// expect(wrapper.vm.items).toEqual([{
|
|
// id: 'test-name-value',
|
|
// name: 'test-name-value',
|
|
// key: 0
|
|
// }])
|
|
// expect(wrapper.vm.resource).toEqual({
|
|
// id: 'test-name-value',
|
|
// name: 'test-name-value',
|
|
// key: 0
|
|
// })
|
|
// done()
|
|
// })
|
|
|
|
it('check items, resource when api is called and $route.path startWith /ldapsetting', async (done) => {
|
|
await mockAxios.mockResolvedValue({
|
|
testapinamecase1response: {
|
|
count: 1,
|
|
testapinamecase1: [{
|
|
name: 'test-name-value',
|
|
hostname: 'test-hostname-value'
|
|
}]
|
|
}
|
|
})
|
|
await router.push({ name: 'testRouter17' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.items).toEqual([{
|
|
id: 'test-hostname-value',
|
|
name: 'test-name-value',
|
|
hostname: 'test-hostname-value',
|
|
key: 0
|
|
}])
|
|
expect(wrapper.vm.resource).toEqual({
|
|
id: 'test-hostname-value',
|
|
name: 'test-name-value',
|
|
hostname: 'test-hostname-value',
|
|
key: 0
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check $notifyError is called when api is called with throw error', async (done) => {
|
|
const errorMock = {
|
|
response: {},
|
|
message: 'Error: throw exception error'
|
|
}
|
|
|
|
await mockAxios.mockRejectedValue(errorMock)
|
|
await router.push({ name: 'testRouter18' })
|
|
await flushPromises()
|
|
|
|
expect(mocks.$notifyError).toHaveBeenCalledTimes(1)
|
|
expect(mocks.$notifyError).toHaveBeenCalledWith(errorMock)
|
|
done()
|
|
})
|
|
|
|
it('check $notifyError is called and router path = /exception/403 when api is called with throw error', async (done) => {
|
|
const errorMock = {
|
|
response: {
|
|
status: 405
|
|
},
|
|
message: 'Error: Method Not Allowed'
|
|
}
|
|
|
|
await mockAxios.mockRejectedValue(errorMock)
|
|
await router.push({ name: 'testRouter19' })
|
|
await flushPromises()
|
|
|
|
expect(mocks.$notifyError).toHaveBeenCalledTimes(1)
|
|
expect(mocks.$notifyError).toHaveBeenCalledWith(errorMock)
|
|
expect(router.currentRoute.value.path).toEqual('/exception/403')
|
|
done()
|
|
})
|
|
|
|
it('check $notifyError is called and router path = /exception/404 when api is called with throw error', async (done) => {
|
|
const errorMock = {
|
|
response: {
|
|
status: 430
|
|
},
|
|
message: 'Error: Request Header Fields Too Large'
|
|
}
|
|
|
|
await mockAxios.mockRejectedValue(errorMock)
|
|
await router.push({ name: 'testRouter19' })
|
|
await flushPromises()
|
|
|
|
expect(mocks.$notifyError).toHaveBeenCalledTimes(1)
|
|
expect(mocks.$notifyError).toHaveBeenCalledWith(errorMock)
|
|
expect(router.currentRoute.value.path).toEqual('/exception/404')
|
|
done()
|
|
})
|
|
|
|
it('check $notifyError is called and router path = /exception/500 when api is called with throw error', async (done) => {
|
|
const errorMock = {
|
|
response: {
|
|
status: 530
|
|
},
|
|
message: 'Error: Site is frozen'
|
|
}
|
|
|
|
await mockAxios.mockRejectedValue(errorMock)
|
|
await router.push({ name: 'testRouter19' })
|
|
await flushPromises()
|
|
|
|
expect(mocks.$notifyError).toHaveBeenCalledTimes(1)
|
|
expect(mocks.$notifyError).toHaveBeenCalledWith(errorMock)
|
|
expect(router.currentRoute.value.path).toEqual('/exception/500')
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('onSearch()', () => {
|
|
it('check router when onSearch() is called with args empty', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'testRouter20', query: { page: 1, pagesize: 20 } })
|
|
await wrapper.vm.onSearch()
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-20')
|
|
expect(router.currentRoute.value.query).toEqual({ page: '1', pagesize: '20' })
|
|
done()
|
|
})
|
|
|
|
it('check router when onSearch() is called with args not empty', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'testRouter21', query: { page: 1, pagesize: 20 } })
|
|
await wrapper.vm.onSearch({ value: 'test-value' })
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-21')
|
|
expect(router.currentRoute.value.query).toEqual({ page: '1', pagesize: '20', value: 'test-value' })
|
|
done()
|
|
})
|
|
|
|
it('check router when onSearch() is called with args have searchQuery', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'testRouter22', query: { page: 1, pagesize: 20 } })
|
|
await wrapper.vm.onSearch({ searchQuery: 'test-value' })
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-22')
|
|
expect(router.currentRoute.value.query).toEqual({
|
|
page: '1',
|
|
pagesize: '20',
|
|
keyword: 'test-value',
|
|
q: 'test-value'
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check router when onSearch() is called with args have searchQuery and route.name equal `role`', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'role' })
|
|
await wrapper.vm.onSearch({ searchQuery: 'test-value' })
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/role')
|
|
expect(router.currentRoute.value.query).toEqual({ keyword: 'test-value', q: 'test-value', page: '1', pagesize: '20' })
|
|
done()
|
|
})
|
|
|
|
it('check router when onSearch() is called with args have searchQuery and route.name equal `quotaemailtemplate`', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'quotaemailtemplate' })
|
|
await wrapper.vm.onSearch({ searchQuery: 'test-value' })
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/quotaemailtemplate')
|
|
expect(router.currentRoute.value.query).toEqual({ templatetype: 'test-value', q: 'test-value', page: '1', pagesize: '20' })
|
|
done()
|
|
})
|
|
|
|
it('check router when onSearch() is called with args have searchQuery and route.name equal `quotaemailtemplate`', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'globalsetting' })
|
|
await wrapper.vm.onSearch({ searchQuery: 'test-value' })
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/globalsetting')
|
|
expect(router.currentRoute.value.query).toEqual({ name: 'test-value', q: 'test-value', page: '1', pagesize: '20' })
|
|
done()
|
|
})
|
|
|
|
it('fetchData() should be called when onSearch() is called', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
await router.push({ name: 'testRouter23', query: { page: 1, pagesize: 20, value: 'test-value' } })
|
|
await wrapper.vm.onSearch({ page: '1', pagesize: '20', value: 'test-value' })
|
|
await flushPromises()
|
|
|
|
expect(fetchData).toHaveBeenLastCalledWith({ page: '1', pagesize: '20', value: 'test-value' })
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('closeAction()', () => {
|
|
it('check currentAction, showAction when closeAction() is called', async (done) => {
|
|
await wrapper.setData({
|
|
currentAction: {
|
|
label: 'label.name',
|
|
loading: true,
|
|
paramFields: []
|
|
},
|
|
showAction: true
|
|
})
|
|
await wrapper.vm.closeAction()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.currentAction).toEqual({})
|
|
expect(wrapper.vm.showAction).toBeFalsy()
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('execAction()', () => {
|
|
it('check showAction, actionData and router name when execAction() is called', async (done) => {
|
|
originalFunc.getFirstIndexFocus = wrapper.vm.getFirstIndexFocus
|
|
originalFunc.setRules = wrapper.vm.setRules
|
|
originalFunc.listUuidOpts = wrapper.vm.listUuidOpts
|
|
originalFunc.fillEditFormFieldValues = wrapper.vm.fillEditFormFieldValues
|
|
|
|
wrapper.vm.getFirstIndexFocus = jest.fn()
|
|
wrapper.vm.setRules = jest.fn((param) => {})
|
|
wrapper.vm.listUuidOpts = jest.fn((param) => {})
|
|
wrapper.vm.fillEditFormFieldValues = jest.fn()
|
|
|
|
await wrapper.setData({ actionData: { name: 'test-add-action' } })
|
|
await wrapper.vm.execAction({
|
|
label: 'labelname',
|
|
icon: 'plus-outlined',
|
|
component: {},
|
|
api: 'testRouter24',
|
|
popup: false
|
|
})
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.showAction).toBeFalsy()
|
|
expect(router.currentRoute.value.name).toEqual('testRouter24')
|
|
done()
|
|
})
|
|
|
|
it('check currentAction params and paramsField when execAction() is called', async (done) => {
|
|
originalFunc.getFirstIndexFocus = wrapper.vm.getFirstIndexFocus
|
|
originalFunc.setRules = wrapper.vm.setRules
|
|
originalFunc.listUuidOpts = wrapper.vm.listUuidOpts
|
|
originalFunc.fillEditFormFieldValues = wrapper.vm.fillEditFormFieldValues
|
|
|
|
wrapper.vm.getFirstIndexFocus = jest.fn()
|
|
wrapper.vm.setRules = jest.fn((param) => {})
|
|
wrapper.vm.listUuidOpts = jest.fn((param) => {})
|
|
wrapper.vm.fillEditFormFieldValues = jest.fn()
|
|
|
|
await wrapper.vm.execAction({
|
|
label: 'label.name',
|
|
api: 'testApiNameCase5',
|
|
paramFields: []
|
|
})
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.currentAction.params).toEqual([
|
|
{ name: 'id', type: 'string' },
|
|
{ name: 'name', type: 'string' },
|
|
{ name: 'column1', type: 'string' },
|
|
{ name: 'column2', type: 'string' },
|
|
{ name: 'column3', type: 'string' }
|
|
])
|
|
expect(wrapper.vm.currentAction.paramFields).toEqual([])
|
|
expect(wrapper.vm.showAction).toBeTruthy()
|
|
done()
|
|
})
|
|
|
|
it('check currentAction params and paramsField when execAction() is called with args is exists', async (done) => {
|
|
originalFunc.getFirstIndexFocus = wrapper.vm.getFirstIndexFocus
|
|
originalFunc.setRules = wrapper.vm.setRules
|
|
originalFunc.listUuidOpts = wrapper.vm.listUuidOpts
|
|
originalFunc.fillEditFormFieldValues = wrapper.vm.fillEditFormFieldValues
|
|
|
|
wrapper.vm.getFirstIndexFocus = jest.fn()
|
|
wrapper.vm.setRules = jest.fn((param) => {})
|
|
wrapper.vm.listUuidOpts = jest.fn((param) => {})
|
|
wrapper.vm.fillEditFormFieldValues = jest.fn()
|
|
|
|
await wrapper.vm.execAction({
|
|
api: 'testApiNameCase5',
|
|
args: ['column1', 'column2', 'column3']
|
|
})
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.currentAction.params).toEqual([
|
|
{ name: 'column1', type: 'string' },
|
|
{ name: 'column2', type: 'string' },
|
|
{ name: 'column3', type: 'string' },
|
|
{ name: 'name', type: 'string' },
|
|
{ name: 'id', type: 'string' }
|
|
])
|
|
expect(wrapper.vm.currentAction.paramFields).toEqual([
|
|
{ name: 'column1', type: 'string' },
|
|
{ name: 'column2', type: 'string' },
|
|
{ name: 'column3', type: 'string' }
|
|
])
|
|
expect(wrapper.vm.showAction).toBeTruthy()
|
|
done()
|
|
})
|
|
|
|
it('check currentAction params and paramsField when execAction() is called with args is function', async (done) => {
|
|
originalFunc.getFirstIndexFocus = wrapper.vm.getFirstIndexFocus
|
|
originalFunc.setRules = wrapper.vm.setRules
|
|
originalFunc.listUuidOpts = wrapper.vm.listUuidOpts
|
|
originalFunc.fillEditFormFieldValues = wrapper.vm.fillEditFormFieldValues
|
|
|
|
wrapper.vm.getFirstIndexFocus = jest.fn()
|
|
wrapper.vm.setRules = jest.fn((param) => {})
|
|
wrapper.vm.listUuidOpts = jest.fn((param) => {})
|
|
wrapper.vm.fillEditFormFieldValues = jest.fn()
|
|
|
|
await wrapper.vm.execAction({
|
|
api: 'testApiNameCase5',
|
|
resource: { id: 'test-id-value', name: 'test-name-value' },
|
|
args: (record, store) => {
|
|
return ['Admin'].includes(store.userInfo.roletype) ? ['column1', 'column2', 'column3'] : ['id', 'name']
|
|
}
|
|
})
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.currentAction.params).toEqual([
|
|
{ name: 'id', type: 'string' },
|
|
{ name: 'name', type: 'string' },
|
|
{ name: 'column1', type: 'string' },
|
|
{ name: 'column2', type: 'string' },
|
|
{ name: 'column3', type: 'string' }
|
|
])
|
|
expect(wrapper.vm.currentAction.paramFields).toEqual([
|
|
{ name: 'id', type: 'string' },
|
|
{ name: 'name', type: 'string' }
|
|
])
|
|
expect(wrapper.vm.showAction).toBeTruthy()
|
|
done()
|
|
})
|
|
|
|
it('check currentAction paramsField and listUuidOpts() is called when execAction() is called', async (done) => {
|
|
originalFunc.getFirstIndexFocus = wrapper.vm.getFirstIndexFocus
|
|
originalFunc.setRules = wrapper.vm.setRules
|
|
originalFunc.listUuidOpts = wrapper.vm.listUuidOpts
|
|
originalFunc.fillEditFormFieldValues = wrapper.vm.fillEditFormFieldValues
|
|
|
|
wrapper.vm.getFirstIndexFocus = jest.fn()
|
|
wrapper.vm.setRules = jest.fn((param) => {})
|
|
wrapper.vm.listUuidOpts = jest.fn((param) => {})
|
|
wrapper.vm.fillEditFormFieldValues = jest.fn()
|
|
|
|
const listUuidOpts = jest.spyOn(wrapper.vm, 'listUuidOpts')
|
|
await wrapper.vm.execAction({
|
|
api: 'testApiNameCase6',
|
|
args: ['id', 'tags', 'column1', 'column2', 'account'],
|
|
mapping: {
|
|
column2: () => {
|
|
return 'test-value'
|
|
}
|
|
}
|
|
})
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.currentAction.paramFields).toEqual([
|
|
{ name: 'id', type: 'uuid' },
|
|
{ name: 'tags', type: 'string' },
|
|
{ name: 'column1', type: 'list' },
|
|
{ name: 'column2', type: 'string' },
|
|
{ name: 'account', type: 'string' }
|
|
])
|
|
expect(wrapper.vm.showAction).toBeTruthy()
|
|
expect(listUuidOpts).toHaveBeenCalledTimes(4)
|
|
expect(listUuidOpts).toHaveBeenCalledWith({ name: 'id', type: 'uuid' }, undefined)
|
|
expect(listUuidOpts).toHaveBeenCalledWith({ name: 'column1', type: 'list' }, undefined)
|
|
expect(listUuidOpts).toHaveBeenCalledWith({ name: 'column2', type: 'string' }, undefined)
|
|
done()
|
|
})
|
|
|
|
it('check fillEditFormFieldValues() is called when execAction() is called', async (done) => {
|
|
originalFunc.getFirstIndexFocus = wrapper.vm.getFirstIndexFocus
|
|
originalFunc.setRules = wrapper.vm.setRules
|
|
originalFunc.listUuidOpts = wrapper.vm.listUuidOpts
|
|
originalFunc.fillEditFormFieldValues = wrapper.vm.fillEditFormFieldValues
|
|
|
|
wrapper.vm.getFirstIndexFocus = jest.fn()
|
|
wrapper.vm.setRules = jest.fn((param) => {})
|
|
wrapper.vm.listUuidOpts = jest.fn((param) => {})
|
|
wrapper.vm.fillEditFormFieldValues = jest.fn()
|
|
|
|
const fillEditFormFieldValues = jest.spyOn(wrapper.vm, 'fillEditFormFieldValues')
|
|
|
|
await wrapper.vm.execAction({
|
|
api: 'testApiNameCase6',
|
|
dataView: true,
|
|
icon: 'edit-outlined'
|
|
})
|
|
await flushPromises()
|
|
|
|
expect(fillEditFormFieldValues).toHaveBeenCalled()
|
|
done()
|
|
})
|
|
|
|
it('check currentAction paramFields when execAction() is called args has confirmpassword field', async (done) => {
|
|
originalFunc.getFirstIndexFocus = wrapper.vm.getFirstIndexFocus
|
|
originalFunc.setRules = wrapper.vm.setRules
|
|
originalFunc.listUuidOpts = wrapper.vm.listUuidOpts
|
|
originalFunc.fillEditFormFieldValues = wrapper.vm.fillEditFormFieldValues
|
|
|
|
wrapper.vm.getFirstIndexFocus = jest.fn()
|
|
wrapper.vm.setRules = jest.fn((param) => {})
|
|
wrapper.vm.listUuidOpts = jest.fn((param) => {})
|
|
wrapper.vm.fillEditFormFieldValues = jest.fn()
|
|
|
|
await wrapper.vm.execAction({
|
|
api: 'testApiNameCase6',
|
|
args: ['confirmpassword'],
|
|
mapping: {}
|
|
})
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.currentAction.paramFields).toEqual([
|
|
{ name: 'confirmpassword', type: 'password', required: true, description: 'confirmpassword-description-en' }
|
|
])
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('listUuidOpts()', () => {
|
|
it('API not called when listUuidOpts() is called with currentAction.mapping.id is null', async (done) => {
|
|
await wrapper.setData({
|
|
currentAction: {
|
|
mapping: {
|
|
id: () => { return '' }
|
|
}
|
|
}
|
|
})
|
|
await wrapper.vm.listUuidOpts({ name: 'id', type: 'uuid' })
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).not.toHaveBeenCalled()
|
|
done()
|
|
})
|
|
|
|
it('API not called when listUuidOpts() is called with currentAction.mapping is empty', async (done) => {
|
|
await wrapper.setData({
|
|
currentAction: {
|
|
mapping: {}
|
|
}
|
|
})
|
|
await wrapper.vm.listUuidOpts({ name: 'test-name', type: 'uuid' })
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).not.toHaveBeenCalled()
|
|
done()
|
|
})
|
|
|
|
it('API should be called and param.opts when listUuidOpts() is called with currentAction.mapping[param.name].api', async (done) => {
|
|
const param = { name: 'template', type: 'uuid' }
|
|
|
|
await mockAxios.mockResolvedValue({
|
|
testapinamecase1response: {
|
|
count: 1,
|
|
testapinamecase1: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
}
|
|
})
|
|
await wrapper.setData({
|
|
currentAction: {
|
|
mapping: {
|
|
template: {
|
|
api: 'testApiNameCase1'
|
|
}
|
|
}
|
|
}
|
|
})
|
|
await wrapper.vm.listUuidOpts(param)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
listall: true,
|
|
showicon: true,
|
|
response: 'json'
|
|
}
|
|
})
|
|
expect(param).toEqual({
|
|
name: 'template',
|
|
type: 'uuid',
|
|
loading: false,
|
|
opts: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when listUuidOpts() is called with store apis has api startWith param.name', async (done) => {
|
|
const param = { name: 'testapiname', type: 'uuid' }
|
|
|
|
await mockAxios.mockResolvedValue({
|
|
listtestapinamesresponse: {
|
|
count: 1,
|
|
testapiname: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
}
|
|
})
|
|
await wrapper.vm.listUuidOpts(param)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'listTestApiNames',
|
|
listall: true,
|
|
response: 'json'
|
|
}
|
|
})
|
|
expect(param).toEqual({
|
|
name: 'testapiname',
|
|
type: 'uuid',
|
|
loading: false,
|
|
opts: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called with params has item name and value assign by resource', async (done) => {
|
|
const param = { name: 'template', type: 'uuid' }
|
|
|
|
await mockAxios.mockResolvedValue({
|
|
testapinamecase1response: {
|
|
count: 0,
|
|
testapinamecase1: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
}
|
|
})
|
|
await wrapper.setData({
|
|
currentAction: {
|
|
mapping: {
|
|
template: {
|
|
api: 'testApiNameCase1',
|
|
params: (record) => {
|
|
return {
|
|
name: record.name
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
resource: {
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}
|
|
})
|
|
await wrapper.vm.listUuidOpts(param)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
listall: true,
|
|
name: 'test-name-value',
|
|
showicon: true,
|
|
response: 'json'
|
|
}
|
|
})
|
|
expect(param).toEqual({
|
|
name: 'template',
|
|
type: 'uuid',
|
|
loading: false,
|
|
opts: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called with params has item templatefilter when apiName is listTemplates', async (done) => {
|
|
const param = { name: 'id', type: 'uuid' }
|
|
|
|
await mockAxios.mockResolvedValue({
|
|
listtemplateresponse: {
|
|
count: 1,
|
|
templates: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
}
|
|
})
|
|
await wrapper.setData({
|
|
apiName: 'listTemplates'
|
|
})
|
|
await wrapper.vm.listUuidOpts(param)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'listTemplates',
|
|
listall: true,
|
|
templatefilter: 'executable',
|
|
response: 'json'
|
|
}
|
|
})
|
|
expect(param).toEqual({
|
|
name: 'id',
|
|
type: 'uuid',
|
|
loading: false,
|
|
opts: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called with params has item isofilter when apiName is listIsos', async (done) => {
|
|
const param = { name: 'id', type: 'uuid' }
|
|
|
|
await mockAxios.mockResolvedValue({
|
|
listisosresponse: {
|
|
count: 1,
|
|
iso: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
}
|
|
})
|
|
await wrapper.setData({ apiName: 'listIsos' })
|
|
await wrapper.vm.listUuidOpts(param)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'listIsos',
|
|
listall: true,
|
|
isofilter: 'executable',
|
|
response: 'json'
|
|
}
|
|
})
|
|
expect(param).toEqual({
|
|
name: 'id',
|
|
type: 'uuid',
|
|
loading: false,
|
|
opts: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called with params has item type = routing when apiName is listHosts', async (done) => {
|
|
const param = { name: 'id', type: 'uuid' }
|
|
|
|
await mockAxios.mockResolvedValue({
|
|
listhostresponse: {
|
|
count: 1,
|
|
hosts: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
}
|
|
})
|
|
await wrapper.setData({ apiName: 'listHosts' })
|
|
await wrapper.vm.listUuidOpts(param)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'listHosts',
|
|
listall: true,
|
|
type: 'routing',
|
|
response: 'json'
|
|
}
|
|
})
|
|
expect(param).toEqual({
|
|
name: 'id',
|
|
type: 'uuid',
|
|
loading: false,
|
|
opts: [{
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called and param.opts is empty when api throw error', async (done) => {
|
|
const param = { name: 'id', type: 'uuid', loading: true }
|
|
spyConsole.log = jest.spyOn(console, 'log').mockImplementation(() => {})
|
|
|
|
await mockAxios.mockRejectedValue({
|
|
response: {},
|
|
stack: 'Error: throw exception error'
|
|
})
|
|
await wrapper.setData({ apiName: 'testApiNameCase1' })
|
|
await wrapper.vm.listUuidOpts(param)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
listall: true,
|
|
response: 'json'
|
|
}
|
|
})
|
|
expect(param).toEqual({
|
|
name: 'id',
|
|
type: 'uuid',
|
|
loading: false,
|
|
opts: []
|
|
})
|
|
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('pollActionCompletion()', () => {
|
|
it('check $notification when pollActionCompletion() is called with action is empty', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
|
|
await mockAxios.mockResolvedValue({
|
|
queryasyncjobresultresponse: {
|
|
jobstatus: 1,
|
|
jobresult: {
|
|
name: 'test-name-value'
|
|
}
|
|
}
|
|
})
|
|
await wrapper.vm.pollActionCompletion('test-job-id', { label: 'label.name' })
|
|
await flushPromises()
|
|
|
|
expect(fetchData).toHaveBeenCalled()
|
|
expect(mocks.$notification.info).not.toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'queryAsyncJobResult',
|
|
jobId: 'test-job-id',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check $notification when pollActionCompletion() is called with action is not empty', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
|
|
await mockAxios.mockResolvedValue({
|
|
queryasyncjobresultresponse: {
|
|
jobstatus: 1,
|
|
jobresult: {
|
|
name: 'test-name-value'
|
|
}
|
|
}
|
|
})
|
|
await wrapper.vm.pollActionCompletion('test-job-id', {
|
|
label: 'labelname',
|
|
response: (jobResult) => {
|
|
return jobResult.name
|
|
}
|
|
})
|
|
await flushPromises()
|
|
|
|
expect(fetchData).toHaveBeenCalled()
|
|
expect(mocks.$notification.info).toHaveBeenCalled()
|
|
expect(mocks.$notification.info).toHaveLastReturnedWith({
|
|
message: 'test-name-en',
|
|
description: 'test-description-info',
|
|
duration: 0
|
|
})
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'queryAsyncJobResult',
|
|
jobId: 'test-job-id',
|
|
response: 'json'
|
|
}
|
|
})
|
|
|
|
done()
|
|
})
|
|
|
|
it('fetchData() should be called when $pollJob error response', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
|
|
await mockAxios.mockResolvedValue({
|
|
queryasyncjobresultresponse: {
|
|
jobstatus: 2,
|
|
jobresult: {
|
|
errortext: 'test-error-message'
|
|
}
|
|
}
|
|
})
|
|
await wrapper.vm.pollActionCompletion('test-job-id', {
|
|
label: 'labelname',
|
|
response: (jobResult) => {
|
|
return jobResult.name
|
|
}
|
|
})
|
|
await flushPromises()
|
|
|
|
expect(fetchData).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'queryAsyncJobResult',
|
|
jobId: 'test-job-id',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('fillEditFormFieldValues()', () => {
|
|
it('form data should be empty when currentAction.paramFields empty', async (done) => {
|
|
await wrapper.setData({ currentAction: { paramFields: [] } })
|
|
await wrapper.vm.fillEditFormFieldValues()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.form).toEqual({})
|
|
done()
|
|
})
|
|
|
|
it('form data should not empty when currentAction.paramFields has item type equal `list`', async (done) => {
|
|
await wrapper.setData({
|
|
currentAction: {
|
|
paramFields: [
|
|
{ name: 'domainids', type: 'list' }
|
|
]
|
|
},
|
|
resource: {
|
|
domainname: ['test-domain-value-1', 'test-domain-value-2']
|
|
}
|
|
})
|
|
await wrapper.vm.fillEditFormFieldValues()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.form).toEqual({ domainids: ['test-domain-value-1', 'test-domain-value-2'] })
|
|
done()
|
|
})
|
|
|
|
it('form data should not empty when currentAction.paramFields has item type equal `account`', async (done) => {
|
|
await wrapper.setData({
|
|
currentAction: {
|
|
paramFields: [
|
|
{ name: 'account', type: 'string' }
|
|
]
|
|
},
|
|
resource: {
|
|
account: 'test-account-value'
|
|
}
|
|
})
|
|
await wrapper.vm.fillEditFormFieldValues()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.form).toEqual({ account: 'test-account-value' })
|
|
done()
|
|
})
|
|
|
|
it('form data should not empty when currentAction.paramFields has item type not in [`list`, `account`]', async (done) => {
|
|
await wrapper.setData({
|
|
currentAction: {
|
|
paramFields: [
|
|
{ name: 'name', type: 'string' }
|
|
]
|
|
},
|
|
resource: {
|
|
name: 'test-name-value'
|
|
}
|
|
})
|
|
await wrapper.vm.fillEditFormFieldValues()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.form).toEqual({ name: 'test-name-value' })
|
|
done()
|
|
})
|
|
|
|
it('form data should be empty when currentAction.paramFields has item not exist in resource', async (done) => {
|
|
await wrapper.setData({
|
|
currentAction: {
|
|
paramFields: [
|
|
{ name: 'templatename', type: 'string' }
|
|
]
|
|
},
|
|
resource: {
|
|
name: 'test-name-value'
|
|
}
|
|
})
|
|
await wrapper.vm.fillEditFormFieldValues()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.form).toEqual({})
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('changeFilter()', () => {
|
|
it('check `route.query` when changeFilter() is called with empty', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'testRouter25' })
|
|
await wrapper.vm.changeFilter()
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-25')
|
|
expect(router.currentRoute.value.query).toEqual({
|
|
filter: undefined,
|
|
page: '1',
|
|
pagesize: '20'
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check `route.query` when changeFilter() is called with $route has query', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'testRouter25', query: { templatefilter: 'template', account: 'test-account' } })
|
|
await wrapper.vm.changeFilter('filter')
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-25')
|
|
expect(router.currentRoute.value.query).toEqual({
|
|
filter: 'filter',
|
|
page: '1',
|
|
pagesize: '20'
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check `route.query` when changeFilter() is called with filter not empty', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'testRouter25' })
|
|
await wrapper.vm.changeFilter('filter')
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-25')
|
|
expect(router.currentRoute.value.query).toEqual({
|
|
filter: 'filter',
|
|
page: '1',
|
|
pagesize: '20'
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check `route.query` when changeFilter() is called with $route.name equal `template`', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'template' })
|
|
await wrapper.vm.changeFilter('filter')
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/template')
|
|
expect(router.currentRoute.value.query).toEqual({
|
|
filter: 'filter',
|
|
templatefilter: 'filter',
|
|
page: '1',
|
|
pagesize: '20'
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check `route.query` when changeFilter() is called with $route.name equal `iso`', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'iso' })
|
|
await wrapper.vm.changeFilter('filter')
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/iso')
|
|
expect(router.currentRoute.value.query).toEqual({
|
|
filter: 'filter',
|
|
isofilter: 'filter',
|
|
page: '1',
|
|
pagesize: '20'
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check `route.query` when changeFilter() is called with $route.name equal `guestnetwork`', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'guestnetwork' })
|
|
await wrapper.vm.changeFilter('filter')
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/guestnetwork')
|
|
expect(router.currentRoute.value.query).toEqual({
|
|
filter: 'filter',
|
|
networkfilter: 'filter',
|
|
page: '1',
|
|
pagesize: '20'
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check `route.query` when changeFilter() is called with filter equal `self` and $route.name equal `vm`', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'vm' })
|
|
await wrapper.vm.changeFilter('self')
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/vm')
|
|
expect(router.currentRoute.value.query).toEqual({
|
|
account: 'test-account',
|
|
domainid: 'test-domain-id',
|
|
filter: 'self',
|
|
page: '1',
|
|
pagesize: '20'
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check `route.query` when changeFilter() is called with filter equal `running` and $route.name equal `vm`', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'vm' })
|
|
await wrapper.vm.changeFilter('running')
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/vm')
|
|
expect(router.currentRoute.value.query).toEqual({
|
|
state: 'running',
|
|
filter: 'running',
|
|
page: '1',
|
|
pagesize: '20'
|
|
})
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('changePage()', () => {
|
|
it('check $route query when changePage() is called with args not empty', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'testRouter26' })
|
|
await wrapper.vm.changePage(2, 10)
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-26')
|
|
expect(router.currentRoute.value.query).toEqual({ page: '2', pagesize: '10' })
|
|
done()
|
|
})
|
|
|
|
it('check $route query when changePage() is called with args empty', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'testRouter26', query: { page: 1, pagesize: 10 } })
|
|
await wrapper.vm.changePage()
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-26')
|
|
expect(router.currentRoute.value.query).toEqual({ page: undefined, pagesize: undefined })
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('changePageSize()', () => {
|
|
it('check $route query when changePageSize() is called with args empty', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'testRouter27' })
|
|
await wrapper.vm.changePageSize()
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-27')
|
|
expect(router.currentRoute.value.query).toEqual({ page: undefined, pagesize: undefined })
|
|
done()
|
|
})
|
|
|
|
it('check $route query when changePageSize() is called with args not empty', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
|
|
await router.push({ name: 'testRouter27' })
|
|
await wrapper.vm.changePageSize(2, 10)
|
|
await flushPromises()
|
|
|
|
expect(router.currentRoute.value.path).toEqual('/test-router-27')
|
|
expect(router.currentRoute.value.query).toEqual({ page: '2', pagesize: '10' })
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('start()', () => {
|
|
it('check loading, selectedRowKeys, fetchData() when start() is called', async (done) => {
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.fetchData = jest.fn((args) => {})
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
|
|
await wrapper.setData({ selectedRowKeys: [{ id: 'test-id' }] })
|
|
await wrapper.vm.start()
|
|
await flushPromises()
|
|
|
|
expect(fetchData).toHaveBeenCalledTimes(1)
|
|
|
|
setTimeout(() => {
|
|
expect(wrapper.vm.loading).toBeFalsy()
|
|
expect(wrapper.vm.selectedRowKeys).toEqual([])
|
|
done()
|
|
}, 1000)
|
|
})
|
|
})
|
|
|
|
describe('toggleLoading()', () => {
|
|
it('check loading when toggleLoading() is called', async (done) => {
|
|
await wrapper.setData({ loading: false })
|
|
await wrapper.vm.toggleLoading()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.loading).toBeTruthy()
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('startLoading()', () => {
|
|
it('check loading when startLoading() is called', async (done) => {
|
|
await wrapper.setData({ loading: false })
|
|
await wrapper.vm.startLoading()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.loading).toBeTruthy()
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('finishLoading()', () => {
|
|
it('check loading when finishLoading() is called', async (done) => {
|
|
await wrapper.setData({ loading: true })
|
|
await wrapper.vm.finishLoading()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.loading).toBeFalsy()
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('handleConfirmBlur()', () => {
|
|
it('check confirmDirty value when handleConfirmBlur() is called with args empty', async (done) => {
|
|
await wrapper.setData({ confirmDirty: undefined })
|
|
await wrapper.vm.handleConfirmBlur()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.confirmDirty).toBeUndefined()
|
|
done()
|
|
})
|
|
|
|
it('check confirmDirty value when handleConfirmBlur() is called with args name not equal `confirmpassword`', async (done) => {
|
|
const event = document.createEvent('Event')
|
|
|
|
await wrapper.setData({ confirmDirty: undefined })
|
|
await wrapper.vm.handleConfirmBlur(event, 'test')
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.confirmDirty).toBeUndefined()
|
|
done()
|
|
})
|
|
|
|
it('check confirmDirty value when handleConfirmBlur() is called with args name equal `confirmpassword`', async (done) => {
|
|
await wrapper.setData({ confirmDirty: false })
|
|
await wrapper.vm.handleConfirmBlur({ target: { value: true } }, 'confirmpassword')
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.confirmDirty).toBeTruthy()
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('validateTwoPassword()', () => {
|
|
it('validate password result is empty when validateTwoPassword() calling with value empty', async (done) => {
|
|
wrapper.vm.form = {}
|
|
|
|
const result = await wrapper.vm.validateTwoPassword({}, null)
|
|
await flushPromises()
|
|
|
|
expect(result).toBeUndefined()
|
|
done()
|
|
})
|
|
|
|
it('validate field `confirmpassword` not valid when validateTwoPassword() is called with `password` not empty', async (done) => {
|
|
let result = null
|
|
wrapper.vm.form = { password: 'abc123' }
|
|
|
|
try {
|
|
result = await wrapper.vm.validateTwoPassword({ field: 'confirmpassword' }, '123abc')
|
|
await flushPromises()
|
|
} catch (e) {
|
|
result = e
|
|
}
|
|
|
|
expect(result).not.toBeUndefined()
|
|
expect(result).toEqual('message validate password')
|
|
done()
|
|
})
|
|
|
|
it('validate field `confirmpassword` valid and result empty when validateTwoPassword() is called with `password` not empty', async (done) => {
|
|
wrapper.vm.form = { password: 'abc123' }
|
|
|
|
const result = await wrapper.vm.validateTwoPassword({ field: 'confirmpassword' }, 'abc123')
|
|
await flushPromises()
|
|
|
|
expect(result).toBeUndefined()
|
|
done()
|
|
})
|
|
|
|
it('validate field `password` valid when validateTwoPassword() is called with `confirmpassword` is empty', async (done) => {
|
|
wrapper.vm.form = { confirmpassword: '' }
|
|
|
|
const result = await wrapper.vm.validateTwoPassword({ field: 'password' }, 'abc123')
|
|
await flushPromises()
|
|
|
|
expect(result).toBeUndefined()
|
|
done()
|
|
})
|
|
|
|
it('validate field `password` valid when validateTwoPassword() is called with `confirmpassword` not empty', async (done) => {
|
|
wrapper.vm.form = { confirmpassword: 'abc123' }
|
|
|
|
const result = await wrapper.vm.validateTwoPassword({ field: 'password' }, 'abc123')
|
|
await flushPromises()
|
|
|
|
expect(result).toBeUndefined()
|
|
done()
|
|
})
|
|
|
|
it('validate field `confirmpassword` a when validateTwoPassword() is called with confirmDirty equal true', async (done) => {
|
|
wrapper.vm.form = { confirmpassword: '123abc' }
|
|
originalFunc.RefValidateFields = wrapper.vm.formRef.value.validateFields
|
|
wrapper.vm.formRef.value.validateFields = jest.fn((field) => {})
|
|
|
|
const formRefValidate = jest.spyOn(wrapper.vm.formRef.value, 'validateFields')
|
|
await wrapper.setData({ confirmDirty: true })
|
|
const result = await wrapper.vm.validateTwoPassword({ field: 'password' }, 'abc123')
|
|
await flushPromises()
|
|
|
|
expect(result).toBeUndefined()
|
|
expect(formRefValidate).toHaveBeenCalledTimes(1)
|
|
expect(formRefValidate).toHaveBeenLastCalledWith('confirmpassword')
|
|
done()
|
|
})
|
|
|
|
it('validate field `password` valid when validateTwoPassword() is called with confirmDirty equal false', async (done) => {
|
|
wrapper.vm.form = { confirmpassword: 'abc123' }
|
|
|
|
await wrapper.setData({ confirmDirty: false })
|
|
const result = await wrapper.vm.validateTwoPassword({ field: 'password' }, 'abc123')
|
|
await flushPromises()
|
|
|
|
expect(result).toBeUndefined()
|
|
done()
|
|
})
|
|
|
|
it('validate result empty when validateTwoPassword() is called with rules.field not equals `password` or `confirmpassword`', async (done) => {
|
|
wrapper.vm.form = {}
|
|
|
|
const result = await wrapper.vm.validateTwoPassword({ field: 'name' }, 'abc123')
|
|
await flushPromises()
|
|
|
|
expect(result).toBeUndefined()
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('setRules()', () => {
|
|
it('check rules when setRules() is called with args empty', async (done) => {
|
|
await wrapper.vm.setRules()
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({})
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with args not empty', async (done) => {
|
|
await wrapper.vm.setRules({ name: 'field', required: true })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({ field: [{ required: true, message: 'required-input' }] })
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with args field.type equal `boolean`', async (done) => {
|
|
await wrapper.vm.setRules({ name: 'field', required: true, type: 'boolean' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({ field: [{ required: true, message: 'required-input' }] })
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with currentAction.mapping not empty', async (done) => {
|
|
await wrapper.setData({
|
|
currentAction: {
|
|
mapping: {
|
|
field: {
|
|
options: []
|
|
}
|
|
}
|
|
}
|
|
})
|
|
await wrapper.vm.setRules({ name: 'field', required: true })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({ field: [{ required: true, message: 'required-select' }] })
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.name equal `keypair`', async (done) => {
|
|
await wrapper.vm.setRules({ name: 'keypair', required: true })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({ keypair: [{ required: true, message: 'required-select' }] })
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.name equal `account`', async (done) => {
|
|
await wrapper.setData({ currentAction: { api: 'testApiNameCase1' } })
|
|
await wrapper.vm.setRules({ name: 'account', required: true })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({ account: [{ required: true, message: 'required-select' }] })
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.type equal `uuid`', async (done) => {
|
|
await wrapper.vm.setRules({ name: 'field', required: true, type: 'uuid' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({ field: [{ required: true, message: 'required-select' }] })
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.type equal `list`', async (done) => {
|
|
await wrapper.vm.setRules({ name: 'field', required: true, type: 'list' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({ field: [{ type: 'array', required: true, message: 'required-select' }] })
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.type equal `long`', async (done) => {
|
|
await wrapper.vm.setRules({ name: 'field', required: true, type: 'long' })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({ field: [{ type: 'number', required: true, message: 'required-number' }] })
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.name equal `password`', async (done) => {
|
|
originalFunc.validateTwoPassword = wrapper.vm.validateTwoPassword
|
|
wrapper.vm.validateTwoPassword = jest.fn()
|
|
|
|
await wrapper.vm.setRules({ name: 'password', required: true })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({
|
|
password: [
|
|
{ required: true, message: 'required-input' },
|
|
{ validator: wrapper.vm.validateTwoPassword }
|
|
]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.name equal `currentpassword`', async (done) => {
|
|
originalFunc.validateTwoPassword = wrapper.vm.validateTwoPassword
|
|
wrapper.vm.validateTwoPassword = jest.fn()
|
|
|
|
await wrapper.vm.setRules({ name: 'currentpassword', required: true })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({
|
|
currentpassword: [
|
|
{ required: true, message: 'required-input' },
|
|
{ validator: wrapper.vm.validateTwoPassword }
|
|
]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.name equal `confirmpassword`', async (done) => {
|
|
originalFunc.validateTwoPassword = wrapper.vm.validateTwoPassword
|
|
wrapper.vm.validateTwoPassword = jest.fn()
|
|
|
|
await wrapper.vm.setRules({ name: 'confirmpassword', required: true })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({
|
|
confirmpassword: [
|
|
{ required: true, message: 'required-input' },
|
|
{ validator: wrapper.vm.validateTwoPassword }
|
|
]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.name equal `certificate`', async (done) => {
|
|
await wrapper.vm.setRules({ name: 'certificate', required: true })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({
|
|
certificate: [
|
|
{ required: true, message: 'required-input' }
|
|
]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.name equal `privatekey`', async (done) => {
|
|
await wrapper.vm.setRules({ name: 'privatekey', required: true })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({
|
|
privatekey: [
|
|
{ required: true, message: 'required-input' }
|
|
]
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('check rules when setRules() is called with field.name equal `certchain`', async (done) => {
|
|
await wrapper.vm.setRules({ name: 'certchain', required: true })
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.rules).toEqual({
|
|
certchain: [
|
|
{ required: true, message: 'required-input' }
|
|
]
|
|
})
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('handleSubmit', () => {
|
|
it('execSubmit() should be called when handleSubmit() is called in resource view', async (done) => {
|
|
originalFunc.execSubmit = wrapper.vm.execSubmit
|
|
wrapper.vm.execSubmit = jest.fn((event) => {})
|
|
|
|
const execSubmit = jest.spyOn(wrapper.vm, 'execSubmit')
|
|
const event = document.createEvent('Event')
|
|
await wrapper.setData({ dataView: true })
|
|
await wrapper.vm.handleSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(execSubmit).toHaveBeenCalledTimes(1)
|
|
expect(execSubmit).toHaveBeenCalledWith(event)
|
|
done()
|
|
})
|
|
|
|
it('formRef makes validation calls when handleSubmit() is called in list view', async (done) => {
|
|
originalFunc.callGroupApi = wrapper.vm.callGroupApi
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
originalFunc.formRef = wrapper.vm.formRef
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.callGroupApi = jest.fn((params, resourceName) => {
|
|
return new Promise(resolve => {
|
|
resolve()
|
|
})
|
|
})
|
|
if (!wrapper.vm.formRef) {
|
|
wrapper.vm.formRef = ref()
|
|
}
|
|
wrapper.vm.formRef.value.validate = jest.fn((params, resourceName) => {
|
|
return new Promise(resolve => {
|
|
resolve()
|
|
})
|
|
})
|
|
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
const callGroupApi = jest.spyOn(wrapper.vm, 'callGroupApi')
|
|
const event = document.createEvent('Event')
|
|
|
|
await wrapper.setData({
|
|
dataView: false,
|
|
currentAction: {
|
|
label: 'label.name',
|
|
groupAction: true,
|
|
groupMap: (selection) => {
|
|
return selection.map(x => { return { id: x } })
|
|
}
|
|
},
|
|
selectedRowKeys: ['test-id-value-1'],
|
|
items: [{
|
|
id: 'test-id-value-1',
|
|
name: 'test-name-value-1'
|
|
}],
|
|
columns: [{
|
|
key: 'column1',
|
|
dataIndex: 'column1',
|
|
title: 'column1'
|
|
}]
|
|
})
|
|
await wrapper.vm.handleSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(wrapper.vm.promises).toHaveLength(1)
|
|
expect(callGroupApi).toHaveBeenCalledTimes(1)
|
|
expect(callGroupApi).toHaveBeenCalledWith({ id: 'test-id-value-1' }, 'test-name-value-1')
|
|
expect(fetchData).toHaveBeenCalledTimes(1)
|
|
expect(mocks.$message.info).toHaveBeenCalledTimes(1)
|
|
expect(mocks.$message.info).toHaveBeenCalledWith({
|
|
content: 'name-en',
|
|
key: 'label.name',
|
|
duration: 3
|
|
})
|
|
done()
|
|
})
|
|
})
|
|
|
|
describe('execSubmit()', () => {
|
|
it('API should be called with params has item id equal resource.id', async (done) => {
|
|
mockAxios.mockResolvedValue({})
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
|
|
const event = document.createEvent('Event')
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
icon: 'plus-outlined',
|
|
params: [{ name: 'id', type: 'uuid' }],
|
|
paramFields: [{ name: 'id', type: 'uuid' }]
|
|
},
|
|
resource: {
|
|
id: 'test-resource-id'
|
|
}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
id: 'test-resource-id',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has input key not exist in currentAction.params', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'id', type: 'uuid' }],
|
|
paramFields: [{ name: 'id', type: 'uuid' }]
|
|
},
|
|
resource: {
|
|
id: 'test-resource-id'
|
|
}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
id: 'test-resource-id',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has input key exist in currentAction.params, type is boolean and value is undefined', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { column1: undefined }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'column1', type: 'boolean' }],
|
|
paramFields: [{ name: 'column1', type: 'boolean' }]
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
column1: false,
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has input key exist in currentAction.params, type is boolean and value is null', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { column1: null }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'column1', type: 'boolean' }],
|
|
paramFields: [{ name: 'column1', type: 'boolean' }]
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
column1: false,
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has input key exist in currentAction.params, type is boolean and value is empty', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { column1: '' }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'column1', type: 'boolean' }],
|
|
paramFields: [{ name: 'column1', type: 'boolean' }]
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
column1: false,
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has not input tag', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { column1: '' }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'column1', type: 'string' }],
|
|
paramFields: [{ name: 'column1', type: 'string' }]
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has input key exist in currentAction.mapping', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { column1: 1 }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'column1', type: 'list' }],
|
|
paramFields: [{ name: 'column1', type: 'list' }],
|
|
mapping: {
|
|
column1: {
|
|
options: ['column-value1', 'column-value2']
|
|
}
|
|
}
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
column1: 'column-value2',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has input key not exist in currentAction.mapping, type is list and currentAction.params[input] has id', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { column1: [1, 2] }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [
|
|
{
|
|
name: 'column1',
|
|
type: 'list',
|
|
opts: [
|
|
{ id: 'test-id-1', value: 'test-value-1' },
|
|
{ id: 'test-id-2', value: 'test-value-2' },
|
|
{ id: 'test-id-3', value: 'test-value-3' }
|
|
]
|
|
}
|
|
],
|
|
paramFields: [
|
|
{
|
|
name: 'column1',
|
|
type: 'list',
|
|
opts: [
|
|
{ id: 'test-id-1', value: 'test-value-1' },
|
|
{ id: 'test-id-2', value: 'test-value-2' },
|
|
{ id: 'test-id-3', value: 'test-value-3' }
|
|
]
|
|
}
|
|
],
|
|
mapping: {}
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
column1: 'test-id-2,test-id-3',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has input key has name = account, currentAction.api = createAccount', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { account: 'test-account-value' }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'createAccount',
|
|
label: 'label.name',
|
|
params: [{ name: 'account', type: 'string' }],
|
|
paramFields: [{ name: 'account', type: 'string' }],
|
|
mapping: {}
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'createAccount',
|
|
account: 'test-account-value',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has input key has name = keypair, currentAction.api = addAccountToProject', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { keypair: 'test-keypair-value' }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'addAccountToProject',
|
|
label: 'label.name',
|
|
params: [{ name: 'keypair', type: 'string' }],
|
|
paramFields: [{ name: 'keypair', type: 'string' }],
|
|
mapping: {}
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'addAccountToProject',
|
|
keypair: 'test-keypair-value',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has input key name = (account | keypair), currentAction.api != (addAccountToProject | createAccount)', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { keypair: 1 }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [
|
|
{
|
|
name: 'keypair',
|
|
type: 'string',
|
|
opts: [
|
|
{ id: 'test-id-1', name: 'test-name-1' },
|
|
{ id: 'test-id-2', name: 'test-name-2' }
|
|
]
|
|
}
|
|
],
|
|
paramFields: [
|
|
{
|
|
name: 'keypair',
|
|
type: 'string',
|
|
opts: [
|
|
{ id: 'test-id-1', name: 'test-name-1' },
|
|
{ id: 'test-id-2', name: 'test-name-2' }
|
|
]
|
|
}
|
|
],
|
|
mapping: {}
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
keypair: 'test-name-2',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when form has input key do not fall under special condition.', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { column1: 'test-column-value' }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'column1', type: 'string' }],
|
|
paramFields: [{ name: 'column1', type: 'string' }],
|
|
mapping: {}
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
column1: 'test-column-value',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when currentAction has defaultArgs', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { column1: 'test-column1-value' }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'column1', type: 'string' }],
|
|
paramFields: [{ name: 'column1', type: 'string' }],
|
|
mapping: {},
|
|
defaultArgs: {
|
|
column2: 'test-column2-value'
|
|
}
|
|
},
|
|
resource: {}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
column1: 'test-column1-value',
|
|
column2: 'test-column2-value',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called when currentAction.mapping has value and value is function', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.form = { column1: 'test-column1-value' }
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'column1', type: 'string' }],
|
|
paramFields: [{ name: 'column1', type: 'string' }],
|
|
mapping: {
|
|
column2: {
|
|
value: (record, params) => {
|
|
return record.name
|
|
}
|
|
}
|
|
}
|
|
},
|
|
resource: {
|
|
id: 'test-id-value',
|
|
name: 'test-name-value'
|
|
}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'GET',
|
|
data: new URLSearchParams(),
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
column1: 'test-column1-value',
|
|
column2: 'test-name-value',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('API should be called with post method', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
originalFunc.closeAction = wrapper.vm.closeAction
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.fetchData = jest.fn()
|
|
wrapper.vm.closeAction = jest.fn()
|
|
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'id', type: 'uuid' }],
|
|
paramFields: [{ name: 'id', type: 'uuid' }],
|
|
post: true
|
|
},
|
|
resource: {
|
|
id: 'test-id-value'
|
|
}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
const postData = new URLSearchParams()
|
|
postData.append('id', 'test-id-value')
|
|
|
|
expect(mockAxios).toHaveBeenCalled()
|
|
expect(mockAxios).toHaveBeenLastCalledWith({
|
|
url: '/',
|
|
method: 'POST',
|
|
data: postData,
|
|
params: {
|
|
command: 'testApiNameCase1',
|
|
response: 'json'
|
|
}
|
|
})
|
|
done()
|
|
})
|
|
|
|
it('handleResponse() & closeAction() should be called when API response success', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.closeAction = wrapper.vm.closeAction
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, params, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.closeAction = jest.fn()
|
|
wrapper.vm.fetchData = jest.fn()
|
|
|
|
const handleResponse = jest.spyOn(wrapper.vm, 'handleResponse')
|
|
const closeAction = jest.spyOn(wrapper.vm, 'closeAction')
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'id', type: 'uuid' }],
|
|
paramFields: [{ name: 'id', type: 'uuid' }]
|
|
},
|
|
resource: {
|
|
id: 'test-id-value'
|
|
}
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(handleResponse).toHaveBeenCalledTimes(1)
|
|
expect(handleResponse).toHaveBeenLastCalledWith(
|
|
{},
|
|
'test-id-value',
|
|
'test-id-value',
|
|
{
|
|
api: 'testApiNameCase1',
|
|
label: 'label.name',
|
|
params: [{ name: 'id', type: 'uuid' }],
|
|
paramFields: [{ name: 'id', type: 'uuid' }]
|
|
}
|
|
)
|
|
expect(closeAction).toHaveBeenCalledTimes(1)
|
|
done()
|
|
})
|
|
|
|
it('$router should go back when API response success with shouldNavigateBack() return true', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.closeAction = wrapper.vm.closeAction
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
originalFunc.routerGo = wrapper.vm.$router.go
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return true })
|
|
wrapper.vm.$router.go = jest.fn((number) => {})
|
|
wrapper.vm.closeAction = jest.fn()
|
|
wrapper.vm.fetchData = jest.fn()
|
|
|
|
const routerGo = jest.spyOn(wrapper.vm.$router, 'go')
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
icon: 'delete-outlined',
|
|
label: 'label.name',
|
|
params: [{ name: 'id', type: 'uuid' }],
|
|
paramFields: [{ name: 'id', type: 'uuid' }]
|
|
},
|
|
resource: {
|
|
id: 'test-id-value'
|
|
},
|
|
dataView: true
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(routerGo).toHaveBeenCalledTimes(1)
|
|
expect(routerGo).toHaveBeenLastCalledWith(-1)
|
|
done()
|
|
})
|
|
|
|
it('$router should go back when API response success with action.api equal `archiveEvents`', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.closeAction = wrapper.vm.closeAction
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
originalFunc.routerGo = wrapper.vm.$router.go
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return true })
|
|
wrapper.vm.$router.go = jest.fn((number) => {})
|
|
wrapper.vm.closeAction = jest.fn()
|
|
wrapper.vm.fetchData = jest.fn()
|
|
|
|
const routerGo = jest.spyOn(wrapper.vm.$router, 'go')
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'archiveEvents',
|
|
icon: 'plus-outlined',
|
|
label: 'label.name',
|
|
params: [{ name: 'id', type: 'uuid' }],
|
|
paramFields: [{ name: 'id', type: 'uuid' }]
|
|
},
|
|
resource: {
|
|
id: 'test-id-value'
|
|
},
|
|
dataView: true
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(routerGo).toHaveBeenCalledTimes(1)
|
|
expect(routerGo).toHaveBeenLastCalledWith(-1)
|
|
done()
|
|
})
|
|
|
|
it('fetchData() should be called when API response success with jobId empty', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.closeAction = wrapper.vm.closeAction
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve() })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.closeAction = jest.fn()
|
|
wrapper.vm.fetchData = jest.fn()
|
|
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
icon: 'plus-outlined',
|
|
label: 'label.name',
|
|
params: [{ name: 'id', type: 'uuid' }],
|
|
paramFields: [{ name: 'id', type: 'uuid' }]
|
|
},
|
|
resource: {
|
|
id: 'test-id-value'
|
|
},
|
|
dataView: true
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(fetchData).toHaveBeenCalled()
|
|
done()
|
|
})
|
|
|
|
it('fetchData() not called when API response success with jobId not empty', async (done) => {
|
|
originalFunc.handleResponse = wrapper.vm.handleResponse
|
|
originalFunc.shouldNavigateBack = wrapper.vm.shouldNavigateBack
|
|
originalFunc.closeAction = wrapper.vm.closeAction
|
|
originalFunc.fetchData = wrapper.vm.fetchData
|
|
wrapper.vm.handleResponse = jest.fn(async (json, resourceName, action) => { return Promise.resolve('test-job-id') })
|
|
wrapper.vm.shouldNavigateBack = jest.fn((args) => { return false })
|
|
wrapper.vm.closeAction = jest.fn()
|
|
wrapper.vm.fetchData = jest.fn()
|
|
|
|
const fetchData = jest.spyOn(wrapper.vm, 'fetchData')
|
|
const event = document.createEvent('Event')
|
|
await mockAxios.mockResolvedValue({})
|
|
await wrapper.setData({
|
|
showAction: true,
|
|
currentAction: {
|
|
api: 'testApiNameCase1',
|
|
icon: 'plus-outlined',
|
|
label: 'label.name',
|
|
params: [{ name: 'id', type: 'uuid' }],
|
|
paramFields: [{ name: 'id', type: 'uuid' }]
|
|
},
|
|
resource: {
|
|
id: 'test-id-value'
|
|
},
|
|
dataView: true
|
|
})
|
|
await wrapper.vm.execSubmit(event)
|
|
await flushPromises()
|
|
|
|
expect(fetchData).not.toHaveBeenCalled()
|
|
done()
|
|
})
|
|
})
|
|
})
|
|
})
|