1055 lines
40 KiB
TypeScript
1055 lines
40 KiB
TypeScript
import * as assert from 'assert'
|
|
import path from 'path'
|
|
import { URI } from 'vscode-uri'
|
|
import { LanguageClient, ServerOptions, TransportKind, Middleware, LanguageClientOptions } from '../../language-client/index'
|
|
import { CancellationTokenSource, Color, DocumentSelector, Position, Range, DefinitionRequest, Location, HoverRequest, Hover, CompletionRequest, CompletionTriggerKind, CompletionItem, SignatureHelpRequest, SignatureHelpTriggerKind, SignatureInformation, ParameterInformation, ReferencesRequest, DocumentHighlightRequest, DocumentHighlight, DocumentHighlightKind, CodeActionRequest, CodeAction, WorkDoneProgressBegin, WorkDoneProgressReport, WorkDoneProgressEnd, ProgressToken, DocumentFormattingRequest, TextEdit, DocumentRangeFormattingRequest, DocumentOnTypeFormattingRequest, RenameRequest, WorkspaceEdit, DocumentLinkRequest, DocumentLink, DocumentColorRequest, ColorInformation, ColorPresentation, DeclarationRequest, FoldingRangeRequest, FoldingRange, ImplementationRequest, SelectionRangeRequest, SelectionRange, TypeDefinitionRequest, ProtocolRequestType, CallHierarchyPrepareRequest, CallHierarchyItem, CallHierarchyIncomingCall, CallHierarchyOutgoingCall, SemanticTokensRegistrationType, LinkedEditingRangeRequest, WillCreateFilesRequest, DidCreateFilesNotification, WillRenameFilesRequest, DidRenameFilesNotification, WillDeleteFilesRequest, DidDeleteFilesNotification, TextDocumentEdit, CancellationToken } from 'vscode-languageserver-protocol'
|
|
import { TextDocument } from 'vscode-languageserver-textdocument'
|
|
import helper from '../helper'
|
|
import workspace from '../../workspace'
|
|
|
|
describe('Client integration', () => {
|
|
let client!: LanguageClient
|
|
let middleware: Middleware
|
|
let uri!: string
|
|
let document!: TextDocument
|
|
let tokenSource!: CancellationTokenSource
|
|
const position: Position = Position.create(1, 1)
|
|
const range: Range = Range.create(1, 1, 1, 2)
|
|
|
|
function rangeEqual(range: Range, sl: number, sc: number, el: number, ec: number): void {
|
|
assert.strictEqual(range.start.line, sl)
|
|
assert.strictEqual(range.start.character, sc)
|
|
assert.strictEqual(range.end.line, el)
|
|
assert.strictEqual(range.end.character, ec)
|
|
}
|
|
|
|
function colorEqual(color: Color, red: number, green: number, blue: number, alpha: number): void {
|
|
assert.strictEqual(color.red, red)
|
|
assert.strictEqual(color.green, green)
|
|
assert.strictEqual(color.blue, blue)
|
|
assert.strictEqual(color.alpha, alpha)
|
|
}
|
|
|
|
function uriEqual(actual: string, expected: string): void {
|
|
assert.strictEqual(actual, expected)
|
|
}
|
|
|
|
function isArray<T>(value: Array<T> | undefined | null, clazz: any, length = 1): asserts value is Array<T> {
|
|
assert.ok(Array.isArray(value), `value is array`)
|
|
assert.strictEqual(value!.length, length, 'value has given length')
|
|
if (clazz && typeof clazz.is === 'function') {
|
|
for (let item of value) {
|
|
assert.ok(clazz.is(item))
|
|
}
|
|
}
|
|
}
|
|
|
|
function isDefined<T>(value: T | undefined | null): asserts value is Exclude<T, undefined | null> {
|
|
if (value === undefined || value === null) {
|
|
throw new Error(`Value is null or undefined`)
|
|
}
|
|
}
|
|
|
|
beforeAll(async () => {
|
|
await helper.setup()
|
|
workspace.registerTextDocumentContentProvider('lsptests', {
|
|
provideTextDocumentContent: (_uri: URI) => {
|
|
return [
|
|
'REM @ECHO OFF',
|
|
'cd c:\\source',
|
|
'REM This is the location of the files that you want to sort',
|
|
'FOR %%f IN (*.doc *.txt) DO XCOPY c:\\source\\"%%f" c:\\text /m /y',
|
|
'REM This moves any files with a .doc or',
|
|
'REM .txt extension from c:\\source to c:\\text',
|
|
'REM %%f is a variable',
|
|
'FOR %%f IN (*.jpg *.png *.bmp) DO XCOPY C:\\source\\"%%f" c:\\images /m /y',
|
|
'REM This moves any files with a .jpg, .png,',
|
|
'REM or .bmp extension from c:\\source to c:\\images;;',
|
|
].join('\n')
|
|
}
|
|
})
|
|
|
|
uri = URI.parse('lsptests://localhost/test.bat').toString()
|
|
let doc = await workspace.loadFile(uri.toString())
|
|
document = doc.textDocument
|
|
tokenSource = new CancellationTokenSource()
|
|
const serverModule = path.join(__dirname, './server/testServer.js')
|
|
const serverOptions: ServerOptions = {
|
|
run: { module: serverModule, transport: TransportKind.ipc },
|
|
debug: { module: serverModule, transport: TransportKind.ipc, options: { execArgv: ['--nolazy', '--inspect=6014'] } }
|
|
}
|
|
const documentSelector: DocumentSelector = [{ scheme: 'lsptests' }]
|
|
|
|
middleware = {}
|
|
const clientOptions: LanguageClientOptions = {
|
|
documentSelector, synchronize: {}, initializationOptions: {}, middleware
|
|
}
|
|
|
|
client = new LanguageClient('test svr', 'Test Language Server', serverOptions, clientOptions)
|
|
client.start()
|
|
await client.onReady()
|
|
})
|
|
|
|
afterAll(async () => {
|
|
await client.stop()
|
|
await helper.shutdown()
|
|
})
|
|
|
|
test('InitializeResult', () => {
|
|
let expected = {
|
|
capabilities: {
|
|
textDocumentSync: 1,
|
|
definitionProvider: true,
|
|
hoverProvider: true,
|
|
completionProvider: { resolveProvider: true, triggerCharacters: ['"', ':'] },
|
|
signatureHelpProvider: {
|
|
triggerCharacters: [':'],
|
|
retriggerCharacters: [':']
|
|
},
|
|
referencesProvider: true,
|
|
documentHighlightProvider: true,
|
|
codeActionProvider: {
|
|
resolveProvider: true
|
|
},
|
|
documentFormattingProvider: true,
|
|
documentRangeFormattingProvider: true,
|
|
documentOnTypeFormattingProvider: {
|
|
firstTriggerCharacter: ':'
|
|
},
|
|
renameProvider: {
|
|
prepareProvider: true
|
|
},
|
|
documentLinkProvider: {
|
|
resolveProvider: true
|
|
},
|
|
colorProvider: true,
|
|
declarationProvider: true,
|
|
foldingRangeProvider: true,
|
|
implementationProvider: true,
|
|
selectionRangeProvider: true,
|
|
typeDefinitionProvider: true,
|
|
callHierarchyProvider: true,
|
|
semanticTokensProvider: {
|
|
legend: {
|
|
tokenTypes: [],
|
|
tokenModifiers: []
|
|
},
|
|
range: true,
|
|
full: {
|
|
delta: true
|
|
}
|
|
},
|
|
workspace: {
|
|
fileOperations: {
|
|
didCreate: { filters: [{ scheme: 'file', pattern: { glob: '**/created-static/**{/,/*.txt}' } }] },
|
|
didRename: {
|
|
filters: [
|
|
{ scheme: 'file', pattern: { glob: '**/renamed-static/**/', matches: 'folder' } },
|
|
{ scheme: 'file', pattern: { glob: '**/renamed-static/**/*.txt', matches: 'file' } }
|
|
]
|
|
},
|
|
didDelete: { filters: [{ scheme: 'file', pattern: { glob: '**/deleted-static/**{/,/*.txt}' } }] },
|
|
willCreate: { filters: [{ scheme: 'file', pattern: { glob: '**/created-static/**{/,/*.txt}' } }] },
|
|
willRename: {
|
|
filters: [
|
|
{ scheme: 'file', pattern: { glob: '**/renamed-static/**/', matches: 'folder' } },
|
|
{ scheme: 'file', pattern: { glob: '**/renamed-static/**/*.txt', matches: 'file' } }
|
|
]
|
|
},
|
|
willDelete: { filters: [{ scheme: 'file', pattern: { glob: '**/deleted-static/**{/,/*.txt}' } }] },
|
|
},
|
|
},
|
|
linkedEditingRangeProvider: true
|
|
},
|
|
customResults: {
|
|
hello: 'world'
|
|
}
|
|
}
|
|
assert.deepEqual(client.initializeResult, expected)
|
|
})
|
|
|
|
test('Goto Definition', async () => {
|
|
const provider = client.getFeature(DefinitionRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = (await provider.provideDefinition(document, position, tokenSource.token)) as Location
|
|
assert.strictEqual(Location.is(result), true)
|
|
uriEqual(result.uri, uri)
|
|
rangeEqual(result.range, 0, 0, 0, 1)
|
|
let middlewareCalled = false
|
|
middleware.provideDefinition = (document, position, token, next) => {
|
|
middlewareCalled = true
|
|
return next(document, position, token)
|
|
}
|
|
await provider.provideDefinition(document, position, tokenSource.token)
|
|
middleware.provideDefinition = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
})
|
|
|
|
test('Hover', async () => {
|
|
const provider = client.getFeature(HoverRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = await provider.provideHover(document, position, tokenSource.token)
|
|
assert.ok(Hover.is(result))
|
|
assert.strictEqual((result.contents as any).kind, 'plaintext')
|
|
assert.strictEqual((result.contents as any).value, 'foo')
|
|
let middlewareCalled = false
|
|
middleware.provideHover = (document, position, token, next) => {
|
|
middlewareCalled = true
|
|
return next(document, position, token)
|
|
}
|
|
await provider.provideHover(document, position, tokenSource.token)
|
|
middleware.provideHover = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
})
|
|
|
|
test('Completion', async () => {
|
|
const provider = client.getFeature(CompletionRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = (await provider.provideCompletionItems(document, position, tokenSource.token, { triggerKind: CompletionTriggerKind.Invoked, triggerCharacter: ':' })) as CompletionItem[]
|
|
|
|
isArray(result, CompletionItem)
|
|
const item = result[0]
|
|
assert.strictEqual(item.label, 'item')
|
|
assert.strictEqual(item.insertText, 'text')
|
|
assert.strictEqual(item.detail, undefined)
|
|
isDefined(provider.resolveCompletionItem)
|
|
|
|
const resolved = await provider.resolveCompletionItem(item, tokenSource.token)
|
|
isDefined(resolved)
|
|
assert.strictEqual(resolved.detail, 'detail')
|
|
|
|
let middlewareCalled = 0
|
|
middleware.provideCompletionItem = (document, position, context, token, next) => {
|
|
middlewareCalled++
|
|
return next(document, position, context, token)
|
|
}
|
|
middleware.resolveCompletionItem = (item, token, next) => {
|
|
middlewareCalled++
|
|
return next(item, token)
|
|
}
|
|
await provider.provideCompletionItems(document, position, tokenSource.token, { triggerKind: CompletionTriggerKind.Invoked, triggerCharacter: ':' })
|
|
await provider.resolveCompletionItem(item, tokenSource.token)
|
|
middleware.provideCompletionItem = undefined
|
|
middleware.resolveCompletionItem = undefined
|
|
assert.strictEqual(middlewareCalled, 2)
|
|
})
|
|
|
|
test('SignatureHelpRequest', async () => {
|
|
const provider = client.getFeature(SignatureHelpRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = await provider.provideSignatureHelp(document, position, tokenSource.token,
|
|
{
|
|
isRetrigger: false,
|
|
triggerKind: SignatureHelpTriggerKind.Invoked,
|
|
triggerCharacter: ':'
|
|
}
|
|
)
|
|
|
|
assert.strictEqual(result.activeSignature, 1)
|
|
assert.strictEqual(result.activeParameter, 1)
|
|
isArray(result.signatures, SignatureInformation)
|
|
|
|
const signature = result.signatures[0]
|
|
assert.strictEqual(signature.label, 'label')
|
|
assert.strictEqual(signature.documentation, 'doc')
|
|
isArray(signature.parameters, ParameterInformation)
|
|
|
|
const parameter = signature.parameters[0]
|
|
assert.strictEqual(parameter.label, 'label')
|
|
assert.strictEqual(parameter.documentation, 'doc')
|
|
|
|
let middlewareCalled = false
|
|
middleware.provideSignatureHelp = (d, p, c, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, p, c, t)
|
|
}
|
|
await provider.provideSignatureHelp(document, position, tokenSource.token,
|
|
{
|
|
isRetrigger: false,
|
|
triggerKind: SignatureHelpTriggerKind.Invoked,
|
|
triggerCharacter: ':'
|
|
}
|
|
)
|
|
middleware.provideSignatureHelp = undefined
|
|
assert.ok(middlewareCalled)
|
|
})
|
|
|
|
test('References', async () => {
|
|
const provider = client.getFeature(ReferencesRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = await provider.provideReferences(document, position, {
|
|
includeDeclaration: true
|
|
}, tokenSource.token)
|
|
|
|
isArray(result, Location, 2)
|
|
for (let i = 0; i < result.length; i++) {
|
|
const location = result[i]
|
|
rangeEqual(location.range, i, i, i, i)
|
|
assert.strictEqual(location.uri.toString(), document.uri.toString())
|
|
}
|
|
|
|
let middlewareCalled = false
|
|
middleware.provideReferences = (d, p, c, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, p, c, t)
|
|
}
|
|
await provider.provideReferences(document, position, {
|
|
includeDeclaration: true
|
|
}, tokenSource.token)
|
|
middleware.provideReferences = undefined
|
|
assert.ok(middlewareCalled)
|
|
})
|
|
|
|
test('Document Highlight', async () => {
|
|
const provider = client.getFeature(DocumentHighlightRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = await provider.provideDocumentHighlights(document, position, tokenSource.token)
|
|
|
|
isArray(result, DocumentHighlight, 1)
|
|
|
|
const highlight = result[0]
|
|
assert.strictEqual(highlight.kind, DocumentHighlightKind.Read)
|
|
rangeEqual(highlight.range, 2, 2, 2, 2)
|
|
|
|
let middlewareCalled = false
|
|
middleware.provideDocumentHighlights = (d, p, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, p, t)
|
|
}
|
|
await provider.provideDocumentHighlights(document, position, tokenSource.token)
|
|
middleware.provideDocumentHighlights = undefined
|
|
assert.ok(middlewareCalled)
|
|
})
|
|
|
|
test('Code Actions', async () => {
|
|
const provider = client.getFeature(CodeActionRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = (await provider.provideCodeActions(document, range, {
|
|
diagnostics: []
|
|
}, tokenSource.token)) as CodeAction[]
|
|
|
|
isArray(result, CodeAction)
|
|
const action = result[0]
|
|
assert.strictEqual(action.title, 'title')
|
|
assert.strictEqual(action.command?.title, 'title')
|
|
assert.strictEqual(action.command?.command, 'id')
|
|
|
|
const resolved = (await provider.resolveCodeAction(result[0], tokenSource.token))
|
|
assert.strictEqual(resolved?.title, 'resolved')
|
|
|
|
let middlewareCalled = false
|
|
middleware.provideCodeActions = (d, r, c, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, r, c, t)
|
|
}
|
|
|
|
await provider.provideCodeActions(document, range, { diagnostics: [] }, tokenSource.token)
|
|
middleware.provideCodeActions = undefined
|
|
assert.ok(middlewareCalled)
|
|
|
|
middlewareCalled = false
|
|
middleware.resolveCodeAction = (c, t, n) => {
|
|
middlewareCalled = true
|
|
return n(c, t)
|
|
}
|
|
|
|
await provider.resolveCodeAction!(result[0], tokenSource.token)
|
|
middleware.resolveCodeAction = undefined
|
|
assert.ok(middlewareCalled)
|
|
})
|
|
|
|
test('Progress', async () => {
|
|
const progressToken = 'TEST-PROGRESS-TOKEN'
|
|
const middlewareEvents: Array<WorkDoneProgressBegin | WorkDoneProgressReport | WorkDoneProgressEnd> = []
|
|
let currentProgressResolver: (value: unknown) => void | undefined
|
|
|
|
// Set up middleware that calls the current resolve function when it gets its 'end' progress event.
|
|
middleware.handleWorkDoneProgress = (token: ProgressToken, params, next) => {
|
|
if (token === progressToken) {
|
|
middlewareEvents.push(params)
|
|
if (params.kind === 'end') {
|
|
setImmediate(currentProgressResolver)
|
|
}
|
|
}
|
|
return next(token, params)
|
|
}
|
|
|
|
// Trigger multiple sample progress events.
|
|
for (let i = 0; i < 2; i++) {
|
|
await new Promise<unknown>((resolve, reject) => {
|
|
currentProgressResolver = resolve
|
|
client.sendRequest(
|
|
new ProtocolRequestType<any, null, never, any, any>('testing/sendSampleProgress'),
|
|
{},
|
|
tokenSource.token,
|
|
).catch(reject)
|
|
})
|
|
}
|
|
|
|
middleware.handleWorkDoneProgress = undefined
|
|
|
|
// Ensure all events were handled.
|
|
assert.deepStrictEqual(
|
|
middlewareEvents.map(p => p.kind),
|
|
['begin', 'report', 'end', 'begin', 'report', 'end'],
|
|
)
|
|
})
|
|
|
|
test('Document Formatting', async () => {
|
|
const provider = client.getFeature(DocumentFormattingRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = await provider.provideDocumentFormattingEdits(document, { tabSize: 4, insertSpaces: false }, tokenSource.token)
|
|
|
|
isArray(result, TextEdit)
|
|
const edit = result[0]
|
|
assert.strictEqual(edit.newText, 'insert')
|
|
rangeEqual(edit.range, 0, 0, 0, 0)
|
|
|
|
let middlewareCalled = true
|
|
middleware.provideDocumentFormattingEdits = (d, c, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, c, t)
|
|
}
|
|
await provider.provideDocumentFormattingEdits(document, { tabSize: 4, insertSpaces: false }, tokenSource.token)
|
|
middleware.provideDocumentFormattingEdits = undefined
|
|
assert.ok(middlewareCalled)
|
|
})
|
|
|
|
test('Document Range Formatting', async () => {
|
|
const provider = client.getFeature(DocumentRangeFormattingRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = await provider.provideDocumentRangeFormattingEdits(document, range, { tabSize: 4, insertSpaces: false }, tokenSource.token)
|
|
|
|
isArray(result, TextEdit)
|
|
const edit = result[0]
|
|
assert.strictEqual(edit.newText, '')
|
|
rangeEqual(edit.range, 1, 1, 1, 2)
|
|
|
|
let middlewareCalled = true
|
|
middleware.provideDocumentRangeFormattingEdits = (d, r, c, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, r, c, t)
|
|
}
|
|
await provider.provideDocumentRangeFormattingEdits(document, range, { tabSize: 4, insertSpaces: false }, tokenSource.token)
|
|
middleware.provideDocumentFormattingEdits = undefined
|
|
assert.ok(middlewareCalled)
|
|
})
|
|
|
|
test('Document on Type Formatting', async () => {
|
|
const provider = client.getFeature(DocumentOnTypeFormattingRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = await provider.provideOnTypeFormattingEdits(document, position, 'a', { tabSize: 4, insertSpaces: false }, tokenSource.token)
|
|
|
|
isArray(result, TextEdit)
|
|
const edit = result[0]
|
|
assert.strictEqual(edit.newText, 'replace')
|
|
rangeEqual(edit.range, 2, 2, 2, 3)
|
|
|
|
let middlewareCalled = true
|
|
middleware.provideOnTypeFormattingEdits = (d, p, s, c, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, p, s, c, t)
|
|
}
|
|
await provider.provideOnTypeFormattingEdits(document, position, 'a', { tabSize: 4, insertSpaces: false }, tokenSource.token)
|
|
middleware.provideDocumentFormattingEdits = undefined
|
|
assert.ok(middlewareCalled)
|
|
})
|
|
|
|
test('Rename', async () => {
|
|
const provider = client.getFeature(RenameRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
isDefined(provider.prepareRename)
|
|
const prepareResult = await provider.prepareRename(document, position, tokenSource.token) as Range
|
|
|
|
rangeEqual(prepareResult, 1, 1, 1, 2)
|
|
const renameResult = await provider.provideRenameEdits(document, position, 'newName', tokenSource.token)
|
|
assert.ok(WorkspaceEdit.is(renameResult))
|
|
let middlewareCalled = 0
|
|
middleware.prepareRename = (d, p, t, n) => {
|
|
middlewareCalled++
|
|
return n(d, p, t)
|
|
}
|
|
await provider.prepareRename(document, position, tokenSource.token)
|
|
middleware.prepareRename = undefined
|
|
middleware.provideRenameEdits = (d, p, w, t, n) => {
|
|
middlewareCalled++
|
|
return n(d, p, w, t)
|
|
}
|
|
await provider.provideRenameEdits(document, position, 'newName', tokenSource.token)
|
|
middleware.provideRenameEdits = undefined
|
|
assert.strictEqual(middlewareCalled, 2)
|
|
})
|
|
|
|
test('Document Link', async () => {
|
|
const provider = client.getFeature(DocumentLinkRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = await provider.provideDocumentLinks(document, tokenSource.token)
|
|
|
|
isArray(result, DocumentLink)
|
|
const documentLink = result[0]
|
|
rangeEqual(documentLink.range, 1, 1, 1, 2)
|
|
|
|
let middlewareCalled = 0
|
|
middleware.provideDocumentLinks = (d, t, n) => {
|
|
middlewareCalled++
|
|
return n(d, t)
|
|
}
|
|
await provider.provideDocumentLinks(document, tokenSource.token)
|
|
middleware.provideDocumentLinks = undefined
|
|
|
|
isDefined(provider.resolveDocumentLink)
|
|
const resolved = await provider.resolveDocumentLink(documentLink, tokenSource.token)
|
|
isDefined(resolved.target)
|
|
assert.strictEqual(resolved.target.toString(), URI.file('/target.txt').toString())
|
|
|
|
middleware.resolveDocumentLink = (i, t, n) => {
|
|
middlewareCalled++
|
|
return n(i, t)
|
|
}
|
|
await provider.resolveDocumentLink(documentLink, tokenSource.token)
|
|
middleware.resolveDocumentLink = undefined
|
|
assert.strictEqual(middlewareCalled, 2)
|
|
})
|
|
|
|
test('Document Color', async () => {
|
|
const provider = client.getFeature(DocumentColorRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const colors = await provider.provideDocumentColors(document, tokenSource.token)
|
|
|
|
isArray(colors, ColorInformation)
|
|
const color = colors[0]
|
|
|
|
rangeEqual(color.range, 1, 1, 1, 2)
|
|
colorEqual(color.color, 1, 1, 1, 1)
|
|
|
|
let middlewareCalled = 0
|
|
middleware.provideDocumentColors = (d, t, n) => {
|
|
middlewareCalled++
|
|
return n(d, t)
|
|
}
|
|
await provider.provideDocumentColors(document, tokenSource.token)
|
|
middleware.provideDocumentColors = undefined
|
|
|
|
const presentations = await provider.provideColorPresentations(color.color, { document, range }, tokenSource.token)
|
|
|
|
isArray(presentations, ColorPresentation)
|
|
const presentation = presentations[0]
|
|
assert.strictEqual(presentation.label, 'label')
|
|
|
|
middleware.provideColorPresentations = (c, x, t, n) => {
|
|
middlewareCalled++
|
|
return n(c, x, t)
|
|
}
|
|
await provider.provideColorPresentations(color.color, { document, range }, tokenSource.token)
|
|
middleware.provideColorPresentations = undefined
|
|
assert.strictEqual(middlewareCalled, 2)
|
|
})
|
|
|
|
test('Goto Declaration', async () => {
|
|
const provider = client.getFeature(DeclarationRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = (await provider.provideDeclaration(document, position, tokenSource.token)) as Location
|
|
|
|
uriEqual(result.uri, uri)
|
|
rangeEqual(result.range, 1, 1, 1, 2)
|
|
|
|
let middlewareCalled = false
|
|
middleware.provideDeclaration = (document, position, token, next) => {
|
|
middlewareCalled = true
|
|
return next(document, position, token)
|
|
}
|
|
await provider.provideDeclaration(document, position, tokenSource.token)
|
|
middleware.provideDeclaration = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
})
|
|
|
|
test('Folding Ranges', async () => {
|
|
const provider = client.getFeature(FoldingRangeRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = (await provider.provideFoldingRanges(document, {}, tokenSource.token))
|
|
|
|
isArray(result, FoldingRange, 1)
|
|
const range = result[0]
|
|
assert.strictEqual(range.startLine, 1)
|
|
assert.strictEqual(range.endLine, 2)
|
|
let middlewareCalled = true
|
|
middleware.provideFoldingRanges = (d, c, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, c, t)
|
|
}
|
|
await provider.provideFoldingRanges(document, {}, tokenSource.token)
|
|
middleware.provideFoldingRanges = undefined
|
|
assert.ok(middlewareCalled)
|
|
})
|
|
|
|
test('Goto Implementation', async () => {
|
|
const provider = client.getFeature(ImplementationRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = (await provider.provideImplementation(document, position, tokenSource.token)) as Location
|
|
|
|
uriEqual(result.uri, uri)
|
|
rangeEqual(result.range, 2, 2, 3, 3)
|
|
|
|
let middlewareCalled = false
|
|
middleware.provideImplementation = (document, position, token, next) => {
|
|
middlewareCalled = true
|
|
return next(document, position, token)
|
|
}
|
|
await provider.provideImplementation(document, position, tokenSource.token)
|
|
middleware.provideImplementation = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
})
|
|
|
|
test('Selection Range', async () => {
|
|
const provider = client.getFeature(SelectionRangeRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = (await provider.provideSelectionRanges(document, [position], tokenSource.token))
|
|
|
|
isArray(result, SelectionRange, 1)
|
|
const range = result[0]
|
|
rangeEqual(range.range, 1, 2, 3, 4)
|
|
let middlewareCalled = false
|
|
middleware.provideSelectionRanges = (d, p, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, p, t)
|
|
}
|
|
await provider.provideSelectionRanges(document, [position], tokenSource.token)
|
|
middleware.provideSelectionRanges = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
})
|
|
|
|
test('Type Definition', async () => {
|
|
const provider = client.getFeature(TypeDefinitionRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = (await provider.provideTypeDefinition(document, position, tokenSource.token)) as Location
|
|
|
|
uriEqual(result.uri, uri)
|
|
rangeEqual(result.range, 2, 2, 3, 3)
|
|
|
|
let middlewareCalled = false
|
|
middleware.provideTypeDefinition = (document, position, token, next) => {
|
|
middlewareCalled = true
|
|
return next(document, position, token)
|
|
}
|
|
await provider.provideTypeDefinition(document, position, tokenSource.token)
|
|
middleware.provideTypeDefinition = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
})
|
|
|
|
test('Call Hierarchy', async () => {
|
|
const provider = client.getFeature(CallHierarchyPrepareRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = (await provider.prepareCallHierarchy(document, position, tokenSource.token)) as CallHierarchyItem[]
|
|
expect(result.length).toBe(1)
|
|
|
|
let middlewareCalled = false
|
|
middleware.prepareCallHierarchy = (d, p, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, p, t)
|
|
}
|
|
await provider.prepareCallHierarchy(document, position, tokenSource.token)
|
|
middleware.prepareCallHierarchy = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
|
|
const item = result[0]
|
|
const incoming = (await provider.provideCallHierarchyIncomingCalls(item, tokenSource.token)) as CallHierarchyIncomingCall[]
|
|
expect(incoming.length).toBe(1)
|
|
assert.deepEqual(incoming[0].from, item)
|
|
middlewareCalled = false
|
|
middleware.provideCallHierarchyIncomingCalls = (i, t, n) => {
|
|
middlewareCalled = true
|
|
return n(i, t)
|
|
}
|
|
await provider.provideCallHierarchyIncomingCalls(item, tokenSource.token)
|
|
middleware.provideCallHierarchyIncomingCalls = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
|
|
const outgoing = (await provider.provideCallHierarchyOutgoingCalls(item, tokenSource.token)) as CallHierarchyOutgoingCall[]
|
|
expect(outgoing.length).toBe(1)
|
|
assert.deepEqual(outgoing[0].to, item)
|
|
middlewareCalled = false
|
|
middleware.provideCallHierarchyOutgoingCalls = (i, t, n) => {
|
|
middlewareCalled = true
|
|
return n(i, t)
|
|
}
|
|
await provider.provideCallHierarchyOutgoingCalls(item, tokenSource.token)
|
|
middleware.provideCallHierarchyOutgoingCalls = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
})
|
|
|
|
const referenceFileUri = URI.parse('/dummy-edit')
|
|
function ensureReferenceEdit(edits: WorkspaceEdit, type: string, expectedLines: string[]) {
|
|
// // Ensure the edits are as expected.
|
|
assert.strictEqual(edits.documentChanges?.length, 1)
|
|
const edit = edits.documentChanges[0] as TextDocumentEdit
|
|
assert.strictEqual(edit.edits.length, 1)
|
|
assert.strictEqual(edit.textDocument.uri, referenceFileUri.path)
|
|
assert.strictEqual(edit.edits[0].newText.trim(), `${type}:\n${expectedLines.join('\n')}`.trim())
|
|
}
|
|
async function ensureNotificationReceived(type: string, params: any) {
|
|
const result = await client.sendRequest(
|
|
new ProtocolRequestType<any, any, never, any, any>('testing/lastFileOperationRequest'),
|
|
{},
|
|
tokenSource.token,
|
|
)
|
|
assert.strictEqual(result.type, type)
|
|
assert.deepEqual(result.params, params)
|
|
assert.deepEqual(result, {
|
|
type,
|
|
params
|
|
})
|
|
}
|
|
|
|
const createFiles = [
|
|
'/my/file.txt',
|
|
'/my/file.js',
|
|
'/my/folder/',
|
|
// Static registration for tests is [operation]-static and *.txt
|
|
'/my/created-static/file.txt',
|
|
'/my/created-static/file.js',
|
|
'/my/created-static/folder/',
|
|
// Dynamic registration for tests is [operation]-dynamic and *.js
|
|
'/my/created-dynamic/file.txt',
|
|
'/my/created-dynamic/file.js',
|
|
'/my/created-dynamic/folder/',
|
|
].map(p => URI.file(p))
|
|
|
|
const renameFiles = [
|
|
['/my/file.txt', '/my-new/file.txt'],
|
|
['/my/file.js', '/my-new/file.js'],
|
|
['/my/folder/', '/my-new/folder/'],
|
|
// Static registration for tests is [operation]-static and *.txt
|
|
['/my/renamed-static/file.txt', '/my-new/renamed-static/file.txt'],
|
|
['/my/renamed-static/file.js', '/my-new/renamed-static/file.js'],
|
|
['/my/renamed-static/folder/', '/my-new/renamed-static/folder/'],
|
|
// Dynamic registration for tests is [operation]-dynamic and *.js
|
|
['/my/renamed-dynamic/file.txt', '/my-new/renamed-dynamic/file.txt'],
|
|
['/my/renamed-dynamic/file.js', '/my-new/renamed-dynamic/file.js'],
|
|
['/my/renamed-dynamic/folder/', '/my-new/renamed-dynamic/folder/'],
|
|
].map(([o, n]) => ({ oldUri: URI.file(o), newUri: URI.file(n) }))
|
|
|
|
const deleteFiles = [
|
|
'/my/file.txt',
|
|
'/my/file.js',
|
|
'/my/folder/',
|
|
// Static registration for tests is [operation]-static and *.txt
|
|
'/my/deleted-static/file.txt',
|
|
'/my/deleted-static/file.js',
|
|
'/my/deleted-static/folder/',
|
|
// Dynamic registration for tests is [operation]-dynamic and *.js
|
|
'/my/deleted-dynamic/file.txt',
|
|
'/my/deleted-dynamic/file.js',
|
|
'/my/deleted-dynamic/folder/',
|
|
].map(p => URI.file(p))
|
|
|
|
test('File Operations - Will Create Files', async () => {
|
|
const feature = client.getFeature(WillCreateFilesRequest.method)
|
|
isDefined(feature)
|
|
|
|
const sendCreateRequest = () => new Promise<WorkspaceEdit>(async (resolve, reject) => {
|
|
void feature.send({ token: CancellationToken.None, files: createFiles, waitUntil: resolve })
|
|
// If feature.send didn't call waitUntil synchronously then something went wrong.
|
|
reject(new Error('Feature unexpectedly did not call waitUntil synchronously'))
|
|
})
|
|
|
|
// Send the event and ensure the server responds with an edit referencing the
|
|
// correct files.
|
|
let edits = await sendCreateRequest()
|
|
ensureReferenceEdit(
|
|
edits,
|
|
'WILL CREATE',
|
|
[
|
|
'file:///my/created-static/file.txt',
|
|
'file:///my/created-static/folder/',
|
|
'file:///my/created-dynamic/file.js',
|
|
'file:///my/created-dynamic/folder/',
|
|
],
|
|
)
|
|
|
|
// Add middleware that strips out any folders.
|
|
middleware.workspace = middleware.workspace || {}
|
|
middleware.workspace.willCreateFiles = (event, next) => next({
|
|
...event,
|
|
files: event.files.filter(f => !f.path.endsWith('/')),
|
|
})
|
|
|
|
// Ensure we get the same results minus the folders that the middleware removed.
|
|
edits = await sendCreateRequest()
|
|
ensureReferenceEdit(
|
|
edits,
|
|
'WILL CREATE',
|
|
[
|
|
'file:///my/created-static/file.txt',
|
|
'file:///my/created-dynamic/file.js',
|
|
],
|
|
)
|
|
|
|
middleware.workspace.willCreateFiles = undefined
|
|
})
|
|
|
|
test('File Operations - Did Create Files', async () => {
|
|
const feature = client.getFeature(DidCreateFilesNotification.method)
|
|
isDefined(feature)
|
|
|
|
// Send the event and ensure the server reports the notification was sent.
|
|
await feature.send({ files: createFiles })
|
|
await ensureNotificationReceived(
|
|
'create',
|
|
{
|
|
files: [
|
|
{ uri: 'file:///my/created-static/file.txt' },
|
|
{ uri: 'file:///my/created-static/folder/' },
|
|
{ uri: 'file:///my/created-dynamic/file.js' },
|
|
{ uri: 'file:///my/created-dynamic/folder/' },
|
|
],
|
|
},
|
|
)
|
|
|
|
// Add middleware that strips out any folders.
|
|
middleware.workspace = middleware.workspace || {}
|
|
middleware.workspace.didCreateFiles = (event, next) => next({
|
|
files: event.files.filter(f => !f.path.endsWith('/')),
|
|
})
|
|
|
|
// Ensure we get the same results minus the folders that the middleware removed.
|
|
await feature.send({ files: createFiles })
|
|
await ensureNotificationReceived(
|
|
'create',
|
|
{
|
|
files: [
|
|
{ uri: 'file:///my/created-static/file.txt' },
|
|
{ uri: 'file:///my/created-dynamic/file.js' },
|
|
],
|
|
},
|
|
)
|
|
|
|
middleware.workspace.didCreateFiles = undefined
|
|
})
|
|
|
|
test('File Operations - Will Rename Files', async () => {
|
|
const feature = client.getFeature(WillRenameFilesRequest.method)
|
|
isDefined(feature)
|
|
|
|
const sendRenameRequest = () => new Promise<WorkspaceEdit>(async (resolve, reject) => {
|
|
void feature.send({ files: renameFiles, waitUntil: resolve })
|
|
// If feature.send didn't call waitUntil synchronously then something went wrong.
|
|
reject(new Error('Feature unexpectedly did not call waitUntil synchronously'))
|
|
})
|
|
|
|
// Send the event and ensure the server responds with an edit referencing the
|
|
// correct files.
|
|
let edits = await sendRenameRequest()
|
|
ensureReferenceEdit(
|
|
edits,
|
|
'WILL RENAME',
|
|
[
|
|
'file:///my/renamed-static/file.txt -> file:///my-new/renamed-static/file.txt',
|
|
'file:///my/renamed-static/folder/ -> file:///my-new/renamed-static/folder/',
|
|
'file:///my/renamed-dynamic/file.js -> file:///my-new/renamed-dynamic/file.js',
|
|
'file:///my/renamed-dynamic/folder/ -> file:///my-new/renamed-dynamic/folder/',
|
|
],
|
|
)
|
|
|
|
// Add middleware that strips out any folders.
|
|
middleware.workspace = middleware.workspace || {}
|
|
middleware.workspace.willRenameFiles = (event, next) => next({
|
|
...event,
|
|
files: event.files.filter(f => !f.oldUri.path.endsWith('/')),
|
|
})
|
|
|
|
// Ensure we get the same results minus the folders that the middleware removed.
|
|
edits = await sendRenameRequest()
|
|
ensureReferenceEdit(
|
|
edits,
|
|
'WILL RENAME',
|
|
[
|
|
'file:///my/renamed-static/file.txt -> file:///my-new/renamed-static/file.txt',
|
|
'file:///my/renamed-dynamic/file.js -> file:///my-new/renamed-dynamic/file.js',
|
|
],
|
|
)
|
|
|
|
middleware.workspace.willRenameFiles = undefined
|
|
})
|
|
|
|
test('File Operations - Did Rename Files', async () => {
|
|
const feature = client.getFeature(DidRenameFilesNotification.method)
|
|
isDefined(feature)
|
|
|
|
// Send the event and ensure the server reports the notification was sent.
|
|
await feature.send({ files: renameFiles })
|
|
await ensureNotificationReceived(
|
|
'rename',
|
|
{
|
|
files: [
|
|
{ oldUri: 'file:///my/renamed-static/file.txt', newUri: 'file:///my-new/renamed-static/file.txt' },
|
|
{ oldUri: 'file:///my/renamed-static/folder/', newUri: 'file:///my-new/renamed-static/folder/' },
|
|
{ oldUri: 'file:///my/renamed-dynamic/file.js', newUri: 'file:///my-new/renamed-dynamic/file.js' },
|
|
{ oldUri: 'file:///my/renamed-dynamic/folder/', newUri: 'file:///my-new/renamed-dynamic/folder/' },
|
|
],
|
|
},
|
|
)
|
|
|
|
// Add middleware that strips out any folders.
|
|
middleware.workspace = middleware.workspace || {}
|
|
middleware.workspace.didRenameFiles = (event, next) => next({
|
|
files: event.files.filter(f => !f.oldUri.path.endsWith('/')),
|
|
})
|
|
|
|
// Ensure we get the same results minus the folders that the middleware removed.
|
|
await feature.send({ files: renameFiles })
|
|
await ensureNotificationReceived(
|
|
'rename',
|
|
{
|
|
files: [
|
|
{ oldUri: 'file:///my/renamed-static/file.txt', newUri: 'file:///my-new/renamed-static/file.txt' },
|
|
{ oldUri: 'file:///my/renamed-dynamic/file.js', newUri: 'file:///my-new/renamed-dynamic/file.js' },
|
|
],
|
|
},
|
|
)
|
|
|
|
middleware.workspace.didRenameFiles = undefined
|
|
})
|
|
|
|
test('File Operations - Will Delete Files', async () => {
|
|
const feature = client.getFeature(WillDeleteFilesRequest.method)
|
|
isDefined(feature)
|
|
|
|
const sendDeleteRequest = () => new Promise<WorkspaceEdit>(async (resolve, reject) => {
|
|
void feature.send({ files: deleteFiles, waitUntil: resolve })
|
|
// If feature.send didn't call waitUntil synchronously then something went wrong.
|
|
reject(new Error('Feature unexpectedly did not call waitUntil synchronously'))
|
|
})
|
|
|
|
// Send the event and ensure the server responds with an edit referencing the
|
|
// correct files.
|
|
let edits = await sendDeleteRequest()
|
|
ensureReferenceEdit(
|
|
edits,
|
|
'WILL DELETE',
|
|
[
|
|
'file:///my/deleted-static/file.txt',
|
|
'file:///my/deleted-static/folder/',
|
|
'file:///my/deleted-dynamic/file.js',
|
|
'file:///my/deleted-dynamic/folder/',
|
|
],
|
|
)
|
|
|
|
// Add middleware that strips out any folders.
|
|
middleware.workspace = middleware.workspace || {}
|
|
middleware.workspace.willDeleteFiles = (event, next) => next({
|
|
...event,
|
|
files: event.files.filter(f => !f.path.endsWith('/')),
|
|
})
|
|
|
|
// Ensure we get the same results minus the folders that the middleware removed.
|
|
edits = await sendDeleteRequest()
|
|
ensureReferenceEdit(
|
|
edits,
|
|
'WILL DELETE',
|
|
[
|
|
'file:///my/deleted-static/file.txt',
|
|
'file:///my/deleted-dynamic/file.js',
|
|
],
|
|
)
|
|
|
|
middleware.workspace.willDeleteFiles = undefined
|
|
})
|
|
|
|
test('File Operations - Did Delete Files', async () => {
|
|
const feature = client.getFeature(DidDeleteFilesNotification.method)
|
|
isDefined(feature)
|
|
|
|
// Send the event and ensure the server reports the notification was sent.
|
|
await feature.send({ files: deleteFiles })
|
|
await ensureNotificationReceived(
|
|
'delete',
|
|
{
|
|
files: [
|
|
{ uri: 'file:///my/deleted-static/file.txt' },
|
|
{ uri: 'file:///my/deleted-static/folder/' },
|
|
{ uri: 'file:///my/deleted-dynamic/file.js' },
|
|
{ uri: 'file:///my/deleted-dynamic/folder/' },
|
|
],
|
|
},
|
|
)
|
|
|
|
// Add middleware that strips out any folders.
|
|
middleware.workspace = middleware.workspace || {}
|
|
middleware.workspace.didDeleteFiles = (event, next) => next({
|
|
files: event.files.filter(f => !f.path.endsWith('/')),
|
|
})
|
|
|
|
// Ensure we get the same results minus the folders that the middleware removed.
|
|
await feature.send({ files: deleteFiles })
|
|
await ensureNotificationReceived(
|
|
'delete',
|
|
{
|
|
files: [
|
|
{ uri: 'file:///my/deleted-static/file.txt' },
|
|
{ uri: 'file:///my/deleted-dynamic/file.js' },
|
|
],
|
|
},
|
|
)
|
|
|
|
middleware.workspace.didDeleteFiles = undefined
|
|
})
|
|
|
|
test('Semantic Tokens', async () => {
|
|
const provider = client.getFeature(SemanticTokensRegistrationType.method).getProvider(document)
|
|
const rangeProvider = provider?.range
|
|
isDefined(rangeProvider)
|
|
const rangeResult = await rangeProvider.provideDocumentRangeSemanticTokens(document, range, tokenSource.token)
|
|
assert.ok(rangeResult !== undefined)
|
|
|
|
let middlewareCalled = false
|
|
middleware.provideDocumentRangeSemanticTokens = (d, r, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, r, t)
|
|
}
|
|
await rangeProvider.provideDocumentRangeSemanticTokens(document, range, tokenSource.token)
|
|
middleware.provideDocumentRangeSemanticTokens = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
|
|
const fullProvider = provider?.full
|
|
isDefined(fullProvider)
|
|
const fullResult = await fullProvider.provideDocumentSemanticTokens(document, tokenSource.token)
|
|
assert.ok(fullResult !== undefined)
|
|
|
|
middlewareCalled = false
|
|
middleware.provideDocumentSemanticTokens = (d, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, t)
|
|
}
|
|
await fullProvider.provideDocumentSemanticTokens(document, tokenSource.token)
|
|
middleware.provideDocumentSemanticTokens = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
|
|
middlewareCalled = false
|
|
middleware.provideDocumentSemanticTokensEdits = (d, i, t, n) => {
|
|
middlewareCalled = true
|
|
return n(d, i, t)
|
|
}
|
|
await fullProvider.provideDocumentSemanticTokensEdits!(document, '2', tokenSource.token)
|
|
middleware.provideDocumentSemanticTokensEdits = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
})
|
|
|
|
test('Linked Editing Ranges', async () => {
|
|
const provider = client.getFeature(LinkedEditingRangeRequest.method).getProvider(document)
|
|
isDefined(provider)
|
|
const result = await provider.provideLinkedEditingRanges(document, position, tokenSource.token)
|
|
|
|
isArray(result.ranges, Range, 1)
|
|
rangeEqual(result.ranges[0], 1, 1, 1, 1)
|
|
|
|
let middlewareCalled = false
|
|
middleware.provideLinkedEditingRange = (document, position, token, next) => {
|
|
middlewareCalled = true
|
|
return next(document, position, token)
|
|
}
|
|
await provider.provideLinkedEditingRanges(document, position, tokenSource.token)
|
|
middleware.provideTypeDefinition = undefined
|
|
assert.strictEqual(middlewareCalled, true)
|
|
})
|
|
})
|