neovim/test/functional/core/job_spec.lua

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1256 lines
42 KiB
Lua
Raw Normal View History

local t = require('test.testutil')
local n = require('test.functional.testnvim')()
local Screen = require('test.functional.ui.screen')
local tt = require('test.functional.testterm')
local clear = n.clear
local eq = t.eq
local eval = n.eval
local exc_exec = n.exc_exec
local feed_command = n.feed_command
local feed = n.feed
local insert = n.insert
local neq = t.neq
local next_msg = n.next_msg
local testprg = n.testprg
local ok = t.ok
local source = n.source
local write_file = t.write_file
local mkdir = t.mkdir
local rmdir = n.rmdir
local assert_alive = n.assert_alive
local command = n.command
local fn = n.fn
local os_kill = n.os_kill
local retry = t.retry
local api = n.api
local NIL = vim.NIL
local poke_eventloop = n.poke_eventloop
local get_pathsep = n.get_pathsep
local pathroot = n.pathroot
local exec_lua = n.exec_lua
local nvim_set = n.nvim_set
local expect_twostreams = n.expect_twostreams
local expect_msg_seq = n.expect_msg_seq
local pcall_err = t.pcall_err
local matches = t.matches
local skip = t.skip
local is_os = t.is_os
describe('jobs', function()
local channel
before_each(function()
clear()
2018-11-09 07:55:47 -07:00
channel = api.nvim_get_chan_info(0).id
api.nvim_set_var('channel', channel)
source([[
function! Normalize(data) abort
" Windows: remove ^M and term escape sequences
return type([]) == type(a:data)
\ ? map(a:data, 'substitute(substitute(v:val, "\r", "", "g"), "\x1b\\%(\\]\\d\\+;.\\{-}\x07\\|\\[.\\{-}[\x40-\x7E]\\)", "", "g")')
\ : a:data
endfunction
2017-06-10 06:25:23 -07:00
function! OnEvent(id, data, event) dict
let userdata = get(self, 'user')
let data = Normalize(a:data)
call rpcnotify(g:channel, a:event, userdata, data)
endfunction
let g:job_opts = {
2017-06-10 06:25:23 -07:00
\ 'on_stdout': function('OnEvent'),
\ 'on_exit': function('OnEvent'),
\ 'user': 0
\ }
]])
end)
it('must specify env option as a dict', function()
command('let g:job_opts.env = v:true')
local _, err = pcall(function()
if is_os('win') then
command("let j = jobstart('set', g:job_opts)")
else
command("let j = jobstart('env', g:job_opts)")
end
end)
matches('E475: Invalid argument: env', err)
end)
2018-11-09 07:55:47 -07:00
it('append environment #env', function()
command("let $VAR = 'abc'")
command("let $TOTO = 'goodbye world'")
command("let g:job_opts.env = {'TOTO': 'hello world'}")
if is_os('win') then
command([[call jobstart('echo %TOTO% %VAR%', g:job_opts)]])
2018-11-09 07:55:47 -07:00
else
command([[call jobstart('echo $TOTO $VAR', g:job_opts)]])
2018-11-09 07:55:47 -07:00
end
expect_msg_seq({
{ 'notification', 'stdout', { 0, { 'hello world abc' } } },
{ 'notification', 'stdout', { 0, { '', '' } } },
}, {
{ 'notification', 'stdout', { 0, { 'hello world abc', '' } } },
{ 'notification', 'stdout', { 0, { '' } } },
})
2018-11-09 07:55:47 -07:00
end)
it('append environment with pty #env', function()
command("let $VAR = 'abc'")
command("let $TOTO = 'goodbye world'")
command('let g:job_opts.pty = v:true')
command("let g:job_opts.env = {'TOTO': 'hello world'}")
if is_os('win') then
command([[call jobstart('echo %TOTO% %VAR%', g:job_opts)]])
else
command([[call jobstart('echo $TOTO $VAR', g:job_opts)]])
end
expect_msg_seq({
{ 'notification', 'stdout', { 0, { 'hello world abc' } } },
{ 'notification', 'stdout', { 0, { '', '' } } },
}, {
{ 'notification', 'stdout', { 0, { 'hello world abc', '' } } },
{ 'notification', 'stdout', { 0, { '' } } },
})
end)
2018-11-09 07:55:47 -07:00
it('replace environment #env', function()
command("let $VAR = 'abc'")
command("let $TOTO = 'goodbye world'")
command("let g:job_opts.env = {'TOTO': 'hello world'}")
command('let g:job_opts.clear_env = 1')
2018-11-09 07:55:47 -07:00
-- libuv ensures that certain "required" environment variables are
-- preserved if the user doesn't provide them in a custom environment
-- https://github.com/libuv/libuv/blob/635e0ce6073c5fbc96040e336b364c061441b54b/src/win/process.c#L672
-- https://github.com/libuv/libuv/blob/635e0ce6073c5fbc96040e336b364c061441b54b/src/win/process.c#L48-L60
--
-- Rather than expecting a completely empty environment, ensure that $VAR
-- is *not* in the environment but $TOTO is.
if is_os('win') then
command([[call jobstart('echo %TOTO% %VAR%', g:job_opts)]])
2018-11-09 07:55:47 -07:00
expect_msg_seq({
{ 'notification', 'stdout', { 0, { 'hello world %VAR%', '' } } },
})
else
command('set shell=/bin/sh')
command([[call jobstart('echo $TOTO $VAR', g:job_opts)]])
2018-11-09 07:55:47 -07:00
expect_msg_seq({
{ 'notification', 'stdout', { 0, { 'hello world', '' } } },
})
end
end)
it('handles case-insensitively matching #env vars', function()
command("let $TOTO = 'abc'")
-- Since $Toto is being set in the job, it should take precedence over the
-- global $TOTO on Windows
command("let g:job_opts = {'env': {'Toto': 'def'}, 'stdout_buffered': v:true}")
if is_os('win') then
command([[let j = jobstart('set | find /I "toto="', g:job_opts)]])
else
command([[let j = jobstart('env | grep -i toto=', g:job_opts)]])
end
command('call jobwait([j])')
command('let g:output = Normalize(g:job_opts.stdout)')
local actual = eval('g:output')
local expected
if is_os('win') then
-- Toto is normalized to TOTO so we can detect duplicates, and because
-- Windows doesn't care about case
expected = { 'TOTO=def', '' }
else
expected = { 'TOTO=abc', 'Toto=def', '' }
end
table.sort(actual)
table.sort(expected)
eq(expected, actual)
end)
it('uses &shell and &shellcmdflag if passed a string', function()
command("let $VAR = 'abc'")
if is_os('win') then
command("let j = jobstart('echo %VAR%', g:job_opts)")
else
command("let j = jobstart('echo $VAR', g:job_opts)")
end
eq({ 'notification', 'stdout', { 0, { 'abc', '' } } }, next_msg())
2017-06-10 06:25:23 -07:00
eq({ 'notification', 'stdout', { 0, { '' } } }, next_msg())
eq({ 'notification', 'exit', { 0, 0 } }, next_msg())
end)
it('changes to given / directory', function()
command("let g:job_opts.cwd = '/'")
if is_os('win') then
command("let j = jobstart('cd', g:job_opts)")
else
command("let j = jobstart('pwd', g:job_opts)")
end
eq({ 'notification', 'stdout', { 0, { pathroot(), '' } } }, next_msg())
2017-06-10 06:25:23 -07:00
eq({ 'notification', 'stdout', { 0, { '' } } }, next_msg())
eq({ 'notification', 'exit', { 0, 0 } }, next_msg())
end)
it('changes to given `cwd` directory', function()
local dir = eval('resolve(tempname())'):gsub('/', get_pathsep())
mkdir(dir)
command("let g:job_opts.cwd = '" .. dir .. "'")
if is_os('win') then
command("let j = jobstart('cd', g:job_opts)")
else
command("let j = jobstart('pwd', g:job_opts)")
end
expect_msg_seq(
{
{ 'notification', 'stdout', { 0, { dir, '' } } },
{ 'notification', 'stdout', { 0, { '' } } },
{ 'notification', 'exit', { 0, 0 } },
},
-- Alternative sequence:
{
{ 'notification', 'stdout', { 0, { dir } } },
{ 'notification', 'stdout', { 0, { '', '' } } },
{ 'notification', 'stdout', { 0, { '' } } },
{ 'notification', 'exit', { 0, 0 } },
}
)
rmdir(dir)
end)
it('fails to change to invalid `cwd`', function()
local dir = eval('resolve(tempname())."-bogus"')
local _, err = pcall(function()
command("let g:job_opts.cwd = '" .. dir .. "'")
if is_os('win') then
command("let j = jobstart('cd', g:job_opts)")
else
command("let j = jobstart('pwd', g:job_opts)")
end
end)
matches('E475: Invalid argument: expected valid directory$', err)
end)
it('error on non-executable `cwd`', function()
skip(is_os('win'), 'Not applicable for Windows')
local dir = 'Xtest_not_executable_dir'
mkdir(dir)
fn.setfperm(dir, 'rw-------')
matches(
'^Vim%(call%):E903: Process failed to start: permission denied: .*',
pcall_err(command, "call jobstart(['pwd'], {'cwd': '" .. dir .. "'})")
2024-01-02 18:09:18 -07:00
)
rmdir(dir)
end)
it('returns 0 when it fails to start', function()
2016-12-10 07:50:08 -07:00
eq('', eval('v:errmsg'))
feed_command('let g:test_jobid = jobstart([])')
2016-12-10 07:50:08 -07:00
eq(0, eval('g:test_jobid'))
eq('E474:', string.match(eval('v:errmsg'), 'E%d*:'))
end)
2016-12-10 07:50:08 -07:00
it('returns -1 when target is not executable #5465', function()
local function new_job()
return eval([[jobstart('')]])
end
2016-12-10 07:50:08 -07:00
local executable_jobid = new_job()
local exe = is_os('win') and './test/functional/fixtures'
or './test/functional/fixtures/non_executable.txt'
eq(
"Vim:E475: Invalid value for argument cmd: '" .. exe .. "' is not executable",
pcall_err(eval, "jobstart(['" .. exe .. "'])")
2024-01-02 18:09:18 -07:00
)
eq('', eval('v:errmsg'))
2016-12-10 07:50:08 -07:00
-- Non-executable job should not increment the job ids. #5465
eq(executable_jobid + 1, new_job())
end)
it('invokes callbacks when the job writes and exits', function()
command("let g:job_opts.on_stderr = function('OnEvent')")
command([[call jobstart(has('win32') ? 'echo:' : 'echo', g:job_opts)]])
2017-06-10 06:25:23 -07:00
expect_twostreams({
{ 'notification', 'stdout', { 0, { '', '' } } },
{ 'notification', 'stdout', { 0, { '' } } },
}, { { 'notification', 'stderr', { 0, { '' } } } })
eq({ 'notification', 'exit', { 0, 0 } }, next_msg())
end)
it('interactive commands', function()
command("let j = jobstart(['cat', '-'], g:job_opts)")
neq(0, eval('j'))
command('call jobsend(j, "abc\\n")')
eq({ 'notification', 'stdout', { 0, { 'abc', '' } } }, next_msg())
command('call jobsend(j, "123\\nxyz\\n")')
expect_msg_seq(
{ { 'notification', 'stdout', { 0, { '123', 'xyz', '' } } } },
-- Alternative sequence:
{
{ 'notification', 'stdout', { 0, { '123', '' } } },
{ 'notification', 'stdout', { 0, { 'xyz', '' } } },
}
)
command('call jobsend(j, [123, "xyz", ""])')
expect_msg_seq(
{ { 'notification', 'stdout', { 0, { '123', 'xyz', '' } } } },
-- Alternative sequence:
{
{ 'notification', 'stdout', { 0, { '123', '' } } },
{ 'notification', 'stdout', { 0, { 'xyz', '' } } },
}
)
command('call jobstop(j)')
2017-06-10 06:25:23 -07:00
eq({ 'notification', 'stdout', { 0, { '' } } }, next_msg())
eq({ 'notification', 'exit', { 0, 143 } }, next_msg())
end)
it('preserves NULs', function()
-- Make a file with NULs in it.
local filename = t.tmpname()
write_file(filename, 'abc\0def\n')
command("let j = jobstart(['cat', '" .. filename .. "'], g:job_opts)")
eq({ 'notification', 'stdout', { 0, { 'abc\ndef', '' } } }, next_msg())
2017-06-10 06:25:23 -07:00
eq({ 'notification', 'stdout', { 0, { '' } } }, next_msg())
eq({ 'notification', 'exit', { 0, 0 } }, next_msg())
os.remove(filename)
-- jobsend() preserves NULs.
command("let j = jobstart(['cat', '-'], g:job_opts)")
command([[call jobsend(j, ["123\n456",""])]])
eq({ 'notification', 'stdout', { 0, { '123\n456', '' } } }, next_msg())
command('call jobstop(j)')
end)
it('emits partial lines (does NOT buffer data lacking newlines)', function()
command("let j = jobstart(['cat', '-'], g:job_opts)")
command('call jobsend(j, "abc\\nxyz")')
eq({ 'notification', 'stdout', { 0, { 'abc', 'xyz' } } }, next_msg())
command('call jobstop(j)')
2017-06-10 06:25:23 -07:00
eq({ 'notification', 'stdout', { 0, { '' } } }, next_msg())
eq({ 'notification', 'exit', { 0, 143 } }, next_msg())
end)
it('preserves newlines', function()
command("let j = jobstart(['cat', '-'], g:job_opts)")
command('call jobsend(j, "a\\n\\nc\\n\\n\\n\\nb\\n\\n")')
eq({ 'notification', 'stdout', { 0, { 'a', '', 'c', '', '', '', 'b', '', '' } } }, next_msg())
end)
it('preserves NULs', function()
command("let j = jobstart(['cat', '-'], g:job_opts)")
command('call jobsend(j, ["\n123\n", "abc\\nxyz\n", ""])')
eq({ 'notification', 'stdout', { 0, { '\n123\n', 'abc\nxyz\n', '' } } }, next_msg())
command('call jobstop(j)')
2017-06-10 06:25:23 -07:00
eq({ 'notification', 'stdout', { 0, { '' } } }, next_msg())
eq({ 'notification', 'exit', { 0, 143 } }, next_msg())
end)
it('avoids sending final newline', function()
command("let j = jobstart(['cat', '-'], g:job_opts)")
command('call jobsend(j, ["some data", "without\nfinal nl"])')
eq({ 'notification', 'stdout', { 0, { 'some data', 'without\nfinal nl' } } }, next_msg())
command('call jobstop(j)')
2017-06-10 06:25:23 -07:00
eq({ 'notification', 'stdout', { 0, { '' } } }, next_msg())
eq({ 'notification', 'exit', { 0, 143 } }, next_msg())
end)
it('closes the job streams with jobclose', function()
command("let j = jobstart(['cat', '-'], g:job_opts)")
command('call jobclose(j, "stdin")')
2017-06-10 06:25:23 -07:00
eq({ 'notification', 'stdout', { 0, { '' } } }, next_msg())
eq({ 'notification', 'exit', { 0, 0 } }, next_msg())
end)
it('disallows jobsend on a job that closed stdin', function()
command("let j = jobstart(['cat', '-'], g:job_opts)")
command('call jobclose(j, "stdin")')
eq(
false,
pcall(function()
command('call jobsend(j, ["some data"])')
end)
2024-01-02 18:09:18 -07:00
)
2021-07-12 12:22:56 -07:00
command("let g:job_opts.stdin = 'null'")
command("let j = jobstart(['cat', '-'], g:job_opts)")
2021-07-12 12:22:56 -07:00
eq(
false,
pcall(function()
command('call jobsend(j, ["some data"])')
2021-07-12 12:22:56 -07:00
end)
2024-01-02 18:09:18 -07:00
)
end)
it('disallows jobsend on a non-existent job', function()
eq(false, pcall(eval, "jobsend(-1, 'lol')"))
eq(0, eval('jobstop(-1)'))
end)
it('jobstop twice on the stopped or exited job return 0', function()
command("let j = jobstart(['cat', '-'], g:job_opts)")
neq(0, eval('j'))
eq(1, eval('jobstop(j)'))
eq(0, eval('jobstop(j)'))
end)
it('will not leak memory if we leave a job running', function()
command("call jobstart(['cat', '-'], g:job_opts)")
end)
it('can get the pid value using getpid', function()
command("let j = jobstart(['cat', '-'], g:job_opts)")
local pid = eval('jobpid(j)')
neq(NIL, api.nvim_get_proc(pid))
command('call jobstop(j)')
2017-06-10 06:25:23 -07:00
eq({ 'notification', 'stdout', { 0, { '' } } }, next_msg())
eq({ 'notification', 'exit', { 0, 143 } }, next_msg())
eq(NIL, api.nvim_get_proc(pid))
end)
it('disposed on Nvim exit', function()
-- use sleep, which doesn't die on stdin close
command(
"let g:j = jobstart(has('win32') ? ['ping', '-n', '1001', '127.0.0.1'] : ['sleep', '1000'], g:job_opts)"
)
local pid = eval('jobpid(g:j)')
neq(NIL, api.nvim_get_proc(pid))
clear()
eq(NIL, api.nvim_get_proc(pid))
end)
it('can survive the exit of nvim with "detach"', function()
command('let g:job_opts.detach = 1')
command(
"let g:j = jobstart(has('win32') ? ['ping', '-n', '1001', '127.0.0.1'] : ['sleep', '1000'], g:job_opts)"
)
local pid = eval('jobpid(g:j)')
neq(NIL, api.nvim_get_proc(pid))
clear()
neq(NIL, api.nvim_get_proc(pid))
-- clean up after ourselves
eq(0, os_kill(pid))
end)
it('can pass user data to the callback', function()
command('let g:job_opts.user = {"n": 5, "s": "str", "l": [1]}')
command([[call jobstart('echo foo', g:job_opts)]])
local data = { n = 5, s = 'str', l = { 1 } }
expect_msg_seq(
{
{ 'notification', 'stdout', { data, { 'foo', '' } } },
{ 'notification', 'stdout', { data, { '' } } },
},
-- Alternative sequence:
{
{ 'notification', 'stdout', { data, { 'foo' } } },
{ 'notification', 'stdout', { data, { '', '' } } },
{ 'notification', 'stdout', { data, { '' } } },
}
)
eq({ 'notification', 'exit', { data, 0 } }, next_msg())
end)
it('can omit data callbacks', function()
command('unlet g:job_opts.on_stdout')
command('let g:job_opts.user = 5')
command([[call jobstart('echo foo', g:job_opts)]])
eq({ 'notification', 'exit', { 5, 0 } }, next_msg())
end)
it('can omit exit callback', function()
command('unlet g:job_opts.on_exit')
command('let g:job_opts.user = 5')
command([[call jobstart('echo foo', g:job_opts)]])
expect_msg_seq(
{
{ 'notification', 'stdout', { 5, { 'foo', '' } } },
{ 'notification', 'stdout', { 5, { '' } } },
},
-- Alternative sequence:
{
{ 'notification', 'stdout', { 5, { 'foo' } } },
{ 'notification', 'stdout', { 5, { '', '' } } },
{ 'notification', 'stdout', { 5, { '' } } },
}
)
end)
it('will pass return code with the exit event', function()
command('let g:job_opts.user = 5')
command("call jobstart('exit 55', g:job_opts)")
2017-06-10 06:25:23 -07:00
eq({ 'notification', 'stdout', { 5, { '' } } }, next_msg())
eq({ 'notification', 'exit', { 5, 55 } }, next_msg())
end)
it('can receive dictionary functions', function()
source([[
let g:dict = {'id': 10}
function g:dict.on_exit(id, code, event)
call rpcnotify(g:channel, a:event, a:code, self.id)
endfunction
call jobstart('exit 45', g:dict)
]])
eq({ 'notification', 'exit', { 45, 10 } }, next_msg())
end)
it('can redefine callbacks being used by a job', function()
local screen = Screen.new()
screen:set_default_attr_ids({
[1] = { bold = true, foreground = Screen.colors.Blue },
})
source([[
function! g:JobHandler(job_id, data, event)
endfunction
let g:callbacks = {
\ 'on_stdout': function('g:JobHandler'),
\ 'on_stderr': function('g:JobHandler'),
\ 'on_exit': function('g:JobHandler')
\ }
let job = jobstart(['cat', '-'], g:callbacks)
]])
poke_eventloop()
source([[
function! g:JobHandler(job_id, data, event)
endfunction
]])
eq('', eval('v:errmsg'))
end)
it('requires funcrefs for script-local (s:) functions', function()
2017-06-10 06:25:23 -07:00
local screen = Screen.new(60, 5)
screen:set_default_attr_ids({
[1] = { bold = true, foreground = Screen.colors.Blue1 },
[2] = { foreground = Screen.colors.Grey100, background = Screen.colors.Red },
[3] = { bold = true, foreground = Screen.colors.SeaGreen4 },
})
-- Pass job callback names _without_ `function(...)`.
source([[
function! s:OnEvent(id, data, event) dict
let g:job_result = get(self, 'user')
endfunction
2017-01-12 23:40:49 -07:00
let s:job = jobstart('echo "foo"', {
\ 'on_stdout': 's:OnEvent',
\ 'on_stderr': 's:OnEvent',
\ 'on_exit': 's:OnEvent',
\ })
]])
screen:expect { any = '{2:E120: Using <SID> not in a script context: s:OnEvent}' }
end)
it('does not repeat output with slow output handlers', function()
source([[
let d = {'data': []}
function! d.on_stdout(job, data, event) dict
call add(self.data, Normalize(a:data))
sleep 200m
endfunction
function! d.on_exit(job, data, event) dict
let g:exit_data = copy(self.data)
endfunction
if has('win32')
let cmd = 'for /L %I in (1,1,5) do @(echo %I& ping -n 2 127.0.0.1 > nul)'
else
let cmd = ['sh', '-c', 'for i in 1 2 3 4 5; do echo $i; sleep 0.1; done']
endif
let g:id = jobstart(cmd, d)
sleep 1500m
call jobwait([g:id])
]])
local expected = { '1', '2', '3', '4', '5', '' }
local chunks = eval('d.data')
-- check nothing was received after exit, including EOF
eq(eval('g:exit_data'), chunks)
local received = { '' }
for i, chunk in ipairs(chunks) do
if i < #chunks then
-- if chunks got joined, a spurious [''] callback was not sent
neq({ '' }, chunk)
else
-- but EOF callback is still sent
eq({ '' }, chunk)
end
received[#received] = received[#received] .. chunk[1]
for j = 2, #chunk do
received[#received + 1] = chunk[j]
end
end
eq(expected, received)
end)
it('does not invoke callbacks recursively', function()
source([[
let d = {'data': []}
function! d.on_stdout(job, data, event) dict
" if callbacks were invoked recursively, this would cause on_stdout
" to be invoked recursively and the data reversed on the call stack
sleep 200m
call add(self.data, Normalize(a:data))
endfunction
function! d.on_exit(job, data, event) dict
let g:exit_data = copy(self.data)
endfunction
if has('win32')
let cmd = 'for /L %I in (1,1,5) do @(echo %I& ping -n 2 127.0.0.1 > nul)'
else
let cmd = ['sh', '-c', 'for i in 1 2 3 4 5; do echo $i; sleep 0.1; done']
endif
let g:id = jobstart(cmd, d)
sleep 1500m
call jobwait([g:id])
]])
local expected = { '1', '2', '3', '4', '5', '' }
local chunks = eval('d.data')
-- check nothing was received after exit, including EOF
eq(eval('g:exit_data'), chunks)
local received = { '' }
for i, chunk in ipairs(chunks) do
if i < #chunks then
-- if chunks got joined, a spurious [''] callback was not sent
neq({ '' }, chunk)
else
-- but EOF callback is still sent
eq({ '' }, chunk)
end
received[#received] = received[#received] .. chunk[1]
for j = 2, #chunk do
received[#received + 1] = chunk[j]
end
end
eq(expected, received)
end)
it('jobstart() works with partial functions', function()
source([[
function PrintArgs(a1, a2, id, data, event)
" Windows: remove ^M
let normalized = map(a:data, 'substitute(v:val, "\r", "", "g")')
call rpcnotify(g:channel, '1', a:a1, a:a2, normalized, a:event)
endfunction
let Callback = function('PrintArgs', ["foo", "bar"])
let g:job_opts = {'on_stdout': Callback}
call jobstart('echo some text', g:job_opts)
]])
expect_msg_seq(
{ { 'notification', '1', { 'foo', 'bar', { 'some text', '' }, 'stdout' } } },
-- Alternative sequence:
{
{ 'notification', '1', { 'foo', 'bar', { 'some text' }, 'stdout' } },
{ 'notification', '1', { 'foo', 'bar', { '', '' }, 'stdout' } },
}
)
end)
it('jobstart() works with closures', function()
source([[
fun! MkFun()
let a1 = 'foo'
let a2 = 'bar'
return {id, data, event -> rpcnotify(g:channel, '1', a1, a2, Normalize(data), event)}
endfun
let g:job_opts = {'on_stdout': MkFun()}
call jobstart('echo some text', g:job_opts)
]])
expect_msg_seq(
{ { 'notification', '1', { 'foo', 'bar', { 'some text', '' }, 'stdout' } } },
-- Alternative sequence:
{
{ 'notification', '1', { 'foo', 'bar', { 'some text' }, 'stdout' } },
{ 'notification', '1', { 'foo', 'bar', { '', '' }, 'stdout' } },
}
)
end)
it('jobstart() works when closure passed directly to `jobstart`', function()
source([[
let g:job_opts = {'on_stdout': {id, data, event -> rpcnotify(g:channel, '1', 'foo', 'bar', Normalize(data), event)}}
call jobstart('echo some text', g:job_opts)
]])
expect_msg_seq(
{ { 'notification', '1', { 'foo', 'bar', { 'some text', '' }, 'stdout' } } },
-- Alternative sequence:
{
{ 'notification', '1', { 'foo', 'bar', { 'some text' }, 'stdout' } },
{ 'notification', '1', { 'foo', 'bar', { '', '' }, 'stdout' } },
}
)
end)
it('jobstart() environment: $NVIM, $NVIM_LISTEN_ADDRESS #11009', function()
local function get_env_in_child_job(envname, env)
return exec_lua(
[[
local envname, env = ...
local join = function(s) return vim.fn.join(s, '') end
local stdout = {}
local stderr = {}
local opt = {
env = env,
stdout_buffered = true,
stderr_buffered = true,
on_stderr = function(chan, data, name) stderr = data end,
on_stdout = function(chan, data, name) stdout = data end,
}
local j1 = vim.fn.jobstart({ vim.v.progpath, '-es', '-V1',('+echo "%s="..getenv("%s")'):format(envname, envname), '+qa!' }, opt)
vim.fn.jobwait({ j1 }, 10000)
return join({ join(stdout), join(stderr) })
]],
envname,
env
)
end
local addr = eval('v:servername')
ok((addr):len() > 0)
-- $NVIM is _not_ defined in the top-level Nvim process.
eq('', eval('$NVIM'))
-- jobstart() shares its v:servername with the child via $NVIM.
eq('NVIM=' .. addr, get_env_in_child_job('NVIM'))
-- $NVIM_LISTEN_ADDRESS is unset by server_init in the child.
eq('NVIM_LISTEN_ADDRESS=v:null', get_env_in_child_job('NVIM_LISTEN_ADDRESS'))
eq(
'NVIM_LISTEN_ADDRESS=v:null',
get_env_in_child_job('NVIM_LISTEN_ADDRESS', { NVIM_LISTEN_ADDRESS = 'Xtest_jobstart_env' })
)
-- User can explicitly set $NVIM_LOG_FILE, $VIM, $VIMRUNTIME.
eq(
'NVIM_LOG_FILE=Xtest_jobstart_env',
get_env_in_child_job('NVIM_LOG_FILE', { NVIM_LOG_FILE = 'Xtest_jobstart_env' })
2024-01-02 18:09:18 -07:00
)
os.remove('Xtest_jobstart_env')
end)
describe('jobwait()', function()
before_each(function()
if is_os('win') then
n.set_shell_powershell()
end
end)
it('returns a list of status codes', function()
source([[
call rpcnotify(g:channel, 'wait', jobwait(has('win32') ? [
\ jobstart('Start-Sleep -Milliseconds 100; exit 4'),
\ jobstart('Start-Sleep -Milliseconds 300; exit 5'),
\ jobstart('Start-Sleep -Milliseconds 500; exit 6'),
\ jobstart('Start-Sleep -Milliseconds 700; exit 7')
\ ] : [
\ jobstart('sleep 0.10; exit 4'),
\ jobstart('sleep 0.110; exit 5'),
\ jobstart('sleep 0.210; exit 6'),
\ jobstart('sleep 0.310; exit 7')
\ ]))
]])
eq({ 'notification', 'wait', { { 4, 5, 6, 7 } } }, next_msg())
end)
it('will run callbacks while waiting', function()
source([[
let g:dict = {}
let g:jobs = []
let g:exits = []
function g:dict.on_stdout(id, code, event) abort
call add(g:jobs, a:id)
endfunction
function g:dict.on_exit(id, code, event) abort
if a:code != 5
throw 'Error!'
endif
call add(g:exits, a:id)
endfunction
call jobwait(has('win32') ? [
\ jobstart('Start-Sleep -Milliseconds 100; exit 5', g:dict),
\ jobstart('Start-Sleep -Milliseconds 300; exit 5', g:dict),
\ jobstart('Start-Sleep -Milliseconds 500; exit 5', g:dict),
\ jobstart('Start-Sleep -Milliseconds 700; exit 5', g:dict)
\ ] : [
\ jobstart('sleep 0.010; exit 5', g:dict),
\ jobstart('sleep 0.030; exit 5', g:dict),
\ jobstart('sleep 0.050; exit 5', g:dict),
\ jobstart('sleep 0.070; exit 5', g:dict)
\ ])
call rpcnotify(g:channel, 'wait', sort(g:jobs), sort(g:exits))
]])
eq({ 'notification', 'wait', { { 3, 4, 5, 6 }, { 3, 4, 5, 6 } } }, next_msg())
end)
it('will return status codes in the order of passed ids', function()
source([[
call rpcnotify(g:channel, 'wait', jobwait(has('win32') ? [
\ jobstart('Start-Sleep -Milliseconds 700; exit 4'),
\ jobstart('Start-Sleep -Milliseconds 500; exit 5'),
\ jobstart('Start-Sleep -Milliseconds 300; exit 6'),
\ jobstart('Start-Sleep -Milliseconds 100; exit 7')
\ ] : [
\ jobstart('sleep 0.070; exit 4'),
\ jobstart('sleep 0.050; exit 5'),
\ jobstart('sleep 0.030; exit 6'),
\ jobstart('sleep 0.010; exit 7')
\ ]))
]])
eq({ 'notification', 'wait', { { 4, 5, 6, 7 } } }, next_msg())
end)
it('will return -3 for invalid job ids', function()
source([[
call rpcnotify(g:channel, 'wait', jobwait([
\ -10,
\ jobstart((has('win32') ? 'Start-Sleep -Milliseconds 100' : 'sleep 0.01').'; exit 5'),
\ ]))
]])
eq({ 'notification', 'wait', { { -3, 5 } } }, next_msg())
end)
it('will return -2 when interrupted without timeout', function()
feed_command(
'call rpcnotify(g:channel, "ready") | '
.. 'call rpcnotify(g:channel, "wait", '
.. 'jobwait([jobstart("'
.. (is_os('win') and 'Start-Sleep 10' or 'sleep 10')
.. '; exit 55")]))'
)
eq({ 'notification', 'ready', {} }, next_msg())
feed('<c-c>')
eq({ 'notification', 'wait', { { -2 } } }, next_msg())
end)
it('will return -2 when interrupted with timeout', function()
feed_command(
'call rpcnotify(g:channel, "ready") | '
.. 'call rpcnotify(g:channel, "wait", '
.. 'jobwait([jobstart("'
.. (is_os('win') and 'Start-Sleep 10' or 'sleep 10')
.. '; exit 55")], 10000))'
)
eq({ 'notification', 'ready', {} }, next_msg())
feed('<c-c>')
eq({ 'notification', 'wait', { { -2 } } }, next_msg())
end)
it('can be called recursively', function()
source([[
let g:opts = {}
let g:counter = 0
function g:opts.on_stdout(id, msg, _event)
if self.state == 0
if self.counter < 10
call Run()
endif
let self.state = 1
call jobsend(a:id, "line1\n")
elseif self.state == 1
let self.state = 2
call jobsend(a:id, "line2\n")
elseif self.state == 2
let self.state = 3
call jobsend(a:id, "line3\n")
2017-06-10 06:25:23 -07:00
elseif self.state == 3
let self.state = 4
call rpcnotify(g:channel, 'w', printf('job %d closed', self.counter))
call jobclose(a:id, 'stdin')
endif
endfunction
function g:opts.on_exit(...)
call rpcnotify(g:channel, 'w', printf('job %d exited', self.counter))
endfunction
function Run()
let g:counter += 1
let j = copy(g:opts)
let j.state = 0
let j.counter = g:counter
call jobwait([
\ jobstart('echo ready; cat -', j),
\ ])
endfunction
]])
feed_command('call Run()')
local r
for i = 10, 1, -1 do
r = next_msg()
eq('job ' .. i .. ' closed', r[3][1])
r = next_msg()
eq('job ' .. i .. ' exited', r[3][1])
end
eq(10, api.nvim_eval('g:counter'))
end)
describe('with timeout argument', function()
it('will return -1 if the wait timed out', function()
source([[
call rpcnotify(g:channel, 'wait', jobwait([
\ jobstart((has('win32') ? 'Start-Sleep 10' : 'sleep 10').'; exit 5'),
\ ], 100))
]])
eq({ 'notification', 'wait', { { -1 } } }, next_msg())
end)
it('can pass 0 to check if a job exists', function()
source([[
call rpcnotify(g:channel, 'wait', jobwait(has('win32') ? [
\ jobstart('Start-Sleep -Milliseconds 50; exit 4'),
\ jobstart('Start-Sleep -Milliseconds 300; exit 5'),
\ ] : [
\ jobstart('sleep 0.05; exit 4'),
\ jobstart('sleep 0.3; exit 5'),
\ ], 0))
]])
eq({ 'notification', 'wait', { { -1, -1 } } }, next_msg())
end)
end)
it('hides cursor and flushes messages before blocking', function()
local screen = Screen.new(50, 6)
command([[let g:id = jobstart([v:progpath, '--clean', '--headless'])]])
source([[
func PrintAndWait()
echon "aaa\nbbb"
call jobwait([g:id], 300)
echon "\nccc"
endfunc
]])
feed_command('call PrintAndWait()')
screen:expect {
grid = [[
|
{1:~ }|*2
{3: }|
aaa |
bbb |
]],
timeout = 100,
}
screen:expect {
grid = [[
|
{3: }|
aaa |
bbb |
ccc |
{6:Press ENTER or type command to continue}^ |
]],
}
feed('<CR>')
fn.jobstop(api.nvim_get_var('id'))
end)
end)
pending('exit event follows stdout, stderr', function()
command("let g:job_opts.on_stderr = function('OnEvent')")
command("let j = jobstart(['cat', '-'], g:job_opts)")
api.nvim_eval('jobsend(j, "abcdef")')
api.nvim_eval('jobstop(j)')
expect_msg_seq(
{
{ 'notification', 'stdout', { 0, { 'abcdef' } } },
{ 'notification', 'stdout', { 0, { '' } } },
{ 'notification', 'stderr', { 0, { '' } } },
},
-- Alternative sequence:
{
{ 'notification', 'stderr', { 0, { '' } } },
{ 'notification', 'stdout', { 0, { 'abcdef' } } },
{ 'notification', 'stdout', { 0, { '' } } },
},
-- Alternative sequence:
{
{ 'notification', 'stdout', { 0, { 'abcdef' } } },
{ 'notification', 'stderr', { 0, { '' } } },
{ 'notification', 'stdout', { 0, { '' } } },
}
)
eq({ 'notification', 'exit', { 0, 143 } }, next_msg())
end)
it('cannot have both rpc and pty options', function()
command('let g:job_opts.pty = v:true')
command('let g:job_opts.rpc = v:true')
local _, err = pcall(command, "let j = jobstart(['cat', '-'], g:job_opts)")
matches("E475: Invalid argument: job cannot have both 'pty' and 'rpc' options set", err)
end)
it('does not crash when repeatedly failing to start shell', function()
source([[
set shell=nosuchshell
func! DoIt()
call jobstart('true')
call jobstart('true')
endfunc
]])
-- The crash only triggered if both jobs are cleaned up on the same event
-- loop tick. This is also prevented by try-block, so feed must be used.
feed_command('call DoIt()')
feed('<cr>') -- press RETURN
assert_alive()
end)
it('jobstop() kills entire process tree #6530', function()
-- XXX: Using `nvim` isn't a good test, it reaps its children on exit.
-- local c = 'call jobstart([v:progpath, "-u", "NONE", "-i", "NONE", "--headless"])'
-- local j = eval("jobstart([v:progpath, '-u', 'NONE', '-i', 'NONE', '--headless', '-c', '"
-- ..c.."', '-c', '"..c.."'])")
-- Create child with several descendants.
if is_os('win') then
2019-08-15 21:37:44 -07:00
source([[
function! s:formatprocs(pid, prefix)
let result = ''
let result .= a:prefix . printf("%-24.24s%6s %12.12s %s\n",
\ s:procs[a:pid]['name'],
\ a:pid,
\ s:procs[a:pid]['Session Name'],
\ s:procs[a:pid]['Session'])
if has_key(s:procs[a:pid], 'children')
for pid in s:procs[a:pid]['children']
let result .= s:formatprocs(pid, a:prefix . ' ')
endfor
endif
return result
endfunction
function! PsTree() abort
let s:procs = {}
for proc in map(
\ map(
\ systemlist('tasklist /NH'),
\ 'substitute(v:val, "\r", "", "")'),
\ 'split(v:val, "\\s\\+")')
if len(proc) == 6
let s:procs[proc[1]] .. ']]' .. [[= {'name': proc[0],
\ 'Session Name': proc[2],
\ 'Session': proc[3]}
endif
endfor
for pid in keys(s:procs)
let children = nvim_get_proc_children(str2nr(pid))
if !empty(children)
let s:procs[pid]['children'] = children
for cpid in children
let s:procs[printf('%d', cpid)]['parent'] = str2nr(pid)
endfor
endif
endfor
let result = ''
for pid in sort(keys(s:procs), {i1, i2 -> i1 - i2})
if !has_key(s:procs[pid], 'parent')
let result .= s:formatprocs(pid, '')
endif
endfor
return result
endfunction
]])
end
local sleep_cmd = (is_os('win') and 'ping -n 31 127.0.0.1' or 'sleep 30')
local j = eval("jobstart('" .. sleep_cmd .. ' | ' .. sleep_cmd .. ' | ' .. sleep_cmd .. "')")
local ppid = fn.jobpid(j)
local children
if is_os('win') then
2019-08-15 21:37:44 -07:00
local status, result = pcall(retry, nil, nil, function()
children = api.nvim_get_proc_children(ppid)
-- On Windows conhost.exe may exist, and
-- e.g. vctip.exe might appear. #10783
ok(#children >= 3 and #children <= 5)
2019-08-15 21:37:44 -07:00
end)
if not status then
print('')
print(eval('PsTree()'))
error(result)
end
2019-08-15 21:37:44 -07:00
else
retry(nil, nil, function()
children = api.nvim_get_proc_children(ppid)
2019-08-15 21:37:44 -07:00
eq(3, #children)
end)
end
-- Assert that nvim_get_proc() sees the children.
for _, child_pid in ipairs(children) do
local info = api.nvim_get_proc(child_pid)
-- eq((is_os('win') and 'nvim.exe' or 'nvim'), info.name)
eq(ppid, info.ppid)
end
-- Kill the root of the tree.
eq(1, fn.jobstop(j))
-- Assert that the children were killed.
retry(nil, nil, function()
for _, child_pid in ipairs(children) do
eq(NIL, api.nvim_get_proc(child_pid))
end
end)
end)
it('jobstop on same id before stopped', function()
command('let j = jobstart(["cat", "-"], g:job_opts)')
neq(0, eval('j'))
eq({ 1, 0 }, eval('[jobstop(j), jobstop(j)]'))
end)
describe('running tty-test program', function()
if skip(is_os('win')) then
return
end
local function next_chunk()
local rv
while true do
local msg = next_msg()
local data = msg[3][2]
for i = 1, #data do
data[i] = data[i]:gsub('\n', '\000')
end
rv = table.concat(data, '\n')
rv = rv:gsub('\r\n$', ''):gsub('^\r\n', '')
if rv ~= '' then
break
end
end
return rv
end
local j
local function send(str)
-- check no nvim_chan_free double free with pty job (#14198)
api.nvim_chan_send(j, str)
end
before_each(function()
-- Redefine Normalize() so that TTY data is not munged.
source([[
function! Normalize(data) abort
return a:data
endfunction
]])
insert(testprg('tty-test'))
command('let g:job_opts.pty = 1')
command('let exec = [expand("<cfile>:p")]')
command('let j = jobstart(exec, g:job_opts)')
j = eval 'j'
eq('tty ready', next_chunk())
end)
it('echoing input', function()
send('test')
eq('test', next_chunk())
end)
it('resizing window', function()
command('call jobresize(j, 40, 10)')
eq('rows: 10, cols: 40', next_chunk())
command('call jobresize(j, 10, 40)')
eq('rows: 40, cols: 10', next_chunk())
end)
it('jobclose() sends SIGHUP', function()
command('call jobclose(j)')
local msg = next_msg()
msg = (msg[2] == 'stdout') and next_msg() or msg -- Skip stdout, if any.
eq({ 'notification', 'exit', { 0, 42 } }, msg)
end)
it('jobstart() does not keep ptmx file descriptor open', function()
-- Start another job (using libuv)
command('let g:job_opts.pty = 0')
local other_jobid = eval("jobstart(['cat', '-'], g:job_opts)")
local other_pid = eval('jobpid(' .. other_jobid .. ')')
-- Other job doesn't block first job from receiving SIGHUP on jobclose()
command('call jobclose(j)')
-- Have to wait so that the SIGHUP can be processed by tty-test on time.
-- Can't wait for the next message in case this test fails, if it fails
-- there won't be any more messages, and the test would hang.
2024-01-12 04:41:09 -07:00
vim.uv.sleep(100)
local err = exc_exec('call jobpid(j)')
2017-06-10 06:25:23 -07:00
eq('Vim(call):E900: Invalid channel id', err)
-- cleanup
eq(other_pid, eval('jobpid(' .. other_jobid .. ')'))
command('call jobstop(' .. other_jobid .. ')')
end)
end)
it('does not close the same handle twice on exit #25086', function()
local filename = string.format('%s.lua', t.tmpname())
write_file(
filename,
[[
vim.api.nvim_create_autocmd('VimLeavePre', {
callback = function()
local id = vim.fn.jobstart('sleep 0')
vim.fn.jobwait({id})
end,
})
]]
)
local screen = tt.setup_child_nvim({
'--cmd',
'set notermguicolors',
'-i',
'NONE',
'-u',
filename,
})
-- Wait for startup to complete, so that all terminal responses are received.
screen:expect([[
{1: } |
~ |*3
{1:[No Name] 0,0-1 All}|
|
{3:-- TERMINAL --} |
]])
feed(':q<CR>')
screen:expect([[
|
[Process exited 0]{1: } |
|*4
{3:-- TERMINAL --} |
]])
end)
end)
describe('pty process teardown', function()
local screen
before_each(function()
clear()
screen = Screen.new(30, 6)
screen:expect([[
^ |
{1:~ }|*4
|
]])
end)
it('does not prevent/delay exit. #4798 #4900', function()
skip(fn.executable('sleep') == 0, 'missing "sleep" command')
-- Use a nested nvim (in :term) to test without --headless.
fn.termopen({
n.nvim_prog,
'-u',
'NONE',
'-i',
'NONE',
'--cmd',
nvim_set,
-- Use :term again in the _nested_ nvim to get a PTY process.
-- Use `sleep` to simulate a long-running child of the PTY.
'+terminal',
'+!(sleep 300 &)',
'+qa',
}, { env = { VIMRUNTIME = os.getenv('VIMRUNTIME') } })
-- Exiting should terminate all descendants (PTY, its children, ...).
screen:expect([[
2017-05-25 03:35:27 -07:00
^ |
[Process exited 0] |
|*4
]])
end)
end)