-- Test server -> client RPC scenarios. Note: unlike `rpcnotify`, to evaluate

-- `rpcrequest` calls we need the client event loop to be running.

local t = require('test.testutil')

local n = require('test.functional.testnvim')()

local clear, eval = n.clear, n.eval

local eq, neq, run, stop = t.eq, t.neq, n.run, n.stop

local nvim_prog, command, fn = n.nvim_prog, n.command, n.fn

local source, next_msg = n.source, n.next_msg

local ok = t.ok

local api = n.api

local set_session = n.set_session

local pcall_err = t.pcall_err

local assert_alive = n.assert_alive

describe('server -> client', function()

local cid

before_each(function()

clear()

cid = api.nvim_get_chan_info(0).id

end)

it('handles unexpected closed stream while preparing RPC response', function()

source([[

let g:_nvim_args = [v:progpath, '--embed', '--headless', '-n', '-u', 'NONE', '-i', 'NONE', ]

let ch1 = jobstart(g:_nvim_args, {'rpc': v:true})

let child1_ch = rpcrequest(ch1, "nvim_get_chan_info", 0).id

call rpcnotify(ch1, 'nvim_eval', 'rpcrequest('.child1_ch.', "nvim_get_api_info")')

let ch2 = jobstart(g:_nvim_args, {'rpc': v:true})

let child2_ch = rpcrequest(ch2, "nvim_get_chan_info", 0).id

call rpcnotify(ch2, 'nvim_eval', 'rpcrequest('.child2_ch.', "nvim_get_api_info")')

call jobstop(ch1)

]])

assert_alive()

end)

describe('simple call', function()

it('works', function()

local function on_setup()

eq({ 4, 5, 6 }, eval('rpcrequest(' .. cid .. ', "scall", 1, 2, 3)'))

stop()

end

local function on_request(method, args)

end

run(on_request, nil, on_setup)

end)

end)

describe('empty string handling in arrays', function()

-- Because the msgpack encoding for an empty string was interpreted as an

-- error, msgpack arrays with an empty string looked like

-- [..., '', 0, ..., 0] after the conversion, regardless of the array

-- elements following the empty string.

it('works', function()

local function on_setup()

eq({ 1, 2, '', 3, 'asdf' }, eval('rpcrequest(' .. cid .. ', "nstring")'))

stop()

end

local function on_request()

end

run(on_request, nil, on_setup)

end)

end)

describe('recursive call', function()

it('works', function()

local function on_setup()

end

local function on_request(method, args)

end

run(on_request, nil, on_setup)

end)

end)

describe('requests and notifications interleaved', function()

it('does not delay notifications during pending request', function()

local received = false

local function on_setup()

eq('retval', fn.rpcrequest(cid, 'doit'))

stop()

end

local function on_request(method)

end

local function on_notification(method)

end

run(on_request, on_notification, on_setup)

end)

-- This tests the following scenario:

--

-- server->client [request ] (1)

-- client->server [request ] (2) triggered by (1)

-- server->client [notification] (3) triggered by (2)

-- server->client [response ] (4) response to (2)

-- client->server [request ] (4) triggered by (3)

-- server->client [request ] (5) triggered by (4)

-- client->server [response ] (6) response to (1)

--

-- If the above scenario ever happens, the client connection will be closed

-- because (6) is returned after request (5) is sent, and nvim

-- only deals with one server->client request at a time. (In other words,

-- the client cannot send a response to a request that is not at the top

-- of nvim's request stack).

pending('will close connection if not properly synchronized', function()

local function on_setup()

eq('notified!', eval('rpcrequest(' .. cid .. ', "notify")'))

end

local function on_request(method)

end

local function on_notification(method)

end

run(on_request, on_notification, on_setup)

-- ignore disconnect failure, otherwise detected by after_each

clear()

end)

end)

describe('recursive (child) nvim client', function()

before_each(function()

command(

"let vim = rpcstart('"

.. nvim_prog

.. "', ['-u', 'NONE', '-i', 'NONE', '--cmd', 'set noswapfile', '--embed', '--headless'])"

)

neq(0, eval('vim'))

end)

after_each(function()

command('call rpcstop(vim)')

end)

it('can send/receive notifications and make requests', function()

command("call rpcnotify(vim, 'vim_set_current_line', 'SOME TEXT')")

-- Wait for the notification to complete.

command("call rpcrequest(vim, 'vim_eval', '0')")

eq('SOME TEXT', eval("rpcrequest(vim, 'vim_get_current_line')"))

end)

it('can communicate buffers, tabpages, and windows', function()

eq({ 1 }, eval("rpcrequest(vim, 'nvim_list_tabpages')"))

-- Window IDs start at 1000 (LOWEST_WIN_ID in window.h)

eq({ 1000 }, eval("rpcrequest(vim, 'nvim_list_wins')"))

local buf = eval("rpcrequest(vim, 'nvim_list_bufs')")[1]

eq(1, buf)

eval("rpcnotify(vim, 'buffer_set_line', " .. buf .. ", 0, 'SOME TEXT')")

command("call rpcrequest(vim, 'vim_eval', '0')") -- wait

eq('SOME TEXT', eval("rpcrequest(vim, 'buffer_get_line', " .. buf .. ', 0)'))

-- Call get_lines(buf, range [0,0], strict_indexing)

eq({ 'SOME TEXT' }, eval("rpcrequest(vim, 'buffer_get_lines', " .. buf .. ', 0, 1, 1)'))

end)

it('returns an error if the request failed', function()

eq(

"Vim:Error invoking 'does-not-exist' on channel 3:\nInvalid method: does-not-exist",

pcall_err(eval, "rpcrequest(vim, 'does-not-exist')")

)

end)

end)

describe('jobstart()', function()

local jobid

before_each(function()

local channel = api.nvim_get_chan_info(0).id

api.nvim_set_var('channel', channel)

source([[

function! s:OnEvent(id, data, event)

call rpcnotify(g:channel, a:event, 0, a:data)

endfunction

let g:job_opts = {

\ 'on_stderr': function('s:OnEvent'),

\ 'on_exit': function('s:OnEvent'),

\ 'user': 0,

\ 'rpc': v:true

\ }

]])

api.nvim_set_var('args', {

nvim_prog,

'-ll',

'test/functional/api/rpc_fixture.lua',

package.path,

package.cpath,

})

jobid = eval('jobstart(g:args, g:job_opts)')

neq(0, jobid)

end)

after_each(function()

pcall(fn.jobstop, jobid)

end)

if t.skip(t.is_os('win')) then

return

end

it('rpc and text stderr can be combined', function()

local status, rv = pcall(fn.rpcrequest, jobid, 'poll')

if not status then

error(string.format('missing nvim Lua module? (%s)', rv))

end

eq('ok', rv)

fn.rpcnotify(jobid, 'ping')

eq({ 'notification', 'pong', {} }, next_msg())

eq('done!', fn.rpcrequest(jobid, 'write_stderr', 'fluff\n'))

eq({ 'notification', 'stderr', { 0, { 'fluff', '' } } }, next_msg())

pcall(fn.rpcrequest, jobid, 'exit')

eq({ 'notification', 'stderr', { 0, { '' } } }, next_msg())

eq({ 'notification', 'exit', { 0, 0 } }, next_msg())

end)

end)

describe('connecting to another (peer) nvim', function()

local function connect_test(server, mode, address)

end

it('via named pipe', function()

local server = n.new_session(false)

set_session(server)

local address = fn.serverlist()[1]

local first = string.sub(address, 1, 1)

ok(first == '/' or first == '\\')

connect_test(server, 'pipe', address)

end)

it('via ipv4 address', function()

local server = n.new_session(false)

set_session(server)

local status, address = pcall(fn.serverstart, '127.0.0.1:')

if not status then

pending('no ipv4 stack')

end

eq('127.0.0.1:', string.sub(address, 1, 10))

connect_test(server, 'tcp', address)

end)

it('via ipv6 address', function()

local server = n.new_session(false)

set_session(server)

local status, address = pcall(fn.serverstart, '::1:')

if not status then

pending('no ipv6 stack')

end

eq('::1:', string.sub(address, 1, 4))

connect_test(server, 'tcp', address)

end)

it('via hostname', function()

local server = n.new_session(false)

set_session(server)

local address = fn.serverstart('localhost:')

eq('localhost:', string.sub(address, 1, 10))

connect_test(server, 'tcp', address)

end)

it('does not crash on receiving UI events', function()

local server = n.new_session(false)

set_session(server)

local address = fn.serverlist()[1]

local client = n.new_session(true)

set_session(client)

local id = fn.sockconnect('pipe', address, { rpc = true })

fn.rpcrequest(id, 'nvim_ui_attach', 80, 24, {})

assert_alive()

server:close()

client:close()

end)

it('via stdio, with many small flushes does not crash #23781', function()

source([[

let chan = jobstart([v:progpath, '--embed', '--headless', '-n', '-u', 'NONE', '-i', 'NONE'], { 'rpc':v:false })

call chansend(chan, 0Z94)

sleep 50m

call chansend(chan, 0Z00)

call chansend(chan, 0Z01)

call chansend(chan, 0ZAC)

call chansend(chan, 0Z6E76696D5F636F6D6D616E64)

call chansend(chan, 0Z91)

call chansend(chan, 0ZA5)

call chansend(chan, 0Z71616C6C21)

let g:statuses = jobwait([chan])

]])

eq(eval('g:statuses'), { 0 })

assert_alive()

end)

end)

describe('connecting to its own pipe address', function()

it('does not deadlock', function()

local address = fn.serverlist()[1]

local first = string.sub(address, 1, 1)

ok(first == '/' or first == '\\')

local serverpid = fn.getpid()

local id = fn.sockconnect('pipe', address, { rpc = true })

fn.rpcrequest(id, 'nvim_set_current_line', 'hello')

eq('hello', api.nvim_get_current_line())

eq(serverpid, fn.rpcrequest(id, 'nvim_eval', 'getpid()'))

eq(id, fn.rpcrequest(id, 'nvim_get_chan_info', 0).id)

end)

end)

end)