294 lines
8.4 KiB
Lua
294 lines
8.4 KiB
Lua
describe('Error boundary handling', function()
|
|
local cp
|
|
local state
|
|
local logged_messages
|
|
|
|
before_each(function()
|
|
logged_messages = {}
|
|
local mock_logger = {
|
|
log = function(msg, level)
|
|
table.insert(logged_messages, { msg = msg, level = level })
|
|
end,
|
|
set_config = function() end,
|
|
}
|
|
package.loaded['cp.log'] = mock_logger
|
|
|
|
-- Mock dependencies that could fail
|
|
package.loaded['cp.scrape'] = {
|
|
scrape_problem = function(ctx)
|
|
-- Sometimes fail to simulate network issues
|
|
if ctx.contest_id == 'fail_scrape' then
|
|
return {
|
|
success = false,
|
|
error = 'Network error',
|
|
}
|
|
end
|
|
return {
|
|
success = true,
|
|
problem_id = ctx.problem_id,
|
|
test_cases = {
|
|
{ input = '1', expected = '2' },
|
|
},
|
|
test_count = 1,
|
|
}
|
|
end,
|
|
scrape_contest_metadata = function(platform, contest_id)
|
|
if contest_id == 'fail_metadata' then
|
|
return {
|
|
success = false,
|
|
error = 'Contest not found',
|
|
}
|
|
end
|
|
return {
|
|
success = true,
|
|
problems = {
|
|
{ id = 'a' },
|
|
{ id = 'b' },
|
|
},
|
|
}
|
|
end,
|
|
scrape_problems_parallel = function()
|
|
return {}
|
|
end,
|
|
}
|
|
|
|
local cache = require('cp.cache')
|
|
cache.load = function() end
|
|
cache.set_test_cases = function() end
|
|
cache.set_file_state = function() end
|
|
cache.get_file_state = function()
|
|
return nil
|
|
end
|
|
cache.get_contest_data = function()
|
|
return nil
|
|
end
|
|
cache.get_test_cases = function()
|
|
return {}
|
|
end
|
|
|
|
-- Mock vim functions
|
|
if not vim.fn then
|
|
vim.fn = {}
|
|
end
|
|
vim.fn.expand = vim.fn.expand or function()
|
|
return '/tmp/test.cpp'
|
|
end
|
|
vim.fn.mkdir = vim.fn.mkdir or function() end
|
|
if not vim.api then
|
|
vim.api = {}
|
|
end
|
|
vim.api.nvim_get_current_buf = vim.api.nvim_get_current_buf or function()
|
|
return 1
|
|
end
|
|
vim.api.nvim_buf_get_lines = vim.api.nvim_buf_get_lines
|
|
or function()
|
|
return { '' }
|
|
end
|
|
if not vim.cmd then
|
|
vim.cmd = {}
|
|
end
|
|
vim.cmd.e = function() end
|
|
vim.cmd.only = function() end
|
|
if not vim.system then
|
|
vim.system = function(cmd)
|
|
return {
|
|
wait = function()
|
|
return { code = 0 }
|
|
end,
|
|
}
|
|
end
|
|
end
|
|
|
|
state = require('cp.state')
|
|
state.reset()
|
|
|
|
cp = require('cp')
|
|
cp.setup({
|
|
contests = {
|
|
codeforces = {
|
|
default_language = 'cpp',
|
|
cpp = { extension = 'cpp', test = { 'echo', 'test' } },
|
|
},
|
|
},
|
|
scrapers = { 'codeforces' },
|
|
})
|
|
end)
|
|
|
|
after_each(function()
|
|
package.loaded['cp.log'] = nil
|
|
package.loaded['cp.scrape'] = nil
|
|
if state then
|
|
state.reset()
|
|
end
|
|
end)
|
|
|
|
it('should handle setup failures gracefully without breaking runner', function()
|
|
-- Try invalid platform
|
|
cp.handle_command({ fargs = { 'invalid_platform', '1234', 'a' } })
|
|
|
|
-- Should have logged error
|
|
local has_error = false
|
|
for _, log_entry in ipairs(logged_messages) do
|
|
if log_entry.level == vim.log.levels.ERROR then
|
|
has_error = true
|
|
break
|
|
end
|
|
end
|
|
assert.is_true(has_error, 'Should log error for invalid platform')
|
|
|
|
-- State should remain clean
|
|
local context = cp.get_current_context()
|
|
assert.is_nil(context.platform)
|
|
|
|
-- Runner should handle this gracefully
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'run' } }) -- Should log error, not crash
|
|
end)
|
|
end)
|
|
|
|
it('should handle scraping failures without state corruption', function()
|
|
-- Setup should fail due to scraping failure
|
|
cp.handle_command({ fargs = { 'codeforces', 'fail_scrape', 'a' } })
|
|
|
|
-- Should have logged scraping error
|
|
local has_scrape_error = false
|
|
for _, log_entry in ipairs(logged_messages) do
|
|
if log_entry.msg and log_entry.msg:match('scraping failed') then
|
|
has_scrape_error = true
|
|
break
|
|
end
|
|
end
|
|
assert.is_true(has_scrape_error, 'Should log scraping failure')
|
|
|
|
-- State should still be set (platform and contest)
|
|
local context = cp.get_current_context()
|
|
assert.equals('codeforces', context.platform)
|
|
assert.equals('fail_scrape', context.contest_id)
|
|
|
|
-- But should handle run gracefully
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'run' } })
|
|
end)
|
|
end)
|
|
|
|
it('should handle missing contest data without crashing navigation', function()
|
|
-- Setup with valid platform but no contest data
|
|
state.set_platform('codeforces')
|
|
state.set_contest_id('nonexistent')
|
|
state.set_problem_id('a')
|
|
|
|
-- Navigation should fail gracefully
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'next' } })
|
|
end)
|
|
|
|
-- Should log appropriate error
|
|
local has_nav_error = false
|
|
for _, log_entry in ipairs(logged_messages) do
|
|
if log_entry.msg and log_entry.msg:match('no contest metadata found') then
|
|
has_nav_error = true
|
|
break
|
|
end
|
|
end
|
|
assert.is_true(has_nav_error, 'Should log navigation error')
|
|
end)
|
|
|
|
it('should handle validation errors without crashing', function()
|
|
-- This would previously cause validation errors
|
|
state.reset() -- All state is nil
|
|
|
|
-- Commands should handle nil state gracefully
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'next' } })
|
|
end)
|
|
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'prev' } })
|
|
end)
|
|
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'run' } })
|
|
end)
|
|
|
|
-- Should have appropriate errors, not validation errors
|
|
local has_validation_error = false
|
|
local has_appropriate_errors = 0
|
|
for _, log_entry in ipairs(logged_messages) do
|
|
if log_entry.msg and log_entry.msg:match('expected string, got nil') then
|
|
has_validation_error = true
|
|
elseif
|
|
log_entry.msg
|
|
and (log_entry.msg:match('no contest set') or log_entry.msg:match('No contest configured'))
|
|
then
|
|
has_appropriate_errors = has_appropriate_errors + 1
|
|
end
|
|
end
|
|
|
|
assert.is_false(has_validation_error, 'Should not have validation errors')
|
|
assert.is_true(has_appropriate_errors > 0, 'Should have user-facing errors')
|
|
end)
|
|
|
|
it('should handle partial state gracefully', function()
|
|
-- Set only platform, not contest
|
|
state.set_platform('codeforces')
|
|
|
|
-- Commands should handle partial state
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'run' } })
|
|
end)
|
|
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'next' } })
|
|
end)
|
|
|
|
-- Should get appropriate errors about missing contest
|
|
local missing_contest_errors = 0
|
|
for _, log_entry in ipairs(logged_messages) do
|
|
if
|
|
log_entry.msg and (log_entry.msg:match('no contest') or log_entry.msg:match('No contest'))
|
|
then
|
|
missing_contest_errors = missing_contest_errors + 1
|
|
end
|
|
end
|
|
assert.is_true(missing_contest_errors > 0, 'Should report missing contest')
|
|
end)
|
|
|
|
it('should isolate command parsing errors from execution', function()
|
|
-- Test malformed commands
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'cache' } }) -- Missing subcommand
|
|
end)
|
|
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { '--lang' } }) -- Missing value
|
|
end)
|
|
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'too', 'many', 'args', 'here', 'extra' } })
|
|
end)
|
|
|
|
-- All should result in error messages, not crashes
|
|
assert.is_true(#logged_messages > 0, 'Should have logged errors')
|
|
|
|
local crash_count = 0
|
|
for _, log_entry in ipairs(logged_messages) do
|
|
if log_entry.msg and log_entry.msg:match('stack traceback') then
|
|
crash_count = crash_count + 1
|
|
end
|
|
end
|
|
assert.equals(0, crash_count, 'Should not have any crashes')
|
|
end)
|
|
|
|
it('should handle module loading failures gracefully', function()
|
|
-- Test with missing optional dependencies
|
|
local original_picker_module = package.loaded['cp.commands.picker']
|
|
package.loaded['cp.commands.picker'] = nil
|
|
|
|
-- Pick command should handle missing module
|
|
assert.has_no_errors(function()
|
|
cp.handle_command({ fargs = { 'pick' } })
|
|
end)
|
|
|
|
package.loaded['cp.commands.picker'] = original_picker_module
|
|
end)
|
|
end)
|