317 lines
10 KiB
TypeScript
317 lines
10 KiB
TypeScript
import { Neovim } from '@chemzqm/neovim'
|
|
import { Command, CodeLens, Disposable, Position, Range, TextEdit } from 'vscode-languageserver-protocol'
|
|
import commands from '../../commands'
|
|
import events from '../../events'
|
|
import CodeLensHandler from '../../handler/codelens/index'
|
|
import CodeLensBuffer, { getCommands } from '../../handler/codelens/buffer'
|
|
import languages from '../../languages'
|
|
import { disposeAll } from '../../util'
|
|
import helper from '../helper'
|
|
import workspace from '../../workspace'
|
|
|
|
let nvim: Neovim
|
|
let codeLens: CodeLensHandler
|
|
let disposables: Disposable[] = []
|
|
let srcId: number
|
|
|
|
jest.setTimeout(10000)
|
|
beforeAll(async () => {
|
|
await helper.setup()
|
|
nvim = helper.nvim
|
|
srcId = await nvim.createNamespace('coc-codelens')
|
|
codeLens = helper.plugin.getHandler().codeLens
|
|
})
|
|
|
|
beforeEach(() => {
|
|
helper.updateConfiguration('codeLens.enable', true)
|
|
})
|
|
|
|
afterAll(async () => {
|
|
await helper.shutdown()
|
|
})
|
|
|
|
afterEach(async () => {
|
|
await helper.reset()
|
|
disposeAll(disposables)
|
|
})
|
|
|
|
async function createBufferWithCodeLens(): Promise<CodeLensBuffer> {
|
|
disposables.push(languages.registerCodeLensProvider([{ language: 'javascript' }], {
|
|
provideCodeLenses: () => {
|
|
return [{
|
|
range: Range.create(0, 0, 0, 1)
|
|
}]
|
|
},
|
|
resolveCodeLens: codeLens => {
|
|
codeLens.command = Command.create('save', '__save', 1, 2, 3)
|
|
return codeLens
|
|
}
|
|
}))
|
|
let doc = await helper.createDocument('e.js')
|
|
await nvim.call('setline', [1, ['a', 'b', 'c']])
|
|
await doc.synchronize()
|
|
await codeLens.checkProvider()
|
|
return codeLens.buffers.getItem(doc.bufnr)
|
|
}
|
|
|
|
describe('codeLenes featrue', () => {
|
|
it('should do codeLenes request and resolve codeLenes', async () => {
|
|
let buf = await createBufferWithCodeLens()
|
|
let doc = await workspace.document
|
|
let codelens = buf.currentCodeLens
|
|
expect(codelens).toBeDefined()
|
|
expect(codelens[0].command).toBeDefined()
|
|
let markers = await helper.getMarkers(doc.bufnr, srcId)
|
|
expect(markers.length).toBe(1)
|
|
})
|
|
|
|
it('should refresh on empty changes', async () => {
|
|
await createBufferWithCodeLens()
|
|
let doc = await workspace.document
|
|
await nvim.call('setline', [1, ['a', 'b', 'c']])
|
|
await doc.synchronize()
|
|
let markers = await helper.getMarkers(doc.bufnr, srcId)
|
|
expect(markers.length).toBe(1)
|
|
})
|
|
|
|
it('should work with empty codeLens', async () => {
|
|
disposables.push(languages.registerCodeLensProvider([{ language: 'javascript' }], {
|
|
provideCodeLenses: () => {
|
|
return []
|
|
}
|
|
}))
|
|
let doc = await helper.createDocument('t.js')
|
|
let buf = codeLens.buffers.getItem(doc.bufnr)
|
|
let codelens = buf.currentCodeLens
|
|
expect(codelens).toBeUndefined()
|
|
})
|
|
|
|
it('should change codeLenes position', async () => {
|
|
let fn = jest.fn()
|
|
helper.updateConfiguration('codeLens.position', 'eol')
|
|
disposables.push(commands.registerCommand('__save', (...args) => {
|
|
fn(...args)
|
|
}))
|
|
disposables.push(languages.registerCodeLensProvider([{ language: 'javascript' }], {
|
|
provideCodeLenses: () => {
|
|
return [{
|
|
range: Range.create(0, 0, 0, 1)
|
|
}]
|
|
},
|
|
resolveCodeLens: codeLens => {
|
|
codeLens.command = Command.create('save', '__save', 1, 2, 3)
|
|
return codeLens
|
|
}
|
|
}))
|
|
let doc = await helper.createDocument('example.js')
|
|
await nvim.call('setline', [1, ['a', 'b', 'c']])
|
|
await codeLens.checkProvider()
|
|
let res = await doc.buffer.getExtMarks(srcId, 0, -1, { details: true })
|
|
expect(res.length).toBeGreaterThan(0)
|
|
let arr = res[0][3]['virt_text']
|
|
expect(arr[0][0]).toBe('save')
|
|
})
|
|
|
|
it('should refresh codeLens on CursorHold', async () => {
|
|
disposables.push(languages.registerCodeLensProvider([{ language: 'javascript' }], {
|
|
provideCodeLenses: document => {
|
|
let n = document.lineCount
|
|
let arr: any[] = []
|
|
for (let i = 0; i <= n - 2; i++) {
|
|
arr.push({
|
|
range: Range.create(i, 0, i, 1),
|
|
command: Command.create('save', '__save', i)
|
|
})
|
|
}
|
|
return arr
|
|
}
|
|
}))
|
|
let doc = await helper.createDocument('example.js')
|
|
await helper.wait(100)
|
|
let markers = await helper.getMarkers(doc.bufnr, srcId)
|
|
await nvim.call('setline', [1, ['a', 'b', 'c']])
|
|
await doc.synchronize()
|
|
await events.fire('CursorHold', [doc.bufnr])
|
|
await helper.wait(200)
|
|
markers = await helper.getMarkers(doc.bufnr, srcId)
|
|
expect(markers.length).toBe(3)
|
|
})
|
|
|
|
it('should cancel codeLenes request on document change', async () => {
|
|
let cancelled = false
|
|
disposables.push(languages.registerCodeLensProvider([{ language: 'javascript' }], {
|
|
provideCodeLenses: (_, token) => {
|
|
return new Promise(resolve => {
|
|
token.onCancellationRequested(() => {
|
|
cancelled = true
|
|
clearTimeout(timer)
|
|
resolve(null)
|
|
})
|
|
let timer = setTimeout(() => {
|
|
resolve([{
|
|
range: Range.create(0, 0, 0, 1)
|
|
}, {
|
|
range: Range.create(1, 0, 1, 1)
|
|
}])
|
|
}, 2000)
|
|
disposables.push({
|
|
dispose: () => {
|
|
clearTimeout(timer)
|
|
}
|
|
})
|
|
})
|
|
},
|
|
resolveCodeLens: codeLens => {
|
|
codeLens.command = Command.create('save', '__save')
|
|
return codeLens
|
|
}
|
|
}))
|
|
let doc = await helper.createDocument('codelens.js')
|
|
await doc.applyEdits([TextEdit.insert(Position.create(0, 0), 'a\nb\nc')])
|
|
expect(cancelled).toBe(true)
|
|
})
|
|
|
|
it('should resolve on CursorMoved', async () => {
|
|
disposables.push(languages.registerCodeLensProvider([{ language: 'javascript' }], {
|
|
provideCodeLenses: () => {
|
|
return [{
|
|
range: Range.create(90, 0, 90, 1)
|
|
}, {
|
|
range: Range.create(91, 0, 91, 1)
|
|
}]
|
|
},
|
|
resolveCodeLens: async codeLens => {
|
|
codeLens.command = Command.create('save', '__save')
|
|
return codeLens
|
|
}
|
|
}))
|
|
let doc = await helper.createDocument('example.js')
|
|
let arr = new Array(100)
|
|
arr.fill('')
|
|
await nvim.call('setline', [1, arr])
|
|
await doc.synchronize()
|
|
await codeLens.checkProvider()
|
|
await nvim.command('normal! gg')
|
|
await nvim.command('normal! G')
|
|
await helper.wait(100)
|
|
let buf = codeLens.buffers.getItem(doc.bufnr)
|
|
let codelens = buf.currentCodeLens
|
|
expect(codelens).toBeDefined()
|
|
expect(codelens[0].command).toBeDefined()
|
|
expect(codelens[1].command).toBeDefined()
|
|
})
|
|
|
|
it('should invoke codeLenes action', async () => {
|
|
let fn = jest.fn()
|
|
disposables.push(commands.registerCommand('__save', (...args) => {
|
|
fn(...args)
|
|
}))
|
|
await createBufferWithCodeLens()
|
|
await helper.doAction('codeLensAction')
|
|
expect(fn).toBeCalledWith(1, 2, 3)
|
|
await nvim.command('normal! G')
|
|
await helper.doAction('codeLensAction')
|
|
})
|
|
|
|
it('should use picker for multiple codeLenses', async () => {
|
|
let fn = jest.fn()
|
|
disposables.push(commands.registerCommand('__save', (...args) => {
|
|
fn(...args)
|
|
}))
|
|
disposables.push(commands.registerCommand('__delete', (...args) => {
|
|
fn(...args)
|
|
}))
|
|
disposables.push(languages.registerCodeLensProvider([{ language: 'javascript' }], {
|
|
provideCodeLenses: () => {
|
|
return [{
|
|
range: Range.create(0, 0, 0, 1),
|
|
command: Command.create('save', '__save', 1, 2, 3)
|
|
}, {
|
|
range: Range.create(0, 1, 0, 2),
|
|
command: Command.create('save', '__delete', 4, 5, 6)
|
|
}]
|
|
}
|
|
}))
|
|
let doc = await helper.createDocument('example.js')
|
|
await nvim.call('setline', [1, ['a', 'b', 'c']])
|
|
await doc.synchronize()
|
|
await codeLens.checkProvider()
|
|
let p = helper.doAction('codeLensAction')
|
|
await helper.waitFloat()
|
|
await nvim.input('<cr>')
|
|
await p
|
|
expect(fn).toBeCalledWith(1, 2, 3)
|
|
})
|
|
|
|
it('should refresh for failed codeLens request', async () => {
|
|
let called = 0
|
|
let fn = jest.fn()
|
|
disposables.push(commands.registerCommand('__save', (...args) => {
|
|
fn(...args)
|
|
}))
|
|
disposables.push(commands.registerCommand('__foo', (...args) => {
|
|
fn(...args)
|
|
}))
|
|
disposables.push(languages.registerCodeLensProvider([{ language: '*' }], {
|
|
provideCodeLenses: () => {
|
|
called++
|
|
if (called == 1) {
|
|
return null
|
|
}
|
|
return [{
|
|
range: Range.create(0, 0, 0, 1),
|
|
command: Command.create('foo', '__foo')
|
|
}]
|
|
}
|
|
}))
|
|
disposables.push(languages.registerCodeLensProvider([{ language: '*' }], {
|
|
provideCodeLenses: () => {
|
|
return [{
|
|
range: Range.create(0, 0, 0, 1),
|
|
command: Command.create('save', '__save')
|
|
}]
|
|
}
|
|
}))
|
|
let doc = await helper.createDocument('example.js')
|
|
await nvim.call('setline', [1, ['a', 'b', 'c']])
|
|
await codeLens.checkProvider()
|
|
let markers = await helper.getMarkers(doc.buffer.id, srcId)
|
|
expect(markers.length).toBeGreaterThan(0)
|
|
let codeLensBuffer = codeLens.buffers.getItem(doc.buffer.id)
|
|
await codeLensBuffer.forceFetch()
|
|
let curr = codeLensBuffer.currentCodeLens
|
|
expect(curr.length).toBeGreaterThan(1)
|
|
})
|
|
|
|
it('should use custom separator & position', async () => {
|
|
helper.updateConfiguration('codeLens.separator', '|')
|
|
helper.updateConfiguration('codeLens.position', 'eol')
|
|
let doc = await helper.createDocument('example.js')
|
|
await nvim.call('setline', [1, ['a', 'b', 'c']])
|
|
await doc.synchronize()
|
|
disposables.push(languages.registerCodeLensProvider([{ language: '*' }], {
|
|
provideCodeLenses: () => {
|
|
return [{
|
|
range: Range.create(0, 0, 1, 0),
|
|
command: Command.create('save', '__save')
|
|
}, {
|
|
range: Range.create(0, 0, 1, 0),
|
|
command: Command.create('save', '__save')
|
|
}]
|
|
}
|
|
}))
|
|
await codeLens.checkProvider()
|
|
let res = await doc.buffer.getExtMarks(srcId, 0, -1, { details: true })
|
|
expect(res.length).toBe(1)
|
|
})
|
|
|
|
it('should get commands from codeLenses', async () => {
|
|
expect(getCommands(1, undefined)).toEqual([])
|
|
let codeLenses = [CodeLens.create(Range.create(0, 0, 0, 0))]
|
|
expect(getCommands(0, codeLenses)).toEqual([])
|
|
codeLenses = [CodeLens.create(Range.create(0, 0, 1, 0)), CodeLens.create(Range.create(2, 0, 3, 0))]
|
|
codeLenses[0].command = Command.create('save', '__save')
|
|
expect(getCommands(0, codeLenses).length).toEqual(1)
|
|
})
|
|
})
|