158 lines
3.7 KiB
Lua
158 lines
3.7 KiB
Lua
local assert = require('luassert')
|
|
local builtin = require('telescope.builtin')
|
|
|
|
local Job = require("plenary.job")
|
|
|
|
local tester = {}
|
|
|
|
local replace_terms = function(input)
|
|
return vim.api.nvim_replace_termcodes(input, true, false, true)
|
|
end
|
|
|
|
local nvim_feed = function(text, feed_opts)
|
|
feed_opts = feed_opts or "m"
|
|
|
|
vim.api.nvim_feedkeys(text, feed_opts, true)
|
|
end
|
|
|
|
tester.picker_feed = function(input, test_cases, debug)
|
|
input = replace_terms(input)
|
|
|
|
return coroutine.wrap(function()
|
|
for i = 1, #input do
|
|
local char = input:sub(i, i)
|
|
nvim_feed(char, "")
|
|
|
|
-- TODO: I'm not 100% sure this is a hack or not...
|
|
-- it's possible these characters could still have an on_complete... but i'm not sure.
|
|
if string.match(char, "%g") then
|
|
coroutine.yield()
|
|
end
|
|
end
|
|
|
|
vim.wait(10, function() end)
|
|
|
|
local timer = vim.loop.new_timer()
|
|
timer:start(20, 0, vim.schedule_wrap(function()
|
|
if test_cases.post_close then
|
|
for k, v in ipairs(test_cases.post_close) do
|
|
io.stderr:write(vim.fn.json_encode({ case = k, expected = v[1], actual = v[2]() }))
|
|
io.stderr:write("\n")
|
|
end
|
|
end
|
|
|
|
if debug then
|
|
return
|
|
end
|
|
|
|
vim.defer_fn(function()
|
|
vim.cmd [[qa!]]
|
|
end, 10)
|
|
end))
|
|
|
|
if not debug then
|
|
vim.schedule(function()
|
|
if test_cases.post_typed then
|
|
for k, v in ipairs(test_cases.post_typed) do
|
|
io.stderr:write(vim.fn.json_encode({ case = k, expected = v[1], actual = v[2]() }))
|
|
io.stderr:write("\n")
|
|
end
|
|
end
|
|
|
|
nvim_feed(replace_terms("<CR>"), "")
|
|
end)
|
|
end
|
|
coroutine.yield()
|
|
end)
|
|
end
|
|
|
|
-- local test_cases = {
|
|
-- post_typed = {
|
|
-- },
|
|
-- post_close = {
|
|
-- { "README.md", function() return "README.md" end },
|
|
-- },
|
|
-- }
|
|
|
|
local _VALID_KEYS = {
|
|
post_typed = true,
|
|
post_close = true,
|
|
}
|
|
|
|
tester.builtin_picker = function(key, input, test_cases, opts)
|
|
opts = opts or {}
|
|
local debug = opts.debug or false
|
|
|
|
for k, _ in pairs(test_cases) do
|
|
if not _VALID_KEYS[k] then
|
|
-- TODO: Make an error type for the json protocol.
|
|
io.stderr:write(vim.fn.json_encode({ case = k, expected = '<a valid key>', actual = k }))
|
|
io.stderr:write("\n")
|
|
vim.cmd [[qa!]]
|
|
end
|
|
end
|
|
|
|
opts.on_complete = {
|
|
tester.picker_feed(input, test_cases, debug)
|
|
}
|
|
|
|
builtin[key](opts)
|
|
end
|
|
|
|
local get_results_from_file = function(file)
|
|
local j = Job:new {
|
|
command = 'nvim',
|
|
args = {
|
|
'--noplugin',
|
|
'-u',
|
|
'scripts/minimal_init.vim',
|
|
'-c',
|
|
'luafile ' .. file
|
|
},
|
|
}
|
|
|
|
j:sync()
|
|
|
|
local results = j:stderr_result()
|
|
local result_table = {}
|
|
for _, v in ipairs(results) do
|
|
table.insert(result_table, vim.fn.json_decode(v))
|
|
end
|
|
|
|
return result_table
|
|
end
|
|
|
|
local check_results = function(results)
|
|
-- TODO: We should get all the test cases here that fail, not just the first one.
|
|
for _, v in ipairs(results) do
|
|
assert.are.same(v.expected, v.actual)
|
|
end
|
|
end
|
|
|
|
tester.run_string = function(contents)
|
|
local tempname = vim.fn.tempname()
|
|
|
|
contents = [[
|
|
local tester = require('telescope.pickers._test')
|
|
local helper = require('telescope.pickers._test_helpers')
|
|
|
|
helper.make_globals()
|
|
]] .. contents
|
|
|
|
vim.fn.writefile(vim.split(contents, "\n"), tempname)
|
|
local result_table = get_results_from_file(tempname)
|
|
vim.fn.delete(tempname)
|
|
|
|
check_results(result_table)
|
|
-- assert.are.same(result_table.expected, result_table.actual)
|
|
end
|
|
|
|
tester.run_file = function(filename)
|
|
local file = './lua/tests/pickers/' .. filename .. '.lua'
|
|
|
|
local result_table = get_results_from_file(file)
|
|
assert.are.same(result_table.expected, result_table.actual)
|
|
end
|
|
|
|
return tester
|