summaryrefslogtreecommitdiff
path: root/tests/selection_session_test.lua
blob: e6f857bf15f94b1eeba7fd83cd02c4187e566f01 (plain)
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
local entry_path = "yazi-enter.yazi/main.lua"

local file = assert(io.open(entry_path, "rb"))
local source = assert(file:read("*a"))
file:close()

local capture = [[
capture_selection_session {
	run = run_selection_session,
	success = UPDATE_SUCCESS,
	failure = UPDATE_FAILURE,
}
]]

local instrumented_source, replacement_count = source:gsub(
	"\nreturn {\n\tentry = function",
	"\n" .. capture .. "\nreturn {\n\tentry = function",
	1
)
assert(replacement_count == 1, "selection session capture point must occur once")

local model
local environment = {
	error = error,
	getmetatable = getmetatable,
	pairs = pairs,
	pcall = pcall,
	type = type,
	capture_selection_session = function(value)
		model = value
	end,
	ya = { sync = function(callback) return callback end },
}
assert(load(instrumented_source, "@" .. entry_path, "t", environment))()

local function assert_equal(actual, expected, label)
	assert(actual == expected, ("%s: expected %s, got %s"):format(label, tostring(expected), tostring(actual)))
end

local intent = {
	mode = "either",
	previous = false,
	smart = true,
	insensitive = false,
	direction = "forward",
	effective_case = "smart",
}

local function run_case(events, results)
	local calls = {}
	local receiver = { index = 0 }
	function receiver:recv()
		self.index = self.index + 1
		local event = assert(events[self.index], "unexpected receive")
		calls[#calls + 1] = { "receive", event[1], event[2] }
		return event[1], event[2]
	end
	local boundaries = {
		prompt = function(prompt)
			calls[#calls + 1] = { "prompt", prompt }
			return receiver
		end,
		find_update = function(query, policy)
			calls[#calls + 1] = { "update", query, policy }
			local result = table.remove(results, 1)
			return result[1], result[2]
		end,
		commit = function(mode, query)
			calls[#calls + 1] = { "commit", mode, query }
			return 1
		end,
	}
	return model.run(intent, boundaries), calls
end

local result, calls = run_case({ { "a", 3 }, { "alpha", 1 } }, {
	{ model.success, false }, { model.success, false },
})
assert_equal(result, 1, "successful session result")
assert_equal(calls[1][1], "prompt", "START to PROMPT")
assert_equal(calls[2][1], "receive", "PROMPT receives Type")
assert_equal(calls[3][1], "update", "Type enters UPDATE")
assert_equal(calls[4][1], "receive", "UPDATE returns to PROMPT")
assert_equal(calls[5][1], "update", "Submit enters FINALIZE")
assert_equal(calls[6][1], "commit", "FINALIZE enters COMMIT")

result, calls = run_case({ { "[", 3 }, { nil, 2 } }, {
	{ model.failure, "malformed" },
})
assert_equal(result, 0, "recoverable update then cancel")
assert_equal(calls[#calls][2], nil, "Cancel query")

result, calls = run_case({ { "a", 3 }, { "ab", 3 }, { "abc", 3 }, { nil, 2 } }, {
	{ model.success, false }, { model.success, false }, { model.success, false },
})
assert_equal(result, 0, "ordered Type session result")
local update_queries = {}
for _, call in ipairs(calls) do
	if call[1] == "update" then
		update_queries[#update_queries + 1] = call[2]
	end
end
assert_equal(table.concat(update_queries, ","), "a,ab,abc", "sequential Type update order")

result, calls = run_case({ { "complete", 1 } }, { { model.success, false } })
assert_equal(result, 1, "rapid Submit result")
assert_equal(calls[3][1], "update", "rapid Submit final update")
assert_equal(calls[3][2], "complete", "rapid Submit complete query")
assert_equal(calls[4][1], "commit", "rapid Submit commit")
assert_equal(calls[4][3], "complete", "rapid Submit committed query")

result, calls = run_case({ { "[", 1 } }, { { model.failure, "malformed" } })
assert_equal(result, 0, "failed finalization")
assert_equal(calls[#calls][1], "update", "failed FINALIZE ends before COMMIT")

for _, event in ipairs({ 2, 0, 99 }) do
	result, calls = run_case({ { nil, event } }, {})
	assert_equal(result, 0, "passive terminal event " .. event)
	assert_equal(#calls, 2, "passive terminal call count " .. event)
end

print("selection session transition checks passed")