410 lines
11 KiB
Lua
410 lines
11 KiB
Lua
local test_samurai = require("test-samurai")
|
|
local core = require("test-samurai.core")
|
|
|
|
local function close_output_container()
|
|
local keys = vim.api.nvim_replace_termcodes("<esc><esc>", true, false, true)
|
|
local attempts = 5
|
|
while attempts > 0 do
|
|
local float_win = nil
|
|
for _, win in ipairs(vim.api.nvim_tabpage_list_wins(0)) do
|
|
local cfg = vim.api.nvim_win_get_config(win)
|
|
if cfg.relative ~= "" then
|
|
float_win = win
|
|
break
|
|
end
|
|
end
|
|
if not float_win then
|
|
break
|
|
end
|
|
vim.api.nvim_set_current_win(float_win)
|
|
vim.api.nvim_feedkeys(keys, "x", false)
|
|
vim.wait(20, function()
|
|
for _, win in ipairs(vim.api.nvim_tabpage_list_wins(0)) do
|
|
local cfg = vim.api.nvim_win_get_config(win)
|
|
if cfg.relative ~= "" then
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end)
|
|
attempts = attempts - 1
|
|
end
|
|
end
|
|
|
|
local function stub_jobstart(opts_config)
|
|
local orig = vim.fn.jobstart
|
|
local idx = 0
|
|
local config = opts_config or {}
|
|
vim.fn.jobstart = function(cmd, opts)
|
|
idx = idx + 1
|
|
local code = 0
|
|
if type(config.exit_codes) == "table" then
|
|
code = config.exit_codes[idx] or 0
|
|
elseif type(config.exit_codes) == "number" then
|
|
code = config.exit_codes
|
|
end
|
|
local out = config.stdout and config.stdout[idx] or nil
|
|
if out and opts and opts.on_stdout then
|
|
if type(out) == "string" then
|
|
out = { out }
|
|
end
|
|
opts.on_stdout(1, out, nil)
|
|
end
|
|
if opts and opts.on_exit then
|
|
opts.on_exit(1, code, nil)
|
|
end
|
|
return 1
|
|
end
|
|
return orig
|
|
end
|
|
|
|
describe("test-samurai quickfix", function()
|
|
before_each(function()
|
|
test_samurai.setup()
|
|
end)
|
|
|
|
after_each(function()
|
|
close_output_container()
|
|
vim.fn.setqflist({}, "r")
|
|
end)
|
|
|
|
it("fuellt die Quickfix-Liste mit Fehltests und leert sie bei Erfolg", function()
|
|
local root = vim.fs.joinpath(vim.loop.cwd(), "tests", "tmp_qf")
|
|
vim.fn.mkdir(root, "p")
|
|
local path = root .. "/foo_test.go"
|
|
vim.fn.writefile({
|
|
"package foo",
|
|
"",
|
|
"func TestFoo(t *testing.T) {",
|
|
' t.Run("bar", func(t *testing.T) {',
|
|
" })",
|
|
"}",
|
|
"",
|
|
"func TestBaz(t *testing.T) {",
|
|
"}",
|
|
}, path)
|
|
|
|
local bufnr = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_buf_set_name(bufnr, path)
|
|
vim.bo[bufnr].filetype = "go"
|
|
vim.api.nvim_set_current_buf(bufnr)
|
|
|
|
local orig_jobstart = stub_jobstart({
|
|
exit_codes = { 1, 0 },
|
|
stdout = {
|
|
{
|
|
vim.json.encode({ Action = "fail", Test = "TestFoo/bar" }),
|
|
vim.json.encode({ Action = "fail", Test = "TestBaz" }),
|
|
},
|
|
{ vim.json.encode({ Action = "pass", Test = "TestFoo" }) },
|
|
},
|
|
})
|
|
|
|
core.run_file()
|
|
|
|
local first = vim.fn.getqflist()
|
|
assert.equals(2, #first)
|
|
assert.equals(path, vim.fn.bufname(first[1].bufnr))
|
|
assert.equals(4, first[1].lnum)
|
|
assert.equals(path, vim.fn.bufname(first[2].bufnr))
|
|
assert.equals(8, first[2].lnum)
|
|
|
|
close_output_container()
|
|
vim.api.nvim_set_current_buf(bufnr)
|
|
|
|
core.run_file()
|
|
|
|
local second = vim.fn.getqflist()
|
|
assert.equals(0, #second)
|
|
|
|
vim.fn.jobstart = orig_jobstart
|
|
end)
|
|
|
|
it("enthaelt bei Go auch Eltern- und Subtest-Failures im Quickfix", function()
|
|
local root = vim.fs.joinpath(vim.loop.cwd(), "tests", "tmp_qf_go_sub")
|
|
vim.fn.mkdir(root, "p")
|
|
local path = root .. "/foo_sub_test.go"
|
|
vim.fn.writefile({
|
|
"package foo",
|
|
"",
|
|
"func TestAwesomeThing(t *testing.T) {",
|
|
' t.Run("evergreen", func(t *testing.T) {',
|
|
" })",
|
|
"",
|
|
' t.Run("everred", func(t *testing.T) {',
|
|
" })",
|
|
"}",
|
|
}, path)
|
|
|
|
local bufnr = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_buf_set_name(bufnr, path)
|
|
vim.bo[bufnr].filetype = "go"
|
|
vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, {
|
|
"package foo",
|
|
"",
|
|
"func TestAwesomeThing(t *testing.T) {",
|
|
' t.Run("evergreen", func(t *testing.T) {',
|
|
" })",
|
|
"",
|
|
' t.Run("everred", func(t *testing.T) {',
|
|
" })",
|
|
"}",
|
|
})
|
|
vim.api.nvim_set_current_buf(bufnr)
|
|
vim.api.nvim_win_set_cursor(0, { 6, 0 })
|
|
|
|
local orig_jobstart = stub_jobstart({
|
|
exit_codes = { 1 },
|
|
stdout = {
|
|
{
|
|
vim.json.encode({ Action = "fail", Test = "TestAwesomeThing/everred" }),
|
|
vim.json.encode({ Action = "fail", Test = "TestAwesomeThing" }),
|
|
},
|
|
},
|
|
})
|
|
|
|
core.run_nearest()
|
|
|
|
local qf = vim.fn.getqflist()
|
|
assert.equals(2, #qf)
|
|
assert.equals(path, vim.fn.bufname(qf[1].bufnr))
|
|
assert.equals(path, vim.fn.bufname(qf[2].bufnr))
|
|
local lines = { qf[1].lnum, qf[2].lnum }
|
|
table.sort(lines)
|
|
assert.are.same({ 3, 7 }, lines)
|
|
|
|
vim.fn.jobstart = orig_jobstart
|
|
end)
|
|
|
|
it("vereinigt Failures aus Parser und Scope fuer Go", function()
|
|
local root = vim.fs.joinpath(vim.loop.cwd(), "tests", "tmp_qf_go_union")
|
|
vim.fn.mkdir(root, "p")
|
|
local path = root .. "/foo_union_test.go"
|
|
vim.fn.writefile({
|
|
"package foo",
|
|
"",
|
|
"func TestAwesomeThing(t *testing.T) {",
|
|
' t.Run(\"evergreen\", func(t *testing.T) {',
|
|
" })",
|
|
"",
|
|
' t.Run(\"everred\", func(t *testing.T) {',
|
|
" })",
|
|
"}",
|
|
}, path)
|
|
|
|
local bufnr = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_buf_set_name(bufnr, path)
|
|
vim.bo[bufnr].filetype = "go"
|
|
vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, {
|
|
"package foo",
|
|
"",
|
|
"func TestAwesomeThing(t *testing.T) {",
|
|
' t.Run(\"evergreen\", func(t *testing.T) {',
|
|
" })",
|
|
"",
|
|
' t.Run(\"everred\", func(t *testing.T) {',
|
|
" })",
|
|
"}",
|
|
})
|
|
vim.api.nvim_set_current_buf(bufnr)
|
|
vim.api.nvim_win_set_cursor(0, { 6, 0 })
|
|
|
|
local go = require("test-samurai.runners.go")
|
|
local orig_parser = go.output_parser
|
|
go.output_parser = function()
|
|
local seen = 0
|
|
return {
|
|
on_line = function()
|
|
seen = seen + 1
|
|
if seen == 1 then
|
|
return {
|
|
passes = {},
|
|
failures = { "TestAwesomeThing/everred" },
|
|
skips = {},
|
|
display = { passes = {}, failures = { "everred" }, skips = {} },
|
|
failures_all = { "TestAwesomeThing" },
|
|
}
|
|
end
|
|
return {
|
|
passes = {},
|
|
failures = { "TestAwesomeThing" },
|
|
skips = {},
|
|
display = { passes = {}, failures = { "TestAwesomeThing" }, skips = {} },
|
|
failures_all = { "TestAwesomeThing" },
|
|
}
|
|
end,
|
|
on_complete = function()
|
|
return nil
|
|
end,
|
|
}
|
|
end
|
|
|
|
local orig_jobstart = stub_jobstart({
|
|
exit_codes = { 1 },
|
|
stdout = {
|
|
{
|
|
vim.json.encode({ Action = "fail", Test = "TestAwesomeThing/everred" }),
|
|
vim.json.encode({ Action = "fail", Test = "TestAwesomeThing" }),
|
|
},
|
|
},
|
|
})
|
|
|
|
core.run_nearest()
|
|
|
|
local qf = vim.fn.getqflist()
|
|
assert.equals(2, #qf)
|
|
assert.equals(path, vim.fn.bufname(qf[1].bufnr))
|
|
assert.equals(path, vim.fn.bufname(qf[2].bufnr))
|
|
local lines = { qf[1].lnum, qf[2].lnum }
|
|
table.sort(lines)
|
|
assert.are.same({ 3, 7 }, lines)
|
|
|
|
vim.fn.jobstart = orig_jobstart
|
|
go.output_parser = orig_parser
|
|
end)
|
|
|
|
it("nutzt Listing-Namen wenn Parser keine Failure-Liste liefert", function()
|
|
local root = vim.fs.joinpath(vim.loop.cwd(), "tests", "tmp_qf_go_listing")
|
|
vim.fn.mkdir(root, "p")
|
|
local path = root .. "/foo_listing_test.go"
|
|
vim.fn.writefile({
|
|
"package foo",
|
|
"",
|
|
"func TestAwesomeThing(t *testing.T) {",
|
|
' t.Run(\"evergreen\", func(t *testing.T) {',
|
|
" })",
|
|
"",
|
|
' t.Run(\"everred\", func(t *testing.T) {',
|
|
" })",
|
|
"}",
|
|
}, path)
|
|
|
|
local bufnr = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_buf_set_name(bufnr, path)
|
|
vim.bo[bufnr].filetype = "go"
|
|
vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, {
|
|
"package foo",
|
|
"",
|
|
"func TestAwesomeThing(t *testing.T) {",
|
|
' t.Run(\"evergreen\", func(t *testing.T) {',
|
|
" })",
|
|
"",
|
|
' t.Run(\"everred\", func(t *testing.T) {',
|
|
" })",
|
|
"}",
|
|
})
|
|
vim.api.nvim_set_current_buf(bufnr)
|
|
vim.api.nvim_win_set_cursor(0, { 6, 0 })
|
|
|
|
local go = require("test-samurai.runners.go")
|
|
local orig_parser = go.output_parser
|
|
go.output_parser = function()
|
|
local step = 0
|
|
return {
|
|
on_line = function()
|
|
step = step + 1
|
|
if step == 1 then
|
|
return {
|
|
passes = {},
|
|
failures = {},
|
|
skips = {},
|
|
display = { passes = {}, failures = { "TestAwesomeThing" }, skips = {} },
|
|
}
|
|
end
|
|
return {
|
|
passes = {},
|
|
failures = {},
|
|
skips = {},
|
|
display = { passes = {}, failures = { "everred" }, skips = {} },
|
|
}
|
|
end,
|
|
on_complete = function()
|
|
return nil
|
|
end,
|
|
}
|
|
end
|
|
|
|
local orig_jobstart = stub_jobstart({
|
|
exit_codes = { 1 },
|
|
stdout = {
|
|
{
|
|
vim.json.encode({ Action = "fail", Test = "TestAwesomeThing/everred" }),
|
|
vim.json.encode({ Action = "fail", Test = "TestAwesomeThing" }),
|
|
},
|
|
},
|
|
})
|
|
|
|
core.run_nearest()
|
|
|
|
local qf = vim.fn.getqflist()
|
|
assert.equals(2, #qf)
|
|
assert.equals(path, vim.fn.bufname(qf[1].bufnr))
|
|
assert.equals(path, vim.fn.bufname(qf[2].bufnr))
|
|
local lines = { qf[1].lnum, qf[2].lnum }
|
|
table.sort(lines)
|
|
assert.are.same({ 3, 7 }, lines)
|
|
|
|
vim.fn.jobstart = orig_jobstart
|
|
go.output_parser = orig_parser
|
|
end)
|
|
|
|
it("mappt Go-Subtests mit durch Unterstriche normalisierten Namen", function()
|
|
local root = vim.fs.joinpath(vim.loop.cwd(), "tests", "tmp_qf_go_norm")
|
|
vim.fn.mkdir(root, "p")
|
|
local path = root .. "/foo_norm_test.go"
|
|
vim.fn.writefile({
|
|
"package foo",
|
|
"",
|
|
"func TestHandleGet(t *testing.T) {",
|
|
' t.Run(\"returns 200 with an list of all badges\", func(t *testing.T) {',
|
|
" })",
|
|
"",
|
|
' t.Run(\"returns 500 on any db error\", func(t *testing.T) {',
|
|
" })",
|
|
"}",
|
|
}, path)
|
|
|
|
local bufnr = vim.api.nvim_create_buf(false, true)
|
|
vim.api.nvim_buf_set_name(bufnr, path)
|
|
vim.bo[bufnr].filetype = "go"
|
|
vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, {
|
|
"package foo",
|
|
"",
|
|
"func TestHandleGet(t *testing.T) {",
|
|
' t.Run(\"returns 200 with an list of all badges\", func(t *testing.T) {',
|
|
" })",
|
|
"",
|
|
' t.Run(\"returns 500 on any db error\", func(t *testing.T) {',
|
|
" })",
|
|
"}",
|
|
})
|
|
vim.api.nvim_set_current_buf(bufnr)
|
|
vim.api.nvim_win_set_cursor(0, { 6, 0 })
|
|
|
|
local orig_jobstart = stub_jobstart({
|
|
exit_codes = { 1 },
|
|
stdout = {
|
|
{
|
|
vim.json.encode({
|
|
Action = "fail",
|
|
Test = "TestHandleGet/returns_500_on_any_db_error",
|
|
}),
|
|
vim.json.encode({ Action = "fail", Test = "TestHandleGet" }),
|
|
},
|
|
},
|
|
})
|
|
|
|
core.run_nearest()
|
|
|
|
local qf = vim.fn.getqflist()
|
|
assert.equals(2, #qf)
|
|
assert.equals(path, vim.fn.bufname(qf[1].bufnr))
|
|
assert.equals(path, vim.fn.bufname(qf[2].bufnr))
|
|
local lines = { qf[1].lnum, qf[2].lnum }
|
|
table.sort(lines)
|
|
assert.are.same({ 3, 7 }, lines)
|
|
|
|
vim.fn.jobstart = orig_jobstart
|
|
end)
|
|
end)
|