305 lines
8.2 KiB
TypeScript
305 lines
8.2 KiB
TypeScript
import { Neovim } from '@chemzqm/neovim'
|
|
import { Disposable } from 'vscode-languageserver-protocol'
|
|
import BasicList from '../../list/basic'
|
|
import manager from '../../list/manager'
|
|
import ListSession from '../../list/session'
|
|
import { ListItem, IList } from '../../types'
|
|
import { disposeAll } from '../../util'
|
|
import helper from '../helper'
|
|
|
|
let labels: string[] = []
|
|
let lastItem: string
|
|
let lastItems: ListItem[]
|
|
|
|
class SimpleList extends BasicList {
|
|
public name = 'simple'
|
|
public detail = 'detail'
|
|
public options = [{
|
|
name: 'foo',
|
|
description: 'foo'
|
|
}]
|
|
constructor(nvim: Neovim) {
|
|
super(nvim)
|
|
this.addAction('open', item => {
|
|
lastItem = item.label
|
|
})
|
|
this.addMultipleAction('multiple', items => {
|
|
lastItems = items
|
|
})
|
|
this.addAction('parallel', async () => {
|
|
await helper.wait(100)
|
|
}, { parallel: true })
|
|
this.addAction('reload', item => {
|
|
lastItem = item.label
|
|
}, { persist: true, reload: true })
|
|
}
|
|
public loadItems(): Promise<ListItem[]> {
|
|
return Promise.resolve(labels.map(s => {
|
|
return { label: s } as ListItem
|
|
}))
|
|
}
|
|
}
|
|
|
|
let nvim: Neovim
|
|
let disposables: Disposable[] = []
|
|
beforeAll(async () => {
|
|
await helper.setup()
|
|
nvim = helper.nvim
|
|
})
|
|
|
|
afterAll(async () => {
|
|
await helper.shutdown()
|
|
})
|
|
|
|
afterEach(async () => {
|
|
disposeAll(disposables)
|
|
manager.reset()
|
|
await helper.reset()
|
|
})
|
|
|
|
describe('list session', () => {
|
|
describe('doDefaultAction()', () => {
|
|
it('should throw error when default action does not exist', async () => {
|
|
labels = ['a', 'b', 'c']
|
|
let list = new SimpleList(nvim)
|
|
list.defaultAction = 'foo'
|
|
let len = list.actions.length
|
|
list.actions.splice(0, len)
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', 'simple'])
|
|
let ui = manager.session.ui
|
|
await ui.ready
|
|
let err
|
|
try {
|
|
await manager.session.first()
|
|
} catch (e) {
|
|
err = e
|
|
}
|
|
expect(err).toBeDefined()
|
|
err = null
|
|
try {
|
|
await manager.session.last()
|
|
} catch (e) {
|
|
err = e
|
|
}
|
|
expect(err).toBeDefined()
|
|
})
|
|
})
|
|
|
|
describe('doItemAction()', () => {
|
|
it('should invoke multiple action', async () => {
|
|
labels = ['a', 'b', 'c']
|
|
let list = new SimpleList(nvim)
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', 'simple'])
|
|
let ui = manager.session.ui
|
|
await ui.ready
|
|
await ui.selectAll()
|
|
await manager.doAction('multiple')
|
|
expect(lastItems.length).toBe(3)
|
|
lastItems = undefined
|
|
})
|
|
|
|
it('should invoke parallel action', async () => {
|
|
labels = ['a', 'b', 'c']
|
|
let list = new SimpleList(nvim)
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', 'simple'])
|
|
let ui = manager.session.ui
|
|
await ui.ready
|
|
await ui.selectAll()
|
|
let d = Date.now()
|
|
await manager.doAction('parallel')
|
|
expect(Date.now() - d).toBeLessThan(300)
|
|
})
|
|
|
|
it('should invoke reload action', async () => {
|
|
labels = ['a', 'b', 'c']
|
|
let list = new SimpleList(nvim)
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', 'simple'])
|
|
let ui = manager.session.ui
|
|
await ui.ready
|
|
labels = ['d', 'e']
|
|
await manager.doAction('reload')
|
|
await helper.wait(50)
|
|
let buf = await nvim.buffer
|
|
let lines = await buf.lines
|
|
expect(lines).toEqual(['d', 'e'])
|
|
})
|
|
})
|
|
|
|
describe('reloadItems()', () => {
|
|
it('should not reload items when window is hidden', async () => {
|
|
let fn = jest.fn()
|
|
let list: IList = {
|
|
name: 'reload',
|
|
defaultAction: 'open',
|
|
actions: [{
|
|
name: 'open',
|
|
execute: () => {}
|
|
}],
|
|
loadItems: () => {
|
|
fn()
|
|
return Promise.resolve([])
|
|
}
|
|
}
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', 'reload'])
|
|
let ui = manager.session.ui
|
|
await ui.ready
|
|
await manager.cancel(true)
|
|
let ses = manager.getSession('reload')
|
|
await ses.reloadItems()
|
|
expect(fn).toBeCalledTimes(1)
|
|
})
|
|
})
|
|
|
|
describe('resume()', () => {
|
|
it('should do preview on resume', async () => {
|
|
labels = ['a', 'b', 'c']
|
|
let lastItem
|
|
let list = new SimpleList(nvim)
|
|
list.actions.push({
|
|
name: 'preview',
|
|
execute: item => {
|
|
lastItem = item
|
|
}
|
|
})
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', '--auto-preview', 'simple'])
|
|
let ui = manager.session.ui
|
|
await ui.ready
|
|
await ui.selectLines(1, 2)
|
|
await helper.wait(50)
|
|
await nvim.call('coc#window#close', [ui.winid])
|
|
await helper.wait(100)
|
|
await manager.session.resume()
|
|
await helper.wait(100)
|
|
expect(lastItem).toBeDefined()
|
|
})
|
|
})
|
|
|
|
describe('jumpBack()', () => {
|
|
it('should jump back', async () => {
|
|
let win = await nvim.window
|
|
labels = ['a', 'b', 'c']
|
|
let list = new SimpleList(nvim)
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', 'simple'])
|
|
let ui = manager.session.ui
|
|
await ui.ready
|
|
manager.session.jumpBack()
|
|
await helper.wait(50)
|
|
let winid = await nvim.call('win_getid')
|
|
expect(winid).toBe(win.id)
|
|
})
|
|
})
|
|
|
|
describe('doNumberSelect()', () => {
|
|
async function create(len: number): Promise<ListSession> {
|
|
labels = []
|
|
for (let i = 0; i < len; i++) {
|
|
let code = 'a'.charCodeAt(0) + i
|
|
labels.push(String.fromCharCode(code))
|
|
}
|
|
let list = new SimpleList(nvim)
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', '--number-select', 'simple'])
|
|
let ui = manager.session.ui
|
|
await ui.ready
|
|
return manager.session
|
|
}
|
|
|
|
it('should return false for invalid number', async () => {
|
|
let session = await create(5)
|
|
let res = await session.doNumberSelect('a')
|
|
expect(res).toBe(false)
|
|
res = await session.doNumberSelect('8')
|
|
expect(res).toBe(false)
|
|
})
|
|
|
|
it('should consider 0 as 10', async () => {
|
|
let session = await create(15)
|
|
let res = await session.doNumberSelect('0')
|
|
expect(res).toBe(true)
|
|
expect(lastItem).toBe('j')
|
|
})
|
|
})
|
|
})
|
|
|
|
describe('showHelp()', () => {
|
|
it('should show description and options in help', async () => {
|
|
labels = ['a', 'b', 'c']
|
|
let list = new SimpleList(nvim)
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', 'simple'])
|
|
let ui = manager.session.ui
|
|
await ui.ready
|
|
await manager.session.showHelp()
|
|
let lines = await nvim.call('getline', [1, '$'])
|
|
expect(lines.indexOf('DESCRIPTION')).toBeGreaterThan(0)
|
|
expect(lines.indexOf('ARGUMENTS')).toBeGreaterThan(0)
|
|
})
|
|
})
|
|
|
|
describe('chooseAction()', () => {
|
|
it('should filter actions not have shortcuts', async () => {
|
|
labels = ['a', 'b', 'c']
|
|
let fn = jest.fn()
|
|
let list = new SimpleList(nvim)
|
|
list.actions.push({
|
|
name: 'a',
|
|
execute: () => {
|
|
fn()
|
|
}
|
|
})
|
|
list.actions.push({
|
|
name: 'b',
|
|
execute: () => {
|
|
}
|
|
})
|
|
list.actions.push({
|
|
name: 'ab',
|
|
execute: () => {
|
|
}
|
|
})
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', 'simple'])
|
|
await manager.session.ui.ready
|
|
let p = manager.session.chooseAction()
|
|
await helper.wait(50)
|
|
await nvim.input('a')
|
|
await p
|
|
expect(fn).toBeCalled()
|
|
})
|
|
|
|
it('should choose action by menu picker', async () => {
|
|
helper.updateConfiguration('list.menuAction', true)
|
|
labels = ['a', 'b', 'c']
|
|
let fn = jest.fn()
|
|
let list = new SimpleList(nvim)
|
|
let len = list.actions.length
|
|
list.actions.splice(0, len)
|
|
list.actions.push({
|
|
name: 'a',
|
|
execute: () => {
|
|
fn()
|
|
}
|
|
})
|
|
list.actions.push({
|
|
name: 'b',
|
|
execute: () => {
|
|
fn()
|
|
}
|
|
})
|
|
disposables.push(manager.registerList(list))
|
|
await manager.start(['--normal', 'simple'])
|
|
await manager.session.ui.ready
|
|
let p = manager.session.chooseAction()
|
|
await helper.wait(100)
|
|
await nvim.input('<cr>')
|
|
await p
|
|
})
|
|
})
|