barrett/cp.nvim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

just delete it

Browse source
This commit is contained in:
Barrett Ruth 2025-09-19 00:35:45 -04:00
parent f4b588c1ab
commit 8e3c372195
1 changed files with 0 additions and 542 deletions
Download patch file Download diff file Expand all files Collapse all files

542
spec/integration_spec.lua
View file

@ -1,542 +0,0 @@
describe('cp integration', function()
local cp
local mock_cache
local mock_system_calls
local mock_log_messages
local temp_files
before_each(function()
cp = require('cp')
mock_cache = {
load = function() end,
get_contest_data = function()
return nil
end,
set_contest_data = function() end,
get_test_cases = function()
return nil
end,
set_test_cases = function() end,
}
mock_system_calls = {}
mock_log_messages = {}
temp_files = {}
vim.system = function(cmd, opts)
table.insert(mock_system_calls, { cmd = cmd, opts = opts })
local result = { code = 0, stdout = '{}', stderr = '' }
if cmd[1] == 'ping' then
result = { code = 0, stdout = '', stderr = '' }
elseif cmd[1] == 'uv' and cmd[2] == 'sync' then
result = { code = 0, stdout = 'Dependencies synced', stderr = '' }
elseif cmd[1] == 'uv' and cmd[2] == 'run' then
if vim.tbl_contains(cmd, 'metadata') then
result.stdout =
'{"success": true, "problems": [{"id": "a", "name": "Problem A"}, {"id": "b", "name": "Problem B"}]}'
elseif vim.tbl_contains(cmd, 'tests') then
result.stdout = '{"success": true, "tests": [{"input": "1 2", "expected": "3"}]}'
end
end
return {
wait = function()
return result
end,
}
end
vim.fn = vim.tbl_extend('force', vim.fn, {
executable = function()
return 1
end,
isdirectory = function()
return 1
end,
filereadable = function(path)
return temp_files[path] and 1 or 0
end,
readfile = function(path)
return temp_files[path] or {}
end,
writefile = function(lines, path)
temp_files[path] = lines
end,
mkdir = function() end,
fnamemodify = function(path, modifier)
if modifier == ':e' then
return path:match('%.([^.]+)$') or ''
elseif modifier == ':h:h:h' then
return '/test/plugin/path'
end
return path
end,
})
vim.api = vim.tbl_extend('force', vim.api or {}, {
nvim_get_current_buf = function()
return 1
end,
nvim_buf_get_lines = function()
return { '' }
end,
nvim_get_option_value = function()
return 'cpp'
end,
nvim_buf_set_lines = function() end,
nvim_win_set_cursor = function() end,
nvim_input = function() end,
})
local cmd_table = {
split = function() end,
vsplit = function() end,
diffthis = function() end,
e = function() end,
startinsert = function() end,
stopinsert = function() end,
}
vim.cmd = setmetatable(cmd_table, {
__call = function(_, cmd_str)
if cmd_str == 'silent only' then
return
end
if cmd_str:match('^e ') then
return
end
if cmd_str == 'startinsert' then
return
end
if cmd_str == 'stopinsert' then
return
end
end,
__index = cmd_table,
__newindex = cmd_table,
})
vim.schedule = function(fn)
fn()
end
package.loaded['cp.cache'] = mock_cache
package.loaded['cp.log'] = {
log = function(msg, level)
table.insert(mock_log_messages, { msg = msg, level = level or vim.log.levels.INFO })
end,
set_config = function() end,
}
cp.setup({
contests = {
atcoder = {
default_language = 'cpp',
timeout_ms = 2000,
cpp = {
compile = { 'g++', '{source}', '-o', '{binary}' },
run = { '{binary}' },
},
},
},
scrapers = { 'atcoder' },
})
end)
after_each(function()
package.loaded['cp.cache'] = nil
package.loaded['cp.log'] = nil
vim.cmd('silent! %bwipeout!')
end)
describe('full workflow', function()
it('handles complete contest setup workflow', function()
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
local found_metadata_call = false
local found_tests_call = false
for _, call in ipairs(mock_system_calls) do
if vim.tbl_contains(call.cmd, 'metadata') then
found_metadata_call = true
end
if vim.tbl_contains(call.cmd, 'tests') then
found_tests_call = true
end
end
assert.is_true(found_metadata_call)
assert.is_true(found_tests_call)
end)
it('integrates scraping with problem creation', function()
local stored_contest_data = nil
local stored_test_cases = nil
mock_cache.set_contest_data = function(platform, contest_id, data)
stored_contest_data = { platform = platform, contest_id = contest_id, data = data }
end
mock_cache.set_test_cases = function(platform, contest_id, problem_id, test_cases)
stored_test_cases = {
platform = platform,
contest_id = contest_id,
problem_id = problem_id,
test_cases = test_cases,
}
end
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
assert.is_not_nil(stored_contest_data)
assert.equals('atcoder', stored_contest_data.platform)
assert.equals('abc123', stored_contest_data.contest_id)
assert.is_not_nil(stored_test_cases)
assert.equals('a', stored_test_cases.problem_id)
end)
it('coordinates between modules correctly', function()
local test_module = require('cp.test')
local state = test_module.get_test_panel_state()
state.test_cases = {
{
input = '1 2',
expected = '3',
status = 'pending',
},
}
local context = {
source_file = 'test.cpp',
binary_file = 'test.run',
input_file = 'io/test.cpin',
expected_file = 'io/test.cpout',
}
local contest_config = {
default_language = 'cpp',
timeout_ms = 2000,
cpp = {
run = { '{binary}' },
},
}
temp_files['test.run'] = {}
vim.system = function()
return {
wait = function()
return { code = 0, stdout = '3\n', stderr = '' }
end,
}
end
local success = test_module.run_test_case(context, contest_config, 1)
assert.is_true(success)
assert.equals('pass', state.test_cases[1].status)
end)
end)
describe('scraper integration', function()
it('integrates with python scrapers correctly', function()
mock_cache.get_contest_data = function()
return nil
end
cp.handle_command({ fargs = { 'atcoder', 'abc123' } })
local found_uv_call = false
for _, call in ipairs(mock_system_calls) do
if call.cmd[1] == 'uv' and call.cmd[2] == 'run' then
found_uv_call = true
break
end
end
assert.is_true(found_uv_call)
end)
it('processes scraper output correctly', function()
vim.system = function(cmd)
if cmd[1] == 'ping' then
return {
wait = function()
return { code = 0 }
end,
}
elseif cmd[1] == 'uv' and cmd[2] == 'sync' then
return {
wait = function()
return { code = 0 }
end,
}
elseif vim.tbl_contains(cmd, 'metadata') then
return {
wait = function()
return {
code = 0,
stdout = '{"success": true, "problems": [{"id": "a", "name": "Problem A"}, {"id": "b", "name": "Problem B"}]}',
}
end,
}
end
return {
wait = function()
return { code = 0 }
end,
}
end
cp.handle_command({ fargs = { 'atcoder', 'abc123' } })
local success_logged = false
for _, log_entry in ipairs(mock_log_messages) do
if log_entry.msg:match('loaded 2 problems for atcoder abc123') then
success_logged = true
break
end
end
assert.is_true(success_logged)
end)
end)
describe('buffer coordination', function()
it('manages multiple buffers correctly', function()
temp_files['abc123a.cpp'] = { '#include <iostream>' }
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
local initial_buf_count = #vim.api.nvim_list_bufs()
assert.is_true(initial_buf_count >= 1)
vim.cmd('enew')
local after_enew_count = #vim.api.nvim_list_bufs()
assert.is_true(after_enew_count > initial_buf_count)
end)
it('coordinates window layouts properly', function()
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
local initial_windows = vim.api.nvim_list_wins()
vim.cmd('split')
local split_windows = vim.api.nvim_list_wins()
assert.is_true(#split_windows > #initial_windows)
end)
it('handles buffer state consistency', function()
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
local context = cp.get_current_context()
assert.equals('atcoder', context.platform)
assert.equals('abc123', context.contest_id)
assert.equals('a', context.problem_id)
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'b' } })
local updated_context = cp.get_current_context()
assert.equals('b', updated_context.problem_id)
end)
end)
describe('cache and persistence', function()
it('maintains data consistency across sessions', function()
local cached_data = {
problems = { { id = 'a', name = 'Problem A' } },
}
mock_cache.get_contest_data = function(platform, contest_id)
if platform == 'atcoder' and contest_id == 'abc123' then
return cached_data
end
end
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
local no_scraper_calls = true
for _, call in ipairs(mock_system_calls) do
if vim.tbl_contains(call.cmd, 'metadata') then
no_scraper_calls = false
break
end
end
assert.is_true(no_scraper_calls)
end)
it('handles concurrent access properly', function()
local access_count = 0
mock_cache.get_contest_data = function()
access_count = access_count + 1
return { problems = { { id = 'a', name = 'Problem A' } } }
end
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
cp.handle_command({ fargs = { 'next' } })
assert.is_true(access_count >= 1)
end)
it('recovers from interrupted operations', function()
vim.system = function(cmd)
if cmd[1] == 'ping' then
return {
wait = function()
return { code = 0 }
end,
}
elseif cmd[1] == 'uv' and cmd[2] == 'sync' then
return {
wait = function()
return { code = 0 }
end,
}
elseif vim.tbl_contains(cmd, 'metadata') then
return {
wait = function()
return { code = 1, stderr = 'interrupted' }
end,
}
end
return {
wait = function()
return { code = 0 }
end,
}
end
assert.has_no_errors(function()
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
end)
local error_logged = false
for _, log_entry in ipairs(mock_log_messages) do
if log_entry.level >= vim.log.levels.WARN then
error_logged = true
break
end
end
assert.is_true(error_logged)
end)
end)
describe('error propagation', function()
it('handles errors across module boundaries', function()
vim.system = function()
error('system call failed')
end
assert.has_error(function()
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
end)
end)
it('provides coherent error messages', function()
cp.handle_command({ fargs = {} })
local usage_error = false
for _, log_entry in ipairs(mock_log_messages) do
if log_entry.level == vim.log.levels.ERROR and log_entry.msg:match('Usage:') then
usage_error = true
break
end
end
assert.is_true(usage_error)
end)
it('maintains system stability on errors', function()
vim.system = function(cmd)
if cmd[1] == 'ping' then
return {
wait = function()
return { code = 0 }
end,
}
elseif cmd[1] == 'uv' and cmd[2] == 'sync' then
return {
wait = function()
return { code = 0 }
end,
}
elseif vim.tbl_contains(cmd, 'metadata') then
return {
wait = function()
return { code = 1, stderr = 'scraper failed' }
end,
}
end
return {
wait = function()
return { code = 0 }
end,
}
end
assert.has_no_errors(function()
cp.handle_command({ fargs = { 'atcoder', 'abc123' } })
assert.is_true(cp.is_initialized())
end)
end)
end)
describe('performance', function()
it('handles large contest data efficiently', function()
local large_problems = {}
for i = 1, 100 do
table.insert(large_problems, { id = string.char(96 + i % 26), name = 'Problem ' .. i })
end
vim.system = function(cmd)
if vim.tbl_contains(cmd, 'metadata') then
return {
wait = function()
return {
code = 0,
stdout = vim.json.encode({ success = true, problems = large_problems }),
}
end,
}
end
return {
wait = function()
return { code = 0 }
end,
}
end
local start_time = vim.uv.hrtime()
cp.handle_command({ fargs = { 'atcoder', 'abc123' } })
local elapsed = (vim.uv.hrtime() - start_time) / 1000000
assert.is_true(elapsed < 1000)
end)
it('manages memory usage appropriately', function()
local initial_buf_count = #vim.api.nvim_list_bufs()
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'b' } })
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'c' } })
local final_buf_count = #vim.api.nvim_list_bufs()
local buf_increase = final_buf_count - initial_buf_count
assert.is_true(buf_increase < 10)
end)
it('maintains responsiveness during operations', function()
local call_count = 0
vim.system = function()
call_count = call_count + 1
vim.wait(10)
return {
wait = function()
return { code = 0, stdout = '{}' }
end,
}
end
local start_time = vim.uv.hrtime()
cp.handle_command({ fargs = { 'atcoder', 'abc123', 'a' } })
local elapsed = (vim.uv.hrtime() - start_time) / 1000000
assert.is_true(elapsed < 500)
assert.is_true(call_count > 0)
end)
end)
end)