1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
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
|
