summaryrefslogtreecommitdiff
path: root/tests/selection_session_test.lua
blob: d079bddd41902af3e6b7001eb79fde24500dc446 (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
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
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({ { "[", 3 }, { "valid", 3 }, { "valid", 1 } }, {
	{ model.failure, "malformed" }, { model.success, false }, { model.success, false },
})
assert_equal(result, 1, "recovered Type session result")
assert_equal(calls[3][2], "[", "malformed Type query")
assert_equal(calls[5][2], "valid", "corrected Type query")
assert_equal(calls[7][2], "valid", "corrected final query")
assert_equal(calls[8][1], "commit", "commit after Type recovery")

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

for _, terminal_event in ipairs({ 2, 0 }) do
	local finder_state = "existing"
	local events = { { "latest", 3 }, { nil, terminal_event } }
	local receiver = { index = 0 }
	function receiver:recv()
		self.index = self.index + 1
		return events[self.index][1], events[self.index][2]
	end
	local passive_boundaries = {
		prompt = function() return receiver end,
		find_update = function(query)
			finder_state = query
			return model.success, false
		end,
		commit = function() error("passive close must not commit") end,
	}
	assert_equal(model.run(intent, passive_boundaries), 0, "passive close result " .. terminal_event)
	assert_equal(finder_state, "latest", "finder state after passive close " .. terminal_event)
end

print("selection session transition checks passed")