#2132 - Support deferred execution for LSP executables, commands, and addresses

1 files changed, 364 insertions, 0 deletions

diff --git a/test/lsp/test_lsp_startup.vader b/test/lsp/test_lsp_startup.vader
new file mode 100644
index 00000000..2fbd32de
--- /dev/null
+++ b/test/lsp/test_lsp_startup.vader
@@ -0,0 +1,364 @@
+Before:
+  Save g:ale_run_synchronously
+
+  let g:ale_run_synchronously = 1
+  unlet! g:ale_run_synchronously_callbacks
+
+  runtime autoload/ale/lsp.vim
+  runtime autoload/ale/lsp_linter.vim
+  runtime autoload/ale/engine.vim
+  runtime autoload/ale/job.vim
+  runtime autoload/ale/socket.vim
+
+  let g:job_map = {}
+  let g:emulate_job_failure = 0
+  let g:next_job_id = 1
+
+  let g:socket_map = {}
+  let g:emulate_socket_failure = 0
+  let g:next_channel_id = 0
+
+  let g:message_buffer = ''
+  let g:calls = []
+
+  function! ale#engine#IsExecutable(buffer, executable) abort
+    return !empty(a:executable)
+  endfunction
+
+  function! ale#job#HasOpenChannel(job_id) abort
+    return has_key(g:job_map, a:job_id)
+  endfunction
+
+  function! ale#job#Stop(job_id) abort
+    if has_key(g:job_map, a:job_id)
+      call remove(g:job_map, a:job_id)
+    endif
+  endfunction
+
+  function! ale#job#Start(command, options) abort
+    if g:emulate_job_failure
+      return 0
+    endif
+
+    let l:job_id = g:next_job_id
+    let g:next_job_id += 1
+    let g:job_map[l:job_id] = [a:command, a:options]
+
+    return l:job_id
+  endfunction
+
+  function! ale#job#SendRaw(job_id, data) abort
+    let g:message_buffer .= a:data
+  endfunction
+
+  function! ale#socket#IsOpen(channel_id) abort
+    return has_key(g:socket_map, a:channel_id)
+  endfunction
+
+  function! ale#socket#Close(channel_id) abort
+    if has_key(g:socket_map, a:channel_id)
+      call remove(g:socket_map, a:channel_id)
+    endif
+  endfunction
+
+  function! ale#socket#Open(address, options) abort
+    if g:emulate_socket_failure
+      return -1
+    endif
+
+    let l:channel_id = g:next_channel_id
+    let g:next_channel_id += 1
+    let g:socket_map[l:channel_id] = [a:address, a:options]
+
+    return l:channel_id
+  endfunction
+
+  function! ale#socket#Send(channel_id, data) abort
+    let g:message_buffer .= a:data
+  endfunction
+
+  function! PopMessages() abort
+    let l:message_list = []
+
+    for l:line in split(g:message_buffer, '\(\r\|\n\|Content-Length\)\+')
+      if l:line[:0] is '{'
+        let l:data = json_decode(l:line)
+
+        call add(l:message_list, l:data)
+      endif
+    endfor
+
+    let g:message_buffer = ''
+
+    return l:message_list
+  endfunction
+
+  function! SendMessage(message) abort
+    let l:conn_id = keys(ale#lsp#GetConnections())[0]
+    let l:body = json_encode(a:message)
+    let l:data = 'Content-Length: ' . strlen(l:body) . "\r\n\r\n" . l:body
+
+    call ale#lsp#HandleMessage(l:conn_id, l:data)
+  endfunction
+
+  function! Start() abort
+    let l:linter = values(ale#linter#GetLintersLoaded())[0][0]
+
+    return ale#lsp_linter#StartLSP(
+    \ bufnr(''),
+    \ l:linter,
+    \ {linter, details -> add(g:calls, [linter.name, details])},
+    \)
+  endfunction
+
+  function! AssertInitSuccess(linter_name, conn_prefix, language, root, command) abort
+    let l:messages = PopMessages()
+
+    if a:linter_name is# 'tsserver'
+      AssertEqual
+      \ [
+      \   {
+      \     'seq': v:null,
+      \     'arguments': {
+      \       'file': expand('%:p'),
+      \     },
+      \     'type': 'request',
+      \     'command': 'open',
+      \   },
+      \ ],
+      \ l:messages
+    else
+      AssertEqual
+      \ [
+      \   {
+      \     'method': 'initialize',
+      \     'jsonrpc': '2.0',
+      \     'id': 1,
+      \     'params': {
+      \       'initializationOptions': {},
+      \       'rootUri': ale#path#ToURI(a:root),
+      \       'capabilities': {},
+      \       'rootPath': a:root,
+      \       'processId': getpid(),
+      \     },
+      \   },
+      \ ],
+      \ l:messages
+
+      call SendMessage({
+      \ 'jsonrpc': '2.0',
+      \ 'id': 1,
+      \ 'result': {
+      \   'capabilities': {
+      \     'renameProvider': v:true,
+      \     'executeCommandProvider': {
+      \       'commands': [],
+      \     },
+      \     'hoverProvider': v:true,
+      \     'documentSymbolProvider': v:true,
+      \     'documentRangeFormattingProvider': v:true,
+      \     'codeLensProvider': {
+      \       'resolveProvider': v:false
+      \     },
+      \     'referencesProvider': v:true,
+      \     'textDocumentSync': 2,
+      \     'documentFormattingProvider': v:true,
+      \     'codeActionProvider': v:true,
+      \     'signatureHelpProvider': {
+      \       'triggerCharacters': ['(', ','],
+      \     },
+      \     'completionProvider': {
+      \       'triggerCharacters': ['.'],
+      \       'resolveProvider': v:false
+      \     },
+      \     'definitionProvider': v:true,
+      \     'experimental': {},
+      \     'documentHighlightProvider': v:true,
+      \     'workspaceSymbolProvider': v:true,
+      \   },
+      \ },
+      \})
+
+      let l:messages = PopMessages()
+
+      AssertEqual
+      \ [
+      \   {
+      \     'method': 'initialized',
+      \     'jsonrpc': '2.0',
+      \     'params': {},
+      \   },
+      \   {
+      \     'method': 'textDocument/didOpen',
+      \     'jsonrpc': '2.0',
+      \     'params': {
+      \       'textDocument': {
+      \         'uri': ale#path#ToURI(expand('%:p')),
+      \         'version': ale#lsp#message#GetNextVersionID() - 1,
+      \         'languageId': a:language,
+      \         'text': "\n",
+      \       },
+      \     },
+      \   },
+      \ ],
+      \ l:messages
+    endif
+
+    AssertEqual
+    \ [
+    \   [
+    \     a:linter_name,
+    \     {
+    \       'connection_id': a:conn_prefix . ':' . a:root,
+    \       'project_root': a:root,
+    \       'buffer': bufnr(''),
+    \       'command': !empty(a:command) ? ale#job#PrepareCommand(bufnr(''), a:command) : '',
+    \     },
+    \   ],
+    \ ],
+    \ g:calls
+  endfunction
+
+  function! AssertInitFailure() abort
+    let l:messages = PopMessages()
+
+    AssertEqual [], l:messages
+    AssertEqual [], g:calls
+  endfunction
+
+  call ale#linter#Reset()
+
+After:
+  Restore
+
+  call ale#linter#Reset()
+  call ale#lsp#ResetConnections()
+
+  unlet! g:job_map
+  unlet! g:emulate_job_failure
+  unlet! g:next_job_id
+
+  unlet! g:socket_map
+  unlet! g:emulate_socket_failure
+  unlet! g:next_channel_id
+
+  unlet! g:message_buffer
+  unlet! g:calls
+
+  delfunction PopMessages
+  delfunction Start
+  delfunction AssertInitSuccess
+  delfunction AssertInitFailure
+
+  runtime autoload/ale/engine.vim
+  runtime autoload/ale/job.vim
+  runtime autoload/ale/socket.vim
+
+Execute(tsserver should be started correctly):
+  runtime ale_linters/typescript/tsserver.vim
+
+  Assert Start()
+  call AssertInitSuccess('tsserver', 'tsserver', '', '', ale#Escape('tsserver'))
+
+Execute(tsserver failures should be handled appropriately):
+  runtime ale_linters/typescript/tsserver.vim
+
+  let g:emulate_job_failure = 1
+
+  Assert !Start()
+  call AssertInitFailure()
+
+Execute(LSP jobs should start correctly):
+  call ale#linter#Define('foobar', {
+  \   'name': 'foo',
+  \   'lsp': 'stdio',
+  \   'executable': 'foo',
+  \   'command': 'foo',
+  \   'project_root': '/foo/bar',
+  \   'initialization_options': {},
+  \})
+
+  Assert Start()
+  call AssertInitSuccess('foo', 'foo', 'foobar', '/foo/bar', 'foo')
+
+Execute(LSP job failures should be handled):
+  call ale#linter#Define('foobar', {
+  \   'name': 'foo',
+  \   'lsp': 'stdio',
+  \   'executable': 'foo',
+  \   'command': 'foo',
+  \   'project_root': '/foo/bar',
+  \   'initialization_options': {},
+  \})
+
+  let g:emulate_job_failure = 1
+
+  Assert !Start()
+  call AssertInitFailure()
+
+Execute(LSP TCP connections should start correctly):
+  call ale#linter#Define('foobar', {
+  \   'name': 'foo',
+  \   'lsp': 'socket',
+  \   'address': 'foo',
+  \   'project_root': '/foo/bar',
+  \   'initialization_options': {},
+  \})
+
+  Assert Start()
+  call AssertInitSuccess('foo', 'foo', 'foobar', '/foo/bar', '')
+
+Execute(LSP TCP connection failures should be handled):
+  call ale#linter#Define('foobar', {
+  \   'name': 'foo',
+  \   'lsp': 'socket',
+  \   'address': 'foo',
+  \   'project_root': '/foo/bar',
+  \   'initialization_options': {},
+  \})
+
+  let g:emulate_socket_failure = 1
+
+  Assert !Start()
+  call AssertInitFailure()
+
+Execute(Deferred executables should be handled correctly):
+  call ale#linter#Define('foobar', {
+  \   'name': 'foo',
+  \   'lsp': 'stdio',
+  \   'executable': {b -> ale#command#Run(b, 'echo', {-> 'foo'})},
+  \   'command': '%e -c',
+  \   'project_root': '/foo/bar',
+  \   'initialization_options': {},
+  \})
+
+  Assert Start()
+  call ale#test#FlushJobs()
+  call AssertInitSuccess('foo', 'foo', 'foobar', '/foo/bar', ale#Escape('foo') . ' -c')
+
+Execute(Deferred commands should be handled correctly):
+  call ale#linter#Define('foobar', {
+  \   'name': 'foo',
+  \   'lsp': 'stdio',
+  \   'executable': 'foo',
+  \   'command': {b -> ale#command#Run(b, 'echo', {-> '%e -c'})},
+  \   'project_root': '/foo/bar',
+  \   'initialization_options': {},
+  \})
+
+  Assert Start()
+  call ale#test#FlushJobs()
+  call AssertInitSuccess('foo', 'foo', 'foobar', '/foo/bar', ale#Escape('foo') . ' -c')
+
+Execute(Deferred addresses should be handled correctly):
+  call ale#linter#Define('foobar', {
+  \   'name': 'foo',
+  \   'lsp': 'socket',
+  \   'address': {b -> ale#command#Run(b, 'echo', {-> 'localhost:1234'})},
+  \   'project_root': '/foo/bar',
+  \   'initialization_options': {},
+  \})
+
+  Assert Start()
+  call ale#test#FlushJobs()
+  call AssertInitSuccess('foo', 'localhost:1234', 'foobar', '/foo/bar', '')