From c9da9744ca33f65fa431d352172ad66249cff32e Mon Sep 17 00:00:00 2001 From: Jackson Moore Date: Sat, 5 Sep 2026 14:31:10 +0200 Subject: Add Find update boundary tests --- tests/find_update_test.lua | 180 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 180 insertions(+) create mode 100644 tests/find_update_test.lua (limited to 'tests/find_update_test.lua') diff --git a/tests/find_update_test.lua b/tests/find_update_test.lua new file mode 100644 index 0000000..ba57486 --- /dev/null +++ b/tests/find_update_test.lua @@ -0,0 +1,180 @@ +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_find_update { + apply = apply_find, + success = UPDATE_SUCCESS, + failure = UPDATE_FAILURE, + clear_error = ERROR_STATUS_CLEAR, +} +]] + +local instrumented_source, replacement_count = source:gsub( + "\nreturn {\n\tentry = function", + "\n" .. capture .. "\nreturn {\n\tentry = function", + 1 +) +assert(replacement_count == 1, "Find updater capture point must occur once") + +local model +local exec_handler +local plugin_error_reports = 0 +local environment = { + error = error, + getmetatable = getmetatable, + pairs = pairs, + pcall = pcall, + type = type, + capture_find_update = function(value) + model = value + end, + ya = { + sync = function(callback) + return callback + end, + exec = function(...) + return exec_handler(...) + end, + err = function() + plugin_error_reports = plugin_error_reports + 1 + end, + }, +} + +local chunk = assert(load(instrumented_source, "@" .. entry_path, "t", environment)) +chunk() + +assert(type(model) == "table", "Find updater was not captured") +assert(type(model.apply) == "function", "Find updater must be a function") + +local function assert_equal(actual, expected, label) + assert(actual == expected, ("%s: expected %s, got %s"):format(label, tostring(expected), tostring(actual))) +end + +local function assert_request(request, query, policy, label) + assert(type(request) == "table", label .. " request must be a table") + assert(request ~= policy, label .. " request must be separate from the search policy") + assert_equal(request[1], query, label .. " positional query") + assert_equal(request[2], nil, label .. " second positional argument") + assert_equal(request.previous, policy.previous, label .. " previous option") + assert_equal(request.smart, policy.smart, label .. " smart option") + assert_equal(request.insensitive, policy.insensitive, label .. " insensitive option") + assert_equal(type(request.previous), "boolean", label .. " previous type") + assert_equal(type(request.smart), "boolean", label .. " smart type") + assert_equal(type(request.insensitive), "boolean", label .. " insensitive type") + + local expected_keys = { + [1] = true, + previous = true, + smart = true, + insensitive = true, + } + local count = 0 + for key in pairs(request) do + assert(expected_keys[key], label .. " unexpected request key " .. tostring(key)) + count = count + 1 + end + assert_equal(count, 4, label .. " request field count") +end + +local complete_query = "literal ; $(touch ignored)\0tail.*" +local policy = { + previous = true, + smart = false, + insensitive = true, +} +local calls = {} +exec_handler = function(action, request, ...) + assert_equal(select("#", ...), 0, "native Find extra argument count") + calls[#calls + 1] = { action = action, request = request } + return "completed reply" +end + +local result, error_status = model.apply(complete_query, policy) +assert_equal(result, model.success, "completed Find result") +assert_equal(error_status, model.clear_error, "completed Find error status") +assert_equal(#calls, 1, "completed Find call count") +assert_equal(calls[1].action, "find_do", "native Find action") +assert_request(calls[1].request, complete_query, policy, "completed Find") +assert_equal(policy.previous, true, "preserved policy previous") +assert_equal(policy.smart, false, "preserved policy smart") +assert_equal(policy.insensitive, true, "preserved policy insensitive") +assert(not calls[1].action:find(complete_query, 1, true), "query must stay separate from action text") + +local reply_completed = false +local awaited_call +exec_handler = function(action, request) + awaited_call = { action = action, request = request } + local reply = coroutine.yield("manager reply pending") + reply_completed = true + return reply +end + +local awaited_policy = { + previous = false, + smart = true, + insensitive = false, +} +local thread = coroutine.create(function() + return model.apply("awaited query", awaited_policy) +end) +local resumed, pending = coroutine.resume(thread) +assert_equal(resumed, true, "awaited Find first resume") +assert_equal(pending, "manager reply pending", "awaited Find pending marker") +assert_equal(coroutine.status(thread), "suspended", "Find updater while reply is pending") +assert_equal(reply_completed, false, "Find completion before manager reply") +assert_equal(awaited_call.action, "find_do", "awaited native Find action") +assert_request(awaited_call.request, "awaited query", awaited_policy, "awaited Find") + +resumed, result, error_status = coroutine.resume(thread, "manager completed") +assert_equal(resumed, true, "awaited Find second resume") +assert_equal(coroutine.status(thread), "dead", "Find updater after reply") +assert_equal(reply_completed, true, "Find completion after manager reply") +assert_equal(result, model.success, "awaited Find result") +assert_equal(error_status, model.clear_error, "awaited Find error status") + +local dispatcher_reported = false +local failed_call +exec_handler = function(action, request) + failed_call = { action = action, request = request } + coroutine.yield("manager error pending") + dispatcher_reported = true + error("native malformed regular expression", 0) +end + +local failed_policy = { + previous = false, + smart = false, + insensitive = false, +} +thread = coroutine.create(function() + return model.apply("[", failed_policy) +end) +resumed, pending = coroutine.resume(thread) +assert_equal(resumed, true, "failed Find first resume") +assert_equal(pending, "manager error pending", "failed Find pending marker") +assert_equal(coroutine.status(thread), "suspended", "failed Find before manager error") +assert_equal(dispatcher_reported, false, "dispatcher report before failed reply") +assert_equal(failed_call.action, "find_do", "failed native Find action") +assert_request(failed_call.request, "[", failed_policy, "failed Find") + +resumed, result, error_status = coroutine.resume(thread) +assert_equal(resumed, true, "caught Find failure resume") +assert_equal(coroutine.status(thread), "dead", "Find updater after caught failure") +assert_equal(dispatcher_reported, true, "standard dispatcher error report") +assert_equal(result, model.failure, "caught Find result") +assert_equal(error_status, "native malformed regular expression", "caught Find error status") +assert_equal(plugin_error_reports, 0, "duplicate plugin error reports") + +exec_handler = function() + return nil +end +result, error_status = model.apply("corrected", failed_policy) +assert_equal(result, model.success, "Find result after a caught failure") +assert_equal(error_status, model.clear_error, "error status after a caught failure") + +print("Find update checks passed") -- cgit v1.2.3