lua LSP client: initial implementation (#11336)

Mainly configuration and RPC infrastructure can be considered "done". Specific requests and their callbacks will be improved later (and also served by plugins). There are also some TODO:s for the client itself, like incremental updates.

Co-authored by at-tjdevries and at-h-michael, with many review/suggestion contributions.

4 files changed, 1237 insertions, 0 deletions

diff --git a/test/functional/fixtures/lsp-test-rpc-server.lua b/test/functional/fixtures/lsp-test-rpc-server.lua
new file mode 100644
index 0000000000..971e61b072
--- /dev/null
+++ b/test/functional/fixtures/lsp-test-rpc-server.lua
@@ -0,0 +1,424 @@
+local protocol = require 'vim.lsp.protocol'
+
+-- Internal utility methods.
+
+-- TODO replace with a better implementation.
+local function json_encode(data)
+  local status, result = pcall(vim.fn.json_encode, data)
+  if status then
+    return result
+  else
+    return nil, result
+  end
+end
+local function json_decode(data)
+  local status, result = pcall(vim.fn.json_decode, data)
+  if status then
+    return result
+  else
+    return nil, result
+  end
+end
+
+local function message_parts(sep, ...)
+  local parts = {}
+  for i = 1, select("#", ...) do
+    local arg = select(i, ...)
+    if arg ~= nil then
+      table.insert(parts, arg)
+    end
+  end
+  return table.concat(parts, sep)
+end
+
+-- Assert utility methods
+
+local function assert_eq(a, b, ...)
+  if not vim.deep_equal(a, b) then
+    error(message_parts(": ",
+      ..., "assert_eq failed",
+      string.format("left == %q, right == %q", vim.inspect(a), vim.inspect(b))
+    ))
+  end
+end
+
+local function format_message_with_content_length(encoded_message)
+  return table.concat {
+    'Content-Length: '; tostring(#encoded_message); '\r\n\r\n';
+    encoded_message;
+  }
+end
+
+-- Server utility methods.
+
+local function read_message()
+  local line = io.read("*l")
+  local length = line:lower():match("content%-length:%s*(%d+)")
+  return assert(json_decode(io.read(2 + length):sub(2)), "read_message.json_decode")
+end
+
+local function send(payload)
+  io.stdout:write(format_message_with_content_length(json_encode(payload)))
+end
+
+local function respond(id, err, result)
+  assert(type(id) == 'number', "id must be a number")
+  send { jsonrpc = "2.0"; id = id, error = err, result = result }
+end
+
+local function notify(method, params)
+  assert(type(method) == 'string', "method must be a string")
+  send { method = method, params = params or {} }
+end
+
+local function expect_notification(method, params, ...)
+  local message = read_message()
+  assert_eq(method, message.method,
+      ..., "expect_notification", "method")
+  assert_eq(params, message.params,
+      ..., "expect_notification", method, "params")
+  assert_eq({jsonrpc = "2.0"; method=method, params=params}, message,
+      ..., "expect_notification", "message")
+end
+
+local function expect_request(method, callback, ...)
+  local req = read_message()
+  assert_eq(method, req.method,
+      ..., "expect_request", "method")
+  local err, result = callback(req.params)
+  respond(req.id, err, result)
+end
+
+io.stderr:setvbuf("no")
+
+local function skeleton(config)
+  local on_init = assert(config.on_init)
+  local body = assert(config.body)
+  expect_request("initialize", function(params)
+    return nil, on_init(params)
+  end)
+  expect_notification("initialized", {})
+  body()
+  expect_request("shutdown", function()
+    return nil, {}
+  end)
+  expect_notification("exit", nil)
+end
+
+-- The actual tests.
+
+local tests = {}
+
+function tests.basic_init()
+  skeleton {
+    on_init = function(_params)
+      return { capabilities = {} }
+    end;
+    body = function()
+      notify('test')
+    end;
+  }
+end
+
+function tests.basic_check_capabilities()
+  skeleton {
+    on_init = function(params)
+      local expected_capabilities = protocol.make_client_capabilities()
+      assert_eq(params.capabilities, expected_capabilities)
+      return {
+        capabilities = {
+          textDocumentSync = protocol.TextDocumentSyncKind.Full;
+        }
+      }
+    end;
+    body = function()
+    end;
+  }
+end
+
+function tests.basic_finish()
+  skeleton {
+    on_init = function(params)
+      local expected_capabilities = protocol.make_client_capabilities()
+      assert_eq(params.capabilities, expected_capabilities)
+      return {
+        capabilities = {
+          textDocumentSync = protocol.TextDocumentSyncKind.Full;
+        }
+      }
+    end;
+    body = function()
+      expect_notification("finish")
+      notify('finish')
+    end;
+  }
+end
+
+function tests.basic_check_buffer_open()
+  skeleton {
+    on_init = function(params)
+      local expected_capabilities = protocol.make_client_capabilities()
+      assert_eq(params.capabilities, expected_capabilities)
+      return {
+        capabilities = {
+          textDocumentSync = protocol.TextDocumentSyncKind.Full;
+        }
+      }
+    end;
+    body = function()
+      notify('start')
+      expect_notification('textDocument/didOpen', {
+        textDocument = {
+          languageId = "";
+          text = table.concat({"testing"; "123"}, "\n");
+          uri = "file://";
+          version = 0;
+        };
+      })
+      expect_notification("finish")
+      notify('finish')
+    end;
+  }
+end
+
+function tests.basic_check_buffer_open_and_change()
+  skeleton {
+    on_init = function(params)
+      local expected_capabilities = protocol.make_client_capabilities()
+      assert_eq(params.capabilities, expected_capabilities)
+      return {
+        capabilities = {
+          textDocumentSync = protocol.TextDocumentSyncKind.Full;
+        }
+      }
+    end;
+    body = function()
+      notify('start')
+      expect_notification('textDocument/didOpen', {
+        textDocument = {
+          languageId = "";
+          text = table.concat({"testing"; "123"}, "\n");
+          uri = "file://";
+          version = 0;
+        };
+      })
+      expect_notification('textDocument/didChange', {
+        textDocument = {
+          uri = "file://";
+          version = 3;
+        };
+        contentChanges = {
+          { text = table.concat({"testing"; "boop"}, "\n"); };
+        }
+      })
+      expect_notification("finish")
+      notify('finish')
+    end;
+  }
+end
+
+function tests.basic_check_buffer_open_and_change_multi()
+  skeleton {
+    on_init = function(params)
+      local expected_capabilities = protocol.make_client_capabilities()
+      assert_eq(params.capabilities, expected_capabilities)
+      return {
+        capabilities = {
+          textDocumentSync = protocol.TextDocumentSyncKind.Full;
+        }
+      }
+    end;
+    body = function()
+      notify('start')
+      expect_notification('textDocument/didOpen', {
+        textDocument = {
+          languageId = "";
+          text = table.concat({"testing"; "123"}, "\n");
+          uri = "file://";
+          version = 0;
+        };
+      })
+      expect_notification('textDocument/didChange', {
+        textDocument = {
+          uri = "file://";
+          version = 3;
+        };
+        contentChanges = {
+          { text = table.concat({"testing"; "321"}, "\n"); };
+        }
+      })
+      expect_notification('textDocument/didChange', {
+        textDocument = {
+          uri = "file://";
+          version = 4;
+        };
+        contentChanges = {
+          { text = table.concat({"testing"; "boop"}, "\n"); };
+        }
+      })
+      expect_notification("finish")
+      notify('finish')
+    end;
+  }
+end
+
+function tests.basic_check_buffer_open_and_change_multi_and_close()
+  skeleton {
+    on_init = function(params)
+      local expected_capabilities = protocol.make_client_capabilities()
+      assert_eq(params.capabilities, expected_capabilities)
+      return {
+        capabilities = {
+          textDocumentSync = protocol.TextDocumentSyncKind.Full;
+        }
+      }
+    end;
+    body = function()
+      notify('start')
+      expect_notification('textDocument/didOpen', {
+        textDocument = {
+          languageId = "";
+          text = table.concat({"testing"; "123"}, "\n");
+          uri = "file://";
+          version = 0;
+        };
+      })
+      expect_notification('textDocument/didChange', {
+        textDocument = {
+          uri = "file://";
+          version = 3;
+        };
+        contentChanges = {
+          { text = table.concat({"testing"; "321"}, "\n"); };
+        }
+      })
+      expect_notification('textDocument/didChange', {
+        textDocument = {
+          uri = "file://";
+          version = 4;
+        };
+        contentChanges = {
+          { text = table.concat({"testing"; "boop"}, "\n"); };
+        }
+      })
+      expect_notification('textDocument/didClose', {
+        textDocument = {
+          uri = "file://";
+        };
+      })
+      expect_notification("finish")
+      notify('finish')
+    end;
+  }
+end
+
+function tests.basic_check_buffer_open_and_change_incremental()
+  skeleton {
+    on_init = function(params)
+      local expected_capabilities = protocol.make_client_capabilities()
+      assert_eq(params.capabilities, expected_capabilities)
+      return {
+        capabilities = {
+          textDocumentSync = protocol.TextDocumentSyncKind.Incremental;
+        }
+      }
+    end;
+    body = function()
+      notify('start')
+      expect_notification('textDocument/didOpen', {
+        textDocument = {
+          languageId = "";
+          text = table.concat({"testing"; "123"}, "\n");
+          uri = "file://";
+          version = 0;
+        };
+      })
+      expect_notification('textDocument/didChange', {
+        textDocument = {
+          uri = "file://";
+          version = 3;
+        };
+        contentChanges = {
+          {
+            range = {
+              start = { line = 1; character = 0; };
+              ["end"] = { line = 2; character = 0; };
+            };
+            rangeLength = 4;
+            text = "boop\n";
+          };
+        }
+      })
+      expect_notification("finish")
+      notify('finish')
+    end;
+  }
+end
+
+function tests.basic_check_buffer_open_and_change_incremental_editting()
+  skeleton {
+    on_init = function(params)
+      local expected_capabilities = protocol.make_client_capabilities()
+      assert_eq(params.capabilities, expected_capabilities)
+      return {
+        capabilities = {
+          textDocumentSync = protocol.TextDocumentSyncKind.Incremental;
+        }
+      }
+    end;
+    body = function()
+      notify('start')
+      expect_notification('textDocument/didOpen', {
+        textDocument = {
+          languageId = "";
+          text = table.concat({"testing"; "123"}, "\n");
+          uri = "file://";
+          version = 0;
+        };
+      })
+      expect_notification('textDocument/didChange', {
+        textDocument = {
+          uri = "file://";
+          version = 3;
+        };
+        contentChanges = {
+          {
+            range = {
+              start = { line = 0; character = 0; };
+              ["end"] = { line = 1; character = 0; };
+            };
+            rangeLength = 4;
+            text = "testing\n\n";
+          };
+        }
+      })
+      expect_notification("finish")
+      notify('finish')
+    end;
+  }
+end
+
+function tests.invalid_header()
+  io.stdout:write("Content-length: \r\n")
+end
+
+-- Tests will be indexed by TEST_NAME
+
+local kill_timer = vim.loop.new_timer()
+kill_timer:start(_G.TIMEOUT or 1e3, 0, function()
+  kill_timer:stop()
+  kill_timer:close()
+  io.stderr:write("TIMEOUT")
+  os.exit(100)
+end)
+
+local test_name = _G.TEST_NAME -- lualint workaround
+assert(type(test_name) == 'string', 'TEST_NAME must be specified.')
+local status, err = pcall(assert(tests[test_name], "Test not found"))
+kill_timer:stop()
+kill_timer:close()
+if not status then
+  io.stderr:write(err)
+  os.exit(1)
+end
+os.exit(0)
diff --git a/test/functional/lua/uri_spec.lua b/test/functional/lua/uri_spec.lua
new file mode 100644
index 0000000000..19b1eb1f61
--- /dev/null
+++ b/test/functional/lua/uri_spec.lua
@@ -0,0 +1,107 @@
+local helpers = require('test.functional.helpers')(after_each)
+local clear = helpers.clear
+local exec_lua = helpers.exec_lua
+local eq = helpers.eq
+
+describe('URI methods', function()
+  before_each(function()
+    clear()
+  end)
+
+  describe('file path to uri', function()
+    describe('encode Unix file path', function()
+      it('file path includes only ascii charactors', function()
+        exec_lua("filepath = '/Foo/Bar/Baz.txt'")
+
+        eq('file:///Foo/Bar/Baz.txt', exec_lua("return vim.uri_from_fname(filepath)"))
+      end)
+
+      it('file path including white space', function()
+        exec_lua("filepath = '/Foo /Bar/Baz.txt'")
+
+        eq('file:///Foo%20/Bar/Baz.txt', exec_lua("return vim.uri_from_fname(filepath)"))
+      end)
+
+      it('file path including Unicode charactors', function()
+        exec_lua("filepath = '/xy/åäö/ɧ/汉语/↥/🤦/🦄/å/بِيَّ.txt'")
+
+        -- The URI encoding should be case-insensitive
+        eq('file:///xy/%c3%a5%c3%a4%c3%b6/%c9%a7/%e6%b1%89%e8%af%ad/%e2%86%a5/%f0%9f%a4%a6/%f0%9f%a6%84/a%cc%8a/%d8%a8%d9%90%d9%8a%d9%8e%d9%91.txt', exec_lua("return vim.uri_from_fname(filepath)"))
+      end)
+    end)
+
+    describe('encode Windows filepath', function()
+      it('file path includes only ascii charactors', function()
+        exec_lua([[filepath = 'C:\\Foo\\Bar\\Baz.txt']])
+
+        eq('file:///C:/Foo/Bar/Baz.txt', exec_lua("return vim.uri_from_fname(filepath)"))
+      end)
+
+      it('file path including white space', function()
+        exec_lua([[filepath = 'C:\\Foo \\Bar\\Baz.txt']])
+
+        eq('file:///C:/Foo%20/Bar/Baz.txt', exec_lua("return vim.uri_from_fname(filepath)"))
+      end)
+
+      it('file path including Unicode charactors', function()
+        exec_lua([[filepath = 'C:\\xy\\åäö\\ɧ\\汉语\\↥\\🤦\\🦄\\å\\بِيَّ.txt']])
+
+        eq('file:///C:/xy/%c3%a5%c3%a4%c3%b6/%c9%a7/%e6%b1%89%e8%af%ad/%e2%86%a5/%f0%9f%a4%a6/%f0%9f%a6%84/a%cc%8a/%d8%a8%d9%90%d9%8a%d9%8e%d9%91.txt', exec_lua("return vim.uri_from_fname(filepath)"))
+      end)
+    end)
+  end)
+
+  describe('uri to filepath', function()
+    describe('decode Unix file path', function()
+      it('file path includes only ascii charactors', function()
+        exec_lua("uri = 'file:///Foo/Bar/Baz.txt'")
+
+        eq('/Foo/Bar/Baz.txt', exec_lua("return vim.uri_to_fname(uri)"))
+      end)
+
+      it('file path including white space', function()
+        exec_lua("uri = 'file:///Foo%20/Bar/Baz.txt'")
+
+        eq('/Foo /Bar/Baz.txt', exec_lua("return vim.uri_to_fname(uri)"))
+      end)
+
+      it('file path including Unicode charactors', function()
+        local test_case = [[
+        local uri = 'file:///xy/%C3%A5%C3%A4%C3%B6/%C9%A7/%E6%B1%89%E8%AF%AD/%E2%86%A5/%F0%9F%A4%A6/%F0%9F%A6%84/a%CC%8A/%D8%A8%D9%90%D9%8A%D9%8E%D9%91.txt'
+        return vim.uri_to_fname(uri)
+        ]]
+
+        eq('/xy/åäö/ɧ/汉语/↥/🤦/🦄/å/بِيَّ.txt', exec_lua(test_case))
+      end)
+    end)
+
+    describe('decode Windows filepath', function()
+      it('file path includes only ascii charactors', function()
+        local test_case = [[
+        local uri = 'file:///C:/Foo/Bar/Baz.txt'
+        return vim.uri_to_fname(uri)
+        ]]
+
+        eq('C:\\Foo\\Bar\\Baz.txt', exec_lua(test_case))
+      end)
+
+      it('file path including white space', function()
+        local test_case = [[
+        local uri = 'file:///C:/Foo%20/Bar/Baz.txt'
+        return vim.uri_to_fname(uri)
+        ]]
+
+        eq('C:\\Foo \\Bar\\Baz.txt', exec_lua(test_case))
+      end)
+
+      it('file path including Unicode charactors', function()
+        local test_case = [[
+        local uri = 'file:///C:/xy/%C3%A5%C3%A4%C3%B6/%C9%A7/%E6%B1%89%E8%AF%AD/%E2%86%A5/%F0%9F%A4%A6/%F0%9F%A6%84/a%CC%8A/%D8%A8%D9%90%D9%8A%D9%8E%D9%91.txt'
+        return vim.uri_to_fname(uri)
+        ]]
+
+        eq('C:\\xy\\åäö\\ɧ\\汉语\\↥\\🤦\\🦄\\å\\بِيَّ.txt', exec_lua(test_case))
+      end)
+    end)
+  end)
+end)
diff --git a/test/functional/lua/vim_spec.lua b/test/functional/lua/vim_spec.lua
index a25ae1d2c0..028f2dcd52 100644
--- a/test/functional/lua/vim_spec.lua
+++ b/test/functional/lua/vim_spec.lua
@@ -305,6 +305,78 @@ describe('lua stdlib', function()
       pcall_err(exec_lua, [[return vim.pesc(2)]]))
   end)
 
+  it('vim.tbl_keys', function()
+    eq({}, exec_lua("return vim.tbl_keys({})"))
+    for _, v in pairs(exec_lua("return vim.tbl_keys({'a', 'b', 'c'})")) do
+      eq(true, exec_lua("return vim.tbl_contains({ 1, 2, 3 }, ...)", v))
+    end
+    for _, v in pairs(exec_lua("return vim.tbl_keys({a=1, b=2, c=3})")) do
+      eq(true, exec_lua("return vim.tbl_contains({ 'a', 'b', 'c' }, ...)", v))
+    end
+  end)
+
+  it('vim.tbl_values', function()
+    eq({}, exec_lua("return vim.tbl_values({})"))
+    for _, v in pairs(exec_lua("return vim.tbl_values({'a', 'b', 'c'})")) do
+      eq(true, exec_lua("return vim.tbl_contains({ 'a', 'b', 'c' }, ...)", v))
+    end
+    for _, v in pairs(exec_lua("return vim.tbl_values({a=1, b=2, c=3})")) do
+      eq(true, exec_lua("return vim.tbl_contains({ 1, 2, 3 }, ...)", v))
+    end
+  end)
+
+  it('vim.tbl_islist', function()
+    eq(NIL, exec_lua("return vim.tbl_islist({})"))
+    eq(true, exec_lua("return vim.tbl_islist({'a', 'b', 'c'})"))
+    eq(false, exec_lua("return vim.tbl_islist({'a', '32', a='hello', b='baz'})"))
+    eq(false, exec_lua("return vim.tbl_islist({1, a='hello', b='baz'})"))
+    eq(false, exec_lua("return vim.tbl_islist({a='hello', b='baz', 1})"))
+    eq(false, exec_lua("return vim.tbl_islist({1, 2, nil, a='hello'})"))
+  end)
+
+  it('vim.tbl_isempty', function()
+    eq(true, exec_lua("return vim.tbl_isempty({})"))
+    eq(false, exec_lua("return vim.tbl_isempty({ 1, 2, 3 })"))
+    eq(false, exec_lua("return vim.tbl_isempty({a=1, b=2, c=3})"))
+  end)
+
+  it('vim.deep_equal', function()
+    eq(true, exec_lua [[ return vim.deep_equal({a=1}, {a=1}) ]])
+    eq(true, exec_lua [[ return vim.deep_equal({a={b=1}}, {a={b=1}}) ]])
+    eq(true, exec_lua [[ return vim.deep_equal({a={b={nil}}}, {a={b={}}}) ]])
+    eq(true, exec_lua [[ return vim.deep_equal({a=1, [5]=5}, {nil,nil,nil,nil,5,a=1}) ]])
+    eq(false, exec_lua [[ return vim.deep_equal(1, {nil,nil,nil,nil,5,a=1}) ]])
+    eq(false, exec_lua [[ return vim.deep_equal(1, 3) ]])
+    eq(false, exec_lua [[ return vim.deep_equal(nil, 3) ]])
+    eq(false, exec_lua [[ return vim.deep_equal({a=1}, {a=2}) ]])
+  end)
+
+  it('vim.list_extend', function()
+    eq({1,2,3}, exec_lua [[ return vim.list_extend({1}, {2,3}) ]])
+    eq('Error executing lua: .../shared.lua: src must be a table',
+      pcall_err(exec_lua, [[ return vim.list_extend({1}, nil) ]]))
+    eq({1,2}, exec_lua [[ return vim.list_extend({1}, {2;a=1}) ]])
+    eq(true, exec_lua [[ local a = {1} return vim.list_extend(a, {2;a=1}) == a ]])
+  end)
+
+  it('vim.tbl_add_reverse_lookup', function()
+    eq(true, exec_lua [[
+    local a = { A = 1 }
+    vim.tbl_add_reverse_lookup(a)
+    return vim.deep_equal(a, { A = 1; [1] = 'A'; })
+    ]])
+    -- Throw an error for trying to do it twice (run into an existing key)
+    local code = [[
+    local res = {}
+    local a = { A = 1 }
+    vim.tbl_add_reverse_lookup(a)
+    assert(vim.deep_equal(a, { A = 1; [1] = 'A'; }))
+    vim.tbl_add_reverse_lookup(a)
+    ]]
+    matches('Error executing lua: .../shared.lua: The reverse lookup found an existing value for "[1A]" while processing key "[1A]"',
+      pcall_err(exec_lua, code))
+  end)
+
   it('vim.call, vim.fn', function()
     eq(true, exec_lua([[return vim.call('sin', 0.0) == 0.0 ]]))
     eq(true, exec_lua([[return vim.fn.sin(0.0) == 0.0 ]]))
diff --git a/test/functional/plugin/lsp/lsp_spec.lua b/test/functional/plugin/lsp/lsp_spec.lua
new file mode 100644
index 0000000000..cd0974b81c
--- /dev/null
+++ b/test/functional/plugin/lsp/lsp_spec.lua
@@ -0,0 +1,634 @@
+local helpers = require('test.functional.helpers')(after_each)
+
+local clear = helpers.clear
+local exec_lua = helpers.exec_lua
+local eq = helpers.eq
+local NIL = helpers.NIL
+
+-- Use these to get access to a coroutine so that I can run async tests and use
+-- yield.
+local run, stop = helpers.run, helpers.stop
+
+if helpers.pending_win32(pending) then return end
+
+local is_windows = require'luv'.os_uname().sysname == "Windows"
+local lsp_test_rpc_server_file = "test/functional/fixtures/lsp-test-rpc-server.lua"
+if is_windows then
+  lsp_test_rpc_server_file = lsp_test_rpc_server_file:gsub("/", "\\")
+end
+
+local function test_rpc_server_setup(test_name, timeout_ms)
+  exec_lua([=[
+    lsp = require('vim.lsp')
+    local test_name, fixture_filename, timeout = ...
+    TEST_RPC_CLIENT_ID = lsp.start_client {
+      cmd = {
+        vim.api.nvim_get_vvar("progpath"), '-Es', '-u', 'NONE', '--headless',
+        "-c", string.format("lua TEST_NAME = %q", test_name),
+        "-c", string.format("lua TIMEOUT = %d", timeout),
+        "-c", "luafile "..fixture_filename,
+      };
+      callbacks = setmetatable({}, {
+        __index = function(t, method)
+          return function(...)
+            return vim.rpcrequest(1, 'callback', ...)
+          end
+        end;
+      });
+      root_dir = vim.loop.cwd();
+      on_init = function(client, result)
+        TEST_RPC_CLIENT = client
+        vim.rpcrequest(1, "init", result)
+      end;
+      on_exit = function(...)
+        vim.rpcnotify(1, "exit", ...)
+      end;
+    }
+  ]=], test_name, lsp_test_rpc_server_file, timeout_ms or 1e3)
+end
+
+local function test_rpc_server(config)
+  if config.test_name then
+    clear()
+    test_rpc_server_setup(config.test_name, config.timeout_ms or 1e3)
+  end
+  local client = setmetatable({}, {
+    __index = function(_, name)
+      -- Workaround for not being able to yield() inside __index for Lua 5.1 :(
+      -- Otherwise I would just return the value here.
+      return function(...)
+        return exec_lua([=[
+        local name = ...
+        if type(TEST_RPC_CLIENT[name]) == 'function' then
+          return TEST_RPC_CLIENT[name](select(2, ...))
+        else
+          return TEST_RPC_CLIENT[name]
+        end
+        ]=], name, ...)
+      end
+    end;
+  })
+  local code, signal
+  local function on_request(method, args)
+    if method == "init" then
+      if config.on_init then
+        config.on_init(client, unpack(args))
+      end
+      return NIL
+    end
+    if method == 'callback' then
+      if config.on_callback then
+        config.on_callback(unpack(args))
+      end
+    end
+    return NIL
+  end
+  local function on_notify(method, args)
+    if method == 'exit' then
+      code, signal = unpack(args)
+      return stop()
+    end
+  end
+  --  TODO specify timeout?
+  --  run(on_request, on_notify, config.on_setup, 1000)
+  run(on_request, on_notify, config.on_setup)
+  if config.on_exit then
+    config.on_exit(code, signal)
+  end
+  stop()
+  if config.test_name then
+    exec_lua("lsp._vim_exit_handler()")
+  end
+end
+
+describe('Language Client API', function()
+  describe('server_name is specified', function()
+    before_each(function()
+      clear()
+      -- Run an instance of nvim on the file which contains our "scripts".
+      -- Pass TEST_NAME to pick the script.
+      local test_name = "basic_init"
+      exec_lua([=[
+        lsp = require('vim.lsp')
+        local test_name, fixture_filename = ...
+        TEST_RPC_CLIENT_ID = lsp.start_client {
+          cmd = {
+            vim.api.nvim_get_vvar("progpath"), '-Es', '-u', 'NONE', '--headless',
+            "-c", string.format("lua TEST_NAME = %q", test_name),
+            "-c", "luafile "..fixture_filename;
+          };
+          root_dir = vim.loop.cwd();
+        }
+      ]=], test_name, lsp_test_rpc_server_file)
+    end)
+
+    after_each(function()
+      exec_lua("lsp._vim_exit_handler()")
+     -- exec_lua("lsp.stop_all_clients(true)")
+    end)
+
+    describe('start_client and stop_client', function()
+      it('should return true', function()
+        for _ = 1, 20 do
+          helpers.sleep(10)
+          if exec_lua("return #lsp.get_active_clients()") > 0 then
+            break
+          end
+        end
+        eq(1, exec_lua("return #lsp.get_active_clients()"))
+        eq(false, exec_lua("return lsp.get_client_by_id(TEST_RPC_CLIENT_ID) == nil"))
+        eq(false, exec_lua("return lsp.get_client_by_id(TEST_RPC_CLIENT_ID).is_stopped()"))
+        exec_lua("return lsp.get_client_by_id(TEST_RPC_CLIENT_ID).stop()")
+        eq(false, exec_lua("return lsp.get_client_by_id(TEST_RPC_CLIENT_ID).is_stopped()"))
+        for _ = 1, 20 do
+          helpers.sleep(10)
+          if exec_lua("return #lsp.get_active_clients()") == 0 then
+            break
+          end
+        end
+        eq(true, exec_lua("return lsp.get_client_by_id(TEST_RPC_CLIENT_ID) == nil"))
+      end)
+    end)
+  end)
+
+  describe('basic_init test', function()
+    it('should run correctly', function()
+      local expected_callbacks = {
+        {NIL, "test", {}, 1};
+      }
+      test_rpc_server {
+        test_name = "basic_init";
+        on_init = function(client, _init_result)
+          -- client is a dummy object which will queue up commands to be run
+          -- once the server initializes. It can't accept lua callbacks or
+          -- other types that may be unserializable for now.
+          client.stop()
+        end;
+        -- If the program timed out, then code will be nil.
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        -- Note that NIL must be used here.
+        -- on_callback(err, method, result, client_id)
+        on_callback = function(...)
+          eq(table.remove(expected_callbacks), {...})
+        end;
+      }
+    end)
+
+    it('should fail', function()
+      local expected_callbacks = {
+        {NIL, "test", {}, 1};
+      }
+      test_rpc_server {
+        test_name = "basic_init";
+        on_init = function(client)
+          client.notify('test')
+          client.stop()
+        end;
+        on_exit = function(code, signal)
+          eq(1, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(...)
+          eq(table.remove(expected_callbacks), {...}, "expected callback")
+        end;
+      }
+    end)
+
+    it('should succeed with manual shutdown', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+        {NIL, "test", {}, 1};
+      }
+      test_rpc_server {
+        test_name = "basic_init";
+        on_init = function(client)
+          eq(0, client.resolved_capabilities().text_document_did_change)
+          client.request('shutdown')
+          client.notify('exit')
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(...)
+          eq(table.remove(expected_callbacks), {...}, "expected callback")
+        end;
+      }
+    end)
+
+    it('should verify capabilities sent', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+      }
+      test_rpc_server {
+        test_name = "basic_check_capabilities";
+        on_init = function(client)
+          client.stop()
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(...)
+          eq(table.remove(expected_callbacks), {...}, "expected callback")
+        end;
+      }
+    end)
+
+    it('should not send didOpen if the buffer closes before init', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+        {NIL, "finish", {}, 1};
+      }
+      local client
+      test_rpc_server {
+        test_name = "basic_finish";
+        on_setup = function()
+          exec_lua [[
+            BUFFER = vim.api.nvim_create_buf(false, true)
+            vim.api.nvim_buf_set_lines(BUFFER, 0, -1, false, {
+              "testing";
+              "123";
+            })
+          ]]
+          eq(1, exec_lua("return TEST_RPC_CLIENT_ID"))
+          eq(true, exec_lua("return lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID)"))
+          eq(true, exec_lua("return lsp.buf_is_attached(BUFFER, TEST_RPC_CLIENT_ID)"))
+          exec_lua [[
+            vim.api.nvim_command(BUFFER.."bwipeout")
+          ]]
+        end;
+        on_init = function(_client)
+          client = _client
+          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          eq(full_kind, client.resolved_capabilities().text_document_did_change)
+          eq(true, client.resolved_capabilities().text_document_open_close)
+          client.notify('finish')
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(err, method, params, client_id)
+          eq(table.remove(expected_callbacks), {err, method, params, client_id}, "expected callback")
+          if method == 'finish' then
+            client.stop()
+          end
+        end;
+      }
+    end)
+
+    it('should check the body sent attaching before init', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+        {NIL, "finish", {}, 1};
+        {NIL, "start", {}, 1};
+      }
+      local client
+      test_rpc_server {
+        test_name = "basic_check_buffer_open";
+        on_setup = function()
+          exec_lua [[
+            BUFFER = vim.api.nvim_create_buf(false, true)
+            vim.api.nvim_buf_set_lines(BUFFER, 0, -1, false, {
+              "testing";
+              "123";
+            })
+          ]]
+          exec_lua [[
+            assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
+          ]]
+        end;
+        on_init = function(_client)
+          client = _client
+          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          eq(full_kind, client.resolved_capabilities().text_document_did_change)
+          eq(true, client.resolved_capabilities().text_document_open_close)
+          exec_lua [[
+            assert(not lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID), "Shouldn't attach twice")
+          ]]
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(err, method, params, client_id)
+          if method == 'start' then
+            client.notify('finish')
+          end
+          eq(table.remove(expected_callbacks), {err, method, params, client_id}, "expected callback")
+          if method == 'finish' then
+            client.stop()
+          end
+        end;
+      }
+    end)
+
+    it('should check the body sent attaching after init', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+        {NIL, "finish", {}, 1};
+        {NIL, "start", {}, 1};
+      }
+      local client
+      test_rpc_server {
+        test_name = "basic_check_buffer_open";
+        on_setup = function()
+          exec_lua [[
+            BUFFER = vim.api.nvim_create_buf(false, true)
+            vim.api.nvim_buf_set_lines(BUFFER, 0, -1, false, {
+              "testing";
+              "123";
+            })
+          ]]
+        end;
+        on_init = function(_client)
+          client = _client
+          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          eq(full_kind, client.resolved_capabilities().text_document_did_change)
+          eq(true, client.resolved_capabilities().text_document_open_close)
+          exec_lua [[
+            assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
+          ]]
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(err, method, params, client_id)
+          if method == 'start' then
+            client.notify('finish')
+          end
+          eq(table.remove(expected_callbacks), {err, method, params, client_id}, "expected callback")
+          if method == 'finish' then
+            client.stop()
+          end
+        end;
+      }
+    end)
+
+    it('should check the body and didChange full', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+        {NIL, "finish", {}, 1};
+        {NIL, "start", {}, 1};
+      }
+      local client
+      test_rpc_server {
+        test_name = "basic_check_buffer_open_and_change";
+        on_setup = function()
+          exec_lua [[
+            BUFFER = vim.api.nvim_create_buf(false, true)
+            vim.api.nvim_buf_set_lines(BUFFER, 0, -1, false, {
+              "testing";
+              "123";
+            })
+          ]]
+        end;
+        on_init = function(_client)
+          client = _client
+          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          eq(full_kind, client.resolved_capabilities().text_document_did_change)
+          eq(true, client.resolved_capabilities().text_document_open_close)
+          exec_lua [[
+            assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
+          ]]
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(err, method, params, client_id)
+          if method == 'start' then
+            exec_lua [[
+              vim.api.nvim_buf_set_lines(BUFFER, 1, 2, false, {
+                "boop";
+              })
+            ]]
+            client.notify('finish')
+          end
+          eq(table.remove(expected_callbacks), {err, method, params, client_id}, "expected callback")
+          if method == 'finish' then
+            client.stop()
+          end
+        end;
+      }
+    end)
+
+    -- TODO(askhan) we don't support full for now, so we can disable these tests.
+    pending('should check the body and didChange incremental', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+        {NIL, "finish", {}, 1};
+        {NIL, "start", {}, 1};
+      }
+      local client
+      test_rpc_server {
+        test_name = "basic_check_buffer_open_and_change_incremental";
+        on_setup = function()
+          exec_lua [[
+            BUFFER = vim.api.nvim_create_buf(false, true)
+            vim.api.nvim_buf_set_lines(BUFFER, 0, -1, false, {
+              "testing";
+              "123";
+            })
+          ]]
+        end;
+        on_init = function(_client)
+          client = _client
+          local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Incremental")
+          eq(sync_kind, client.resolved_capabilities().text_document_did_change)
+          eq(true, client.resolved_capabilities().text_document_open_close)
+          exec_lua [[
+            assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
+          ]]
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(err, method, params, client_id)
+          if method == 'start' then
+            exec_lua [[
+              vim.api.nvim_buf_set_lines(BUFFER, 1, 2, false, {
+                "boop";
+              })
+            ]]
+            client.notify('finish')
+          end
+          eq(table.remove(expected_callbacks), {err, method, params, client_id}, "expected callback")
+          if method == 'finish' then
+            client.stop()
+          end
+        end;
+      }
+    end)
+
+    -- TODO(askhan) we don't support full for now, so we can disable these tests.
+    pending('should check the body and didChange incremental normal mode editting', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+        {NIL, "finish", {}, 1};
+        {NIL, "start", {}, 1};
+      }
+      local client
+      test_rpc_server {
+        test_name = "basic_check_buffer_open_and_change_incremental_editting";
+        on_setup = function()
+          exec_lua [[
+            BUFFER = vim.api.nvim_create_buf(false, true)
+            vim.api.nvim_buf_set_lines(BUFFER, 0, -1, false, {
+              "testing";
+              "123";
+            })
+          ]]
+        end;
+        on_init = function(_client)
+          client = _client
+          local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Incremental")
+          eq(sync_kind, client.resolved_capabilities().text_document_did_change)
+          eq(true, client.resolved_capabilities().text_document_open_close)
+          exec_lua [[
+            assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
+          ]]
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(err, method, params, client_id)
+          if method == 'start' then
+            helpers.command("normal! 1Go")
+            client.notify('finish')
+          end
+          eq(table.remove(expected_callbacks), {err, method, params, client_id}, "expected callback")
+          if method == 'finish' then
+            client.stop()
+          end
+        end;
+      }
+    end)
+
+    it('should check the body and didChange full with 2 changes', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+        {NIL, "finish", {}, 1};
+        {NIL, "start", {}, 1};
+      }
+      local client
+      test_rpc_server {
+        test_name = "basic_check_buffer_open_and_change_multi";
+        on_setup = function()
+          exec_lua [[
+            BUFFER = vim.api.nvim_create_buf(false, true)
+            vim.api.nvim_buf_set_lines(BUFFER, 0, -1, false, {
+              "testing";
+              "123";
+            })
+          ]]
+        end;
+        on_init = function(_client)
+          client = _client
+          local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          eq(sync_kind, client.resolved_capabilities().text_document_did_change)
+          eq(true, client.resolved_capabilities().text_document_open_close)
+          exec_lua [[
+            assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
+          ]]
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(err, method, params, client_id)
+          if method == 'start' then
+            exec_lua [[
+              vim.api.nvim_buf_set_lines(BUFFER, 1, 2, false, {
+                "321";
+              })
+              vim.api.nvim_buf_set_lines(BUFFER, 1, 2, false, {
+                "boop";
+              })
+            ]]
+            client.notify('finish')
+          end
+          eq(table.remove(expected_callbacks), {err, method, params, client_id}, "expected callback")
+          if method == 'finish' then
+            client.stop()
+          end
+        end;
+      }
+    end)
+
+    it('should check the body and didChange full lifecycle', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+        {NIL, "finish", {}, 1};
+        {NIL, "start", {}, 1};
+      }
+      local client
+      test_rpc_server {
+        test_name = "basic_check_buffer_open_and_change_multi_and_close";
+        on_setup = function()
+          exec_lua [[
+            BUFFER = vim.api.nvim_create_buf(false, true)
+            vim.api.nvim_buf_set_lines(BUFFER, 0, -1, false, {
+              "testing";
+              "123";
+            })
+          ]]
+        end;
+        on_init = function(_client)
+          client = _client
+          local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
+          eq(sync_kind, client.resolved_capabilities().text_document_did_change)
+          eq(true, client.resolved_capabilities().text_document_open_close)
+          exec_lua [[
+            assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
+          ]]
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(err, method, params, client_id)
+          if method == 'start' then
+            exec_lua [[
+              vim.api.nvim_buf_set_lines(BUFFER, 1, 2, false, {
+                "321";
+              })
+              vim.api.nvim_buf_set_lines(BUFFER, 1, 2, false, {
+                "boop";
+              })
+              vim.api.nvim_command(BUFFER.."bwipeout")
+            ]]
+            client.notify('finish')
+          end
+          eq(table.remove(expected_callbacks), {err, method, params, client_id}, "expected callback")
+          if method == 'finish' then
+            client.stop()
+          end
+        end;
+      }
+    end)
+
+  end)
+
+  describe("parsing tests", function()
+    it('should handle invalid content-length correctly', function()
+      local expected_callbacks = {
+        {NIL, "shutdown", {}, 1};
+        {NIL, "finish", {}, 1};
+        {NIL, "start", {}, 1};
+      }
+      local client
+      test_rpc_server {
+        test_name = "invalid_header";
+        on_setup = function()
+        end;
+        on_init = function(_client)
+          client = _client
+          client.stop(true)
+        end;
+        on_exit = function(code, signal)
+          eq(0, code, "exit code") eq(0, signal, "exit signal")
+        end;
+        on_callback = function(err, method, params, client_id)
+          eq(table.remove(expected_callbacks), {err, method, params, client_id}, "expected callback")
+        end;
+      }
+    end)
+
+  end)
+end)