mirror of
https://github.com/XiaoDaiGua-Ray/ray-template.git
synced 2026-11-18 17:03:36 +08:00
649 lines
20 KiB
TypeScript
649 lines
20 KiB
TypeScript
import { RTablePro, useTablePro } from '@/components/RTablePro'
|
|
import type {
|
|
TableProInst,
|
|
TableProParams,
|
|
TableProResult,
|
|
} from '@/components/RTablePro'
|
|
import { provideUiServices } from '@ray-template/ui/services'
|
|
import { flushPromises, mount } from '@vue/test-utils'
|
|
import { NDataTable, NDropdown, NPagination } from 'naive-ui'
|
|
import { defineComponent, h } from 'vue'
|
|
import * as csv from '../../packages/ui/src/RTablePro/src/csv'
|
|
|
|
const columns = [{ title: 'Name', key: 'name' }]
|
|
const response = (name: string, total = 30): TableProResult => ({
|
|
data: [{ id: name, name }],
|
|
total,
|
|
})
|
|
|
|
it('binds table actions on mount and clears the instance until the table remounts', async () => {
|
|
const [
|
|
register,
|
|
{ isReady, reload, setPage, getTableProInstance, getCurrentPageData },
|
|
] = useTablePro()
|
|
const request = vi.fn(async (_params: TableProParams) => response('Alice'))
|
|
const mountTable = () =>
|
|
mount(RTablePro, { props: { columns, request, onRegister: register } })
|
|
|
|
expect(isReady.value).toBe(false)
|
|
expect(getTableProInstance).toThrow('Table is not mounted')
|
|
const first = mountTable()
|
|
const originalInstance = getTableProInstance()
|
|
|
|
try {
|
|
expect(isReady.value).toBe(true)
|
|
await setPage(2)
|
|
await flushPromises()
|
|
expect(request.mock.lastCall?.[0]).toEqual({ page: 2, pageSize: 10 })
|
|
expect(getCurrentPageData()).toEqual(response('Alice').data)
|
|
} finally {
|
|
first.unmount()
|
|
}
|
|
|
|
expect(isReady.value).toBe(false)
|
|
expect(getTableProInstance).toThrow('Table is not mounted')
|
|
const second = mountTable()
|
|
|
|
try {
|
|
expect(isReady.value).toBe(true)
|
|
expect(getTableProInstance()).not.toBe(originalInstance)
|
|
await setPage(2)
|
|
await reload(true)
|
|
expect(request.mock.lastCall?.[0]).toEqual({ page: 1, pageSize: 10 })
|
|
} finally {
|
|
second.unmount()
|
|
}
|
|
})
|
|
|
|
it('loads and paginates once per action, without rewriting the filter object', async () => {
|
|
const request = vi.fn(async (_params: TableProParams) => response('Alice'))
|
|
const filters = { email: '@example.test', page: 99 }
|
|
const wrapper = mount(RTablePro, {
|
|
props: { columns, request, params: filters, tool: false },
|
|
})
|
|
|
|
try {
|
|
await flushPromises()
|
|
expect(request.mock.calls).toEqual([
|
|
[
|
|
{ email: '@example.test', page: 1, pageSize: 10 },
|
|
expect.any(AbortSignal),
|
|
],
|
|
])
|
|
const table = wrapper.getComponent(NDataTable)
|
|
|
|
expect(table.props('remote')).toBe(true)
|
|
expect(table.props('data')).toEqual(response('Alice').data)
|
|
expect(wrapper.getComponent(NPagination).props('itemCount')).toBe(30)
|
|
|
|
const instance = wrapper.vm as unknown as TableProInst
|
|
|
|
await instance.setPage(2)
|
|
await instance.setPageSize(20)
|
|
await instance.setPage(2)
|
|
await wrapper.setProps({ params: { email: 'alice' } })
|
|
await flushPromises()
|
|
|
|
expect(request.mock.calls.map(([params]) => params)).toEqual([
|
|
{ email: '@example.test', page: 1, pageSize: 10 },
|
|
{ email: '@example.test', page: 2, pageSize: 10 },
|
|
{ email: '@example.test', page: 1, pageSize: 20 },
|
|
{ email: '@example.test', page: 2, pageSize: 20 },
|
|
{ email: 'alice', page: 1, pageSize: 20 },
|
|
])
|
|
expect(filters).toEqual({ email: '@example.test', page: 99 })
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('ignores stale data even if the loader ignores cancellation', async () => {
|
|
const first = Promise.withResolvers<TableProResult>()
|
|
const second = Promise.withResolvers<TableProResult>()
|
|
const request = vi
|
|
.fn((_params: TableProParams, _signal: AbortSignal) => first.promise)
|
|
.mockImplementationOnce(() => first.promise)
|
|
.mockImplementationOnce(() => second.promise)
|
|
const wrapper = mount(RTablePro, { props: { columns, request, tool: false } })
|
|
|
|
try {
|
|
const instance = wrapper.vm as unknown as TableProInst
|
|
const next = instance.setPage(2)
|
|
|
|
expect(request.mock.calls[0][1].aborted).toBe(true)
|
|
second.resolve(response('New page', 40))
|
|
await next
|
|
first.resolve(response('Old page'))
|
|
await flushPromises()
|
|
|
|
expect(wrapper.text()).toContain('New page')
|
|
expect(wrapper.text()).not.toContain('Old page')
|
|
expect(wrapper.getComponent(NDataTable).props('loading')).toBe(false)
|
|
expect(instance.queryState).toMatchObject({
|
|
loading: false,
|
|
failed: false,
|
|
page: 2,
|
|
total: 40,
|
|
})
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('exposes read-only query state during load, failure and retry', async () => {
|
|
const initial = Promise.withResolvers<TableProResult>()
|
|
const failing = Promise.withResolvers<TableProResult>()
|
|
const retry = Promise.withResolvers<TableProResult>()
|
|
const request = vi
|
|
.fn(() => retry.promise)
|
|
.mockReturnValueOnce(initial.promise)
|
|
.mockReturnValueOnce(failing.promise)
|
|
const [register, { queryState, reload, setPageSize }] = useTablePro()
|
|
|
|
expect(queryState.value).toBeNull()
|
|
const wrapper = mount(RTablePro, {
|
|
props: { columns, request, onRegister: register, tool: false },
|
|
})
|
|
|
|
try {
|
|
expect(queryState.value).toEqual({
|
|
loading: true,
|
|
failed: false,
|
|
page: 1,
|
|
pageSize: 10,
|
|
total: null,
|
|
})
|
|
expect(Reflect.set(queryState.value!, 'page', 99)).toBe(false)
|
|
|
|
initial.resolve(response('Last successful result', 42))
|
|
await flushPromises()
|
|
expect(queryState.value).toMatchObject({ loading: false, total: 42 })
|
|
|
|
const next = setPageSize(20)
|
|
|
|
expect(queryState.value).toMatchObject({
|
|
loading: true,
|
|
pageSize: 20,
|
|
total: 42,
|
|
})
|
|
failing.reject(new Error('offline'))
|
|
await next
|
|
expect(queryState.value).toEqual({
|
|
loading: false,
|
|
failed: true,
|
|
page: 1,
|
|
pageSize: 20,
|
|
total: null,
|
|
})
|
|
expect(wrapper.text()).not.toContain('Last successful result')
|
|
|
|
const retrying = reload()
|
|
|
|
expect(queryState.value).toMatchObject({
|
|
loading: true,
|
|
failed: false,
|
|
total: null,
|
|
})
|
|
retry.resolve(response('Recovered', 7))
|
|
await retrying
|
|
expect(queryState.value).toMatchObject({
|
|
loading: false,
|
|
failed: false,
|
|
total: 7,
|
|
})
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
|
|
expect(queryState.value).toBeNull()
|
|
})
|
|
|
|
it('clears rows and blocks output while a different query scope loads or fails', async () => {
|
|
const failed = Promise.withResolvers<TableProResult>()
|
|
const request = vi
|
|
.fn(async (_params: TableProParams) => response('Account B'))
|
|
.mockResolvedValueOnce(response('Account A'))
|
|
.mockImplementationOnce(() => failed.promise)
|
|
const wrapper = mount(RTablePro, {
|
|
props: { columns, request, params: { account: { id: 'a' } } },
|
|
})
|
|
const table = wrapper.vm as unknown as TableProInst
|
|
const download = vi
|
|
.spyOn(csv, 'downloadTableCsv')
|
|
.mockImplementation(() => {})
|
|
|
|
try {
|
|
await flushPromises()
|
|
expect(table.getCurrentPageData()).toEqual(response('Account A').data)
|
|
await wrapper.setProps({ params: { account: { id: 'b' } } })
|
|
|
|
expect(table.queryState).toMatchObject({ loading: true, total: null })
|
|
expect(table.getCurrentPageData()).toEqual([])
|
|
expect(table.getTableInstance()).toBeNull()
|
|
expect(wrapper.getComponent(NDataTable).props('data')).toEqual([])
|
|
failed.reject(new Error('offline'))
|
|
await flushPromises()
|
|
|
|
expect(table.queryState).toMatchObject({ failed: true, total: null })
|
|
expect(wrapper.text()).not.toContain('Account A')
|
|
expect(await table.print()).toBe(false)
|
|
table.downloadCsv({ keepOriginalData: true })
|
|
expect(download).not.toHaveBeenCalled()
|
|
|
|
await table.reload()
|
|
expect(table.getCurrentPageData()).toEqual(response('Account B').data)
|
|
table.downloadCsv()
|
|
expect(download).toHaveBeenCalledExactlyOnceWith(
|
|
'"Name"\r\n"Account B"',
|
|
void 0,
|
|
)
|
|
} finally {
|
|
download.mockRestore()
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('clears even same-query rows on failure and when the request source changes', async () => {
|
|
const request = vi
|
|
.fn(async (_params: TableProParams) => response('Previous source'))
|
|
.mockResolvedValueOnce(response('Previous source'))
|
|
.mockRejectedValueOnce(new Error('offline'))
|
|
const replacement = vi.fn(async () => {
|
|
throw new Error('new source offline')
|
|
})
|
|
const wrapper = mount(RTablePro, { props: { columns, request } })
|
|
const table = wrapper.vm as unknown as TableProInst
|
|
|
|
try {
|
|
await flushPromises()
|
|
await table.reload()
|
|
expect(table.queryState).toMatchObject({ failed: true, total: null })
|
|
expect(table.getCurrentPageData()).toEqual([])
|
|
|
|
await table.reload()
|
|
expect(table.getCurrentPageData()).toEqual(response('Previous source').data)
|
|
await wrapper.setProps({ request: replacement })
|
|
await flushPromises()
|
|
expect(table.queryState).toMatchObject({ failed: true, total: null })
|
|
expect(table.getCurrentPageData()).toEqual([])
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('shows a toast and the normal empty state without an inline alert, then allows retry', async () => {
|
|
const request = vi
|
|
.fn(async (_params: TableProParams) => response('Recovered', 1))
|
|
.mockRejectedValueOnce(new Error('offline'))
|
|
const reportError = vi.fn()
|
|
const wrapper = mount(
|
|
defineComponent({
|
|
setup() {
|
|
provideUiServices({ reportError })
|
|
|
|
return () =>
|
|
h(
|
|
RTablePro,
|
|
{ columns, request, pagination: false, tool: false },
|
|
{
|
|
empty: () => 'Custom empty state',
|
|
notice: () => 'Always visible notice',
|
|
},
|
|
)
|
|
},
|
|
}),
|
|
)
|
|
const table = wrapper.getComponent(RTablePro)
|
|
const instance = table.vm as unknown as TableProInst
|
|
|
|
try {
|
|
await flushPromises()
|
|
expect(table.emitted('request-error')).toHaveLength(1)
|
|
expect(reportError).toHaveBeenCalledExactlyOnceWith(
|
|
"Couldn't load the data",
|
|
)
|
|
expect(table.getComponent(NDataTable).props('pagination')).toBe(false)
|
|
expect(table.text()).toContain('Custom empty state')
|
|
expect(table.text()).toContain('Always visible notice')
|
|
expect(table.find('.n-alert').exists()).toBe(false)
|
|
await instance.reload()
|
|
|
|
expect(request.mock.calls.map(([params]) => params)).toEqual([{}, {}])
|
|
expect(table.text()).toContain('Recovered')
|
|
expect(instance.queryState).toEqual({
|
|
loading: false,
|
|
failed: false,
|
|
page: null,
|
|
pageSize: null,
|
|
total: 1,
|
|
})
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('reads the sorted and filtered local page without a request or custom row key', async () => {
|
|
const data = [
|
|
{ id: 3, name: 'Third' },
|
|
{ id: 1, name: 'First' },
|
|
{ id: 2, name: 'Second' },
|
|
]
|
|
const wrapper = mount(RTablePro, {
|
|
props: {
|
|
columns: [{ title: 'Name', key: 'name', sorter: 'default' }],
|
|
data,
|
|
pageSize: 1,
|
|
search: [{ key: 'name', label: 'Name' }],
|
|
tool: false,
|
|
},
|
|
})
|
|
|
|
try {
|
|
expect(wrapper.getComponent(NDataTable).props('remote')).toBe(false)
|
|
const instance = wrapper.vm as unknown as TableProInst
|
|
|
|
expect(instance.getCurrentPageData()).toEqual([data[0]])
|
|
instance.getTableInstance()?.sort('name', 'ascend')
|
|
await instance.setPage(2)
|
|
expect(wrapper.text()).toContain('Second')
|
|
expect(instance.getCurrentPageData()).toEqual([data[2]])
|
|
|
|
await wrapper.get('input').setValue('ir')
|
|
await wrapper.get('form').trigger('submit')
|
|
expect(instance.getCurrentPageData()).toEqual([data[1]])
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('renders bare data without a toolbar or pagination by default', () => {
|
|
const wrapper = mount(RTablePro, {
|
|
props: { bare: true, columns, data: response('Bare row', 1).data },
|
|
})
|
|
|
|
try {
|
|
expect(wrapper.text()).toContain('Bare row')
|
|
expect(wrapper.getComponent(NDataTable).props('pagination')).toBe(false)
|
|
expect(wrapper.find('header').exists()).toBe(false)
|
|
expect(wrapper.classes()).not.toContain('r-table--card')
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('submits the search and resets the page without requiring form state in the caller', async () => {
|
|
const request = vi.fn(async (_params: TableProParams) => response('Alice'))
|
|
const wrapper = mount(RTablePro, {
|
|
props: {
|
|
columns,
|
|
request,
|
|
search: [{ key: 'name', label: 'Name' }],
|
|
tool: false,
|
|
},
|
|
})
|
|
|
|
try {
|
|
const instance = wrapper.vm as unknown as TableProInst
|
|
|
|
await instance.setPage(2)
|
|
await wrapper.get('input').setValue(' Alice ')
|
|
expect(request).toHaveBeenCalledTimes(2)
|
|
await wrapper.get('form').trigger('submit')
|
|
await flushPromises()
|
|
expect(request).toHaveBeenCalledTimes(3)
|
|
expect(request.mock.lastCall?.[0]).toEqual({
|
|
name: 'Alice',
|
|
page: 1,
|
|
pageSize: 10,
|
|
})
|
|
|
|
await wrapper.get('form button[type="button"]').trigger('click')
|
|
await flushPromises()
|
|
expect(request.mock.lastCall?.[0]).toEqual({ page: 1, pageSize: 10 })
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('enables the table body scroller with a single autoHeight prop', () => {
|
|
const wrapper = mount(RTablePro, {
|
|
props: {
|
|
autoHeight: true,
|
|
columns,
|
|
data: response('Row', 1).data,
|
|
tool: false,
|
|
},
|
|
})
|
|
|
|
try {
|
|
expect(wrapper.getComponent(NDataTable).props('flexHeight')).toBe(true)
|
|
expect(wrapper.classes()).toContain('r-table--fill')
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('returns to the last available remote page when the total shrinks', async () => {
|
|
const request = vi
|
|
.fn(async (_params: TableProParams) => response('First page', 5))
|
|
.mockResolvedValueOnce(response('Initial', 30))
|
|
.mockResolvedValueOnce({ data: [], total: 5 })
|
|
const wrapper = mount(RTablePro, { props: { columns, request, tool: false } })
|
|
|
|
try {
|
|
await flushPromises()
|
|
const instance = wrapper.vm as unknown as TableProInst
|
|
|
|
await instance.setPage(3)
|
|
|
|
expect(request.mock.calls.map(([params]) => params.page)).toEqual([1, 3, 1])
|
|
expect(wrapper.text()).toContain('First page')
|
|
expect(instance.queryState).toMatchObject({ page: 1, total: 5 })
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('passes native pagination settings and totals through for a manually controlled remote table', async () => {
|
|
const onUpdatePage = vi.fn()
|
|
const wrapper = mount(RTablePro, {
|
|
props: {
|
|
columns,
|
|
remote: true,
|
|
data: [{ id: 1, name: 'Loaded by caller' }],
|
|
pagination: {
|
|
page: 3,
|
|
pageSize: 20,
|
|
itemCount: 80,
|
|
showQuickJumper: true,
|
|
onUpdatePage,
|
|
},
|
|
tool: false,
|
|
},
|
|
})
|
|
|
|
try {
|
|
const pager = wrapper.getComponent(NPagination)
|
|
|
|
expect((wrapper.vm as unknown as TableProInst).queryState).toBeNull()
|
|
expect(pager.props()).toMatchObject({
|
|
page: 3,
|
|
pageSize: 20,
|
|
itemCount: 80,
|
|
showQuickJumper: true,
|
|
})
|
|
await pager.findAll('.n-pagination-item--button').at(-1)!.trigger('click')
|
|
expect(onUpdatePage).toHaveBeenCalledOnce()
|
|
expect(onUpdatePage).toHaveBeenCalledWith(4)
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('uses native initial paging options with managed requests and validates imperative values', async () => {
|
|
const request = vi.fn(async (_params: TableProParams) =>
|
|
response('Loaded', 100),
|
|
)
|
|
const wrapper = mount(RTablePro, {
|
|
props: {
|
|
columns,
|
|
request,
|
|
pagination: { defaultPage: 2, defaultPageSize: 20 },
|
|
tool: false,
|
|
},
|
|
})
|
|
|
|
try {
|
|
await flushPromises()
|
|
const instance = wrapper.vm as unknown as TableProInst
|
|
|
|
await instance.setPage(0)
|
|
await instance.setPageSize(Number.NaN)
|
|
expect(request.mock.calls.map(([params]) => params)).toEqual([
|
|
{ page: 2, pageSize: 20 },
|
|
])
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('keeps TablePro state in sync when DataTable changes its page directly', async () => {
|
|
const data = [
|
|
{ id: 1, name: 'First' },
|
|
{ id: 2, name: 'Second' },
|
|
]
|
|
const onUpdatePage = vi.fn()
|
|
const wrapper = mount(RTablePro, {
|
|
props: { data, columns, pageSize: 1, onUpdatePage, tool: false },
|
|
})
|
|
|
|
try {
|
|
const instance = wrapper.vm as unknown as TableProInst
|
|
|
|
instance.getTableInstance()?.page(2)
|
|
await wrapper.vm.$nextTick()
|
|
|
|
expect(wrapper.getComponent(NPagination).props('page')).toBe(2)
|
|
expect(wrapper.text()).toContain('Second')
|
|
expect(onUpdatePage).toHaveBeenCalledOnce()
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('supports an optional title slot for actions without putting controls inside a heading', () => {
|
|
const wrapper = mount(RTablePro, {
|
|
props: {
|
|
columns,
|
|
data: [{ id: 1, name: 'Alice' }],
|
|
title: 'Default title',
|
|
tool: false,
|
|
},
|
|
slots: { title: '<button>Quick action</button>' },
|
|
})
|
|
|
|
try {
|
|
expect(wrapper.get('header button').text()).toBe('Quick action')
|
|
expect(wrapper.find('header h2').exists()).toBe(false)
|
|
expect(wrapper.text()).not.toContain('Default title')
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('provides the row that opened the context menu and discards it after data changes', async () => {
|
|
const row = { id: 7, name: 'Alice' }
|
|
const option = { key: 'edit', label: 'Edit' }
|
|
const select = vi.fn()
|
|
const onContextmenu = vi.fn((event: MouseEvent) => event.preventDefault())
|
|
const wrapper = mount(RTablePro, {
|
|
props: {
|
|
columns,
|
|
data: [row],
|
|
tool: false,
|
|
rowProps: () => ({ onContextmenu }),
|
|
contextMenuOptions: [option],
|
|
onContextMenuClick: select,
|
|
},
|
|
global: { stubs: { teleport: true } },
|
|
})
|
|
const menu = wrapper
|
|
.findAllComponents(NDropdown)
|
|
.find((dropdown) => dropdown.props('trigger') === 'manual')!
|
|
|
|
try {
|
|
const entry = wrapper.get('tbody tr')
|
|
|
|
await entry.trigger('contextmenu')
|
|
expect(onContextmenu).toHaveBeenCalledOnce()
|
|
expect(menu.props('show')).toBe(false)
|
|
|
|
expect(entry.attributes('tabindex')).toBe('0')
|
|
await entry.trigger('keydown', { key: 'F10', shiftKey: true })
|
|
expect(menu.props('show')).toBe(true)
|
|
await wrapper.get('.n-dropdown-option-body').trigger('click')
|
|
expect(select).toHaveBeenCalledExactlyOnceWith('edit', option, {
|
|
row,
|
|
index: 0,
|
|
})
|
|
|
|
await entry.trigger('keydown', { key: 'ContextMenu' })
|
|
expect(menu.props('show')).toBe(true)
|
|
await wrapper.setProps({ data: [{ id: 8, name: 'Ray' }] })
|
|
expect(menu.props('show')).toBe(false)
|
|
const closingOption = wrapper.find('.n-dropdown-option-body')
|
|
|
|
if (closingOption.exists()) await closingOption.trigger('click')
|
|
|
|
expect(select).toHaveBeenCalledOnce()
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('keeps panel props and slots out of the native table while forwarding its own API', () => {
|
|
const wrapper = mount(RTablePro, {
|
|
props: {
|
|
columns,
|
|
tool: false,
|
|
title: 'Panel title',
|
|
scrollX: 640,
|
|
columnStateKey: 'directory',
|
|
},
|
|
attrs: { id: 'directory' },
|
|
slots: { empty: 'Native empty slot', tableFooter: 'Panel footer' },
|
|
})
|
|
|
|
try {
|
|
const native = wrapper.getComponent(NDataTable)
|
|
|
|
expect(wrapper.attributes('id')).toBe('directory')
|
|
expect(wrapper.classes()).toContain('r-table--card')
|
|
expect(native.props('scrollX')).toBe(640)
|
|
expect(native.attributes('columnstatekey')).toBeUndefined()
|
|
expect(native.attributes('id')).toBeUndefined()
|
|
expect(native.text()).toContain('Native empty slot')
|
|
expect(native.text()).not.toContain('Panel footer')
|
|
expect(wrapper.get('.r-table__footer').text()).toBe('Panel footer')
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|
|
|
|
it('respects a changed density prop without reviving an earlier local choice', async () => {
|
|
const wrapper = mount(RTablePro, { props: { columns, size: 'medium' } })
|
|
const native = wrapper.getComponent(NDataTable)
|
|
|
|
try {
|
|
wrapper.getComponent(NDropdown).vm.$emit('select', 'density:small')
|
|
await wrapper.vm.$nextTick()
|
|
expect(native.props('size')).toBe('small')
|
|
await wrapper.setProps({ size: 'large' })
|
|
expect(native.props('size')).toBe('large')
|
|
await wrapper.setProps({ size: 'medium' })
|
|
expect(native.props('size')).toBe('medium')
|
|
} finally {
|
|
wrapper.unmount()
|
|
}
|
|
})
|