feat: more tests

spec/state_contract_spec.lua

@@ -0,0 +1,248 @@
+describe('State module contracts', function()
+  local cp
+  local state
+  local logged_messages
+  local original_scrape_problem
+  local original_scrape_contest_metadata
+  local original_cache_get_test_cases
+
+  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 scraping to avoid network calls
+    original_scrape_problem = package.loaded['cp.scrape']
+    package.loaded['cp.scrape'] = {
+      scrape_problem = function(ctx)
+        return {
+          success = true,
+          problem_id = ctx.problem_id,
+          test_cases = {
+            { input = 'test input', expected = 'test output' },
+          },
+          test_count = 1,
+        }
+      end,
+      scrape_contest_metadata = function(platform, contest_id)
+        return {
+          success = true,
+          problems = {
+            { id = 'a' },
+            { id = 'b' },
+            { id = 'c' },
+          },
+        }
+      end,
+      scrape_problems_parallel = function()
+        return {}
+      end,
+    }
+
+    -- Mock cache to avoid file system
+    local cache = require('cp.cache')
+    original_cache_get_test_cases = cache.get_test_cases
+    cache.get_test_cases = function(platform, contest_id, problem_id)
+      -- Return some mock test cases
+      return {
+        { input = 'mock input', expected = 'mock output' },
+      }
+    end
+
+    -- Mock cache load/save to be no-ops
+    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
+
+    -- Mock vim functions that might not exist in test
+    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
+    vim.fn.fnamemodify = vim.fn.fnamemodify or function(path)
+      return path
+    end
+    vim.fn.tempname = vim.fn.tempname or function()
+      return '/tmp/session'
+    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
+    vim.cmd.split = function() end
+    vim.cmd.vsplit = function() end
+    if not vim.system then
+      vim.system = function(cmd)
+        return {
+          wait = function()
+            return { code = 0 }
+          end,
+        }
+      end
+    end
+
+    -- Reset state completely
+    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
+    if original_scrape_problem then
+      package.loaded['cp.scrape'] = original_scrape_problem
+    end
+    if original_cache_get_test_cases then
+      local cache = require('cp.cache')
+      cache.get_test_cases = original_cache_get_test_cases
+    end
+    if state then
+      state.reset()
+    end
+  end)
+
+  it('should enforce that all modules use state getters, not direct properties', function()
+    local state_module = require('cp.state')
+
+    -- State module should expose getter functions
+    assert.equals('function', type(state_module.get_platform))
+    assert.equals('function', type(state_module.get_contest_id))
+    assert.equals('function', type(state_module.get_problem_id))
+
+    -- State module should NOT expose internal state properties directly
+    -- (This prevents the bug we just fixed)
+    assert.is_nil(state_module.platform)
+    assert.is_nil(state_module.contest_id)
+    assert.is_nil(state_module.problem_id)
+  end)
+
+  it('should maintain state consistency between context and direct access', function()
+    -- Set up a problem
+    cp.handle_command({ fargs = { 'codeforces', '1234', 'a' } })
+
+    -- Get context through public API
+    local context = cp.get_current_context()
+
+    -- Get values through state module directly
+    local direct_access = {
+      platform = state.get_platform(),
+      contest_id = state.get_contest_id(),
+      problem_id = state.get_problem_id(),
+    }
+
+    -- These should be identical
+    assert.equals(context.platform, direct_access.platform)
+    assert.equals(context.contest_id, direct_access.contest_id)
+    assert.equals(context.problem_id, direct_access.problem_id)
+  end)
+
+  it('should handle nil state values gracefully in all consumers', function()
+    -- Start with clean state (all nil)
+    state.reset()
+
+    -- This should NOT crash with "expected string, got nil"
+    assert.has_no_errors(function()
+      cp.handle_command({ fargs = { 'run' } })
+    end)
+
+    -- Should log appropriate error, not validation error
+    local has_validation_error = false
+    local has_appropriate_error = false
+    for _, log_entry in ipairs(logged_messages) do
+      if log_entry.msg:match('expected string, got nil') then
+        has_validation_error = true
+      elseif log_entry.msg:match('No contest configured') then
+        has_appropriate_error = true
+      end
+    end
+
+    assert.is_false(has_validation_error, 'Should not have validation errors')
+    assert.is_true(has_appropriate_error, 'Should have appropriate user-facing error')
+  end)
+
+  it('should pass state module (not state data) to runner functions', function()
+    -- This is the core bug we fixed - runner expects state module, not state data
+    local run = require('cp.runner.run')
+    local problem = require('cp.problem')
+
+    -- Set up proper state
+    state.set_platform('codeforces')
+    state.set_contest_id('1234')
+    state.set_problem_id('a')
+
+    local ctx = problem.create_context('codeforces', '1234', 'a', {
+      contests = { codeforces = { cpp = { extension = 'cpp' } } },
+    })
+
+    -- This should work - passing the state MODULE
+    assert.has_no_errors(function()
+      run.load_test_cases(ctx, state)
+    end)
+
+    -- This would be the bug - passing state DATA instead of state MODULE
+    local fake_state_data = {
+      platform = 'codeforces',
+      contest_id = '1234',
+      problem_id = 'a',
+    }
+
+    -- This should fail gracefully (function should check for get_* methods)
+    local success = pcall(function()
+      run.load_test_cases(ctx, fake_state_data)
+    end)
+
+    -- The current implementation would crash because fake_state_data has no get_* methods
+    -- This test documents the expected behavior
+    assert.is_false(success, 'Should fail when passed wrong state type')
+  end)
+
+  it('should handle state transitions correctly', function()
+    -- Test that state changes are reflected everywhere
+
+    -- Initial state
+    cp.handle_command({ fargs = { 'codeforces', '1234', 'a' } })
+    assert.equals('a', cp.get_current_context().problem_id)
+
+    -- Navigate to next problem
+    cp.handle_command({ fargs = { 'codeforces', '1234', 'b' } })
+    assert.equals('b', cp.get_current_context().problem_id)
+
+    -- State should be consistent everywhere
+    assert.equals('b', state.get_problem_id())
+  end)
+end)