Minitest Ebt Lua

child.lua([[
    local winnr, cursor = ...
    vim.api.nvim_win_set_cursor(winnr, cursor)
]], { window_handle, { 2, 3 } })

-- Good: mock a collaborator so this test is only about my_function
M.fetch_data = function(_path) return { lines = { 'a', 'b' } } end

-- Good: mock a vim API with side effects not relevant to this test
vim.notify = function() end

-- Bad: mock vim.api.nvim_create_buf — let neovim do this for real

child.lua([[
    _G.fixture.keymap_set_args = {}
    vim.keymap.set = function(modes, lhs, rhs, opts)
        _G.fixture.keymap_set_args[lhs] = { modes = modes, lhs = lhs, rhs = rhs, opts = opts }
    end
    M.my_function()
]])

local modes = child.lua_get([[_G.fixture.keymap_set_args['<Esc>'].modes]])
eq(modes, 'n')

child.lua([[
    _G.fixture.callback_called = false
    M.get_callback = function()
        return function() _G.fixture.callback_called = true end
    end
    M.my_function()
]])

-- trigger the callback
child.lua([[_G.fixture.keymap_set_args['q'].rhs()]])
local called = child.lua_get([[_G.fixture.callback_called]])
eq(called, true)

_G.fixture = {}                          -- reset at top-level pre_case
_G.fixture.bufnr = <number>              -- buffer handles captured inside child.lua
_G.fixture.winnr = <number>              -- window handles captured inside child.lua
_G.fixture.captured_args = <any>         -- spy captures
_G.fixture.some_flag = false             -- boolean sentinels

child.lua([[
    local buf = vim.api.nvim_create_buf(true, true)
    vim.api.nvim_buf_set_lines(buf, 0, -1, false, ...)
    vim.api.nvim_set_current_buf(buf)
    _G.fixture.bufnr = buf
    _G.fixture.winnr = vim.api.nvim_get_current_win()
]], { { 'line1', 'line2', 'line3' } })

eq(result, vim.NIL)   -- function returned nil

local new_set = MiniTest.new_set
local eq = MiniTest.expect.equality

local child = MiniTest.new_child_neovim()

-- ──────────────────────────────────────────────────────────────────────────────────────────────
-- utility

local test_logging = [[
    _G.test_logs = {}
    _G.captured_prints = {}
    local original_print = print
    print = function(...)
      local args = {...}
      local msg = table.concat(vim.tbl_map(tostring, args), ' ')
      table.insert(_G.captured_prints, msg)
      original_print(...)
    end
]]

local print_test_logging = function()
    local captured_prints = child.lua_get('_G.captured_prints')
    if captured_prints and #captured_prints > 0 then
        print('\n=== Child Neovim Print Statements ===')
        for i, msg in ipairs(captured_prints) do
            print(string.format('[%d] %s', i, msg))
        end
        print('=== End Print Statements ===\n')
    end
end

-- ──────────────────────────────────────────────────────────────────────────────────────────────
-- setup

local T = new_set({
    hooks = {
        pre_case = function()
            child.restart({ '-u', 'scripts/minimal_init.lua' })
            child.lua([[
                package.loaded['myplugin.utils'] = {
                    read_lines = function(_) return {} end,
                }
                _G.Lib = {
                    compute = function(_s1, _s2, _opts) return nil end,
                }
                vim.system = function(_cmd, _opts)
                    return { wait = function() return { code = 0, stdout = '', stderr = '' } end }
                end
            ]])
            child.lua([[M = require('myplugin.view')]])
            child.lua([[_G.fixture = {}]])
            child.lua(test_logging)
        end,
        post_case = print_test_logging,
        post_once = child.stop,
    },
})

-- ──────────────────────────────────────────────────────────────────────────────────────────────
-- open_buffer() - example based tests

T['open_buffer()'] = new_set({
    hooks = {
        pre_case = function()
            child.lua([[
                vim.fn.expand = function(_) return '/fake/file.lua' end
                vim.api.nvim_get_current_buf = function() return 99 end
                M.load_content = function(_buf, _path) end
                M.setup_keymaps = function(_buf) end
            ]])
        end,
    }
})

T['open_buffer()']['binds escape key to close'] = function()
    child.lua([[
        _G.fixture.keymap_set_args = {}
        vim.keymap.set = function(modes, lhs, rhs, opts)
            _G.fixture.keymap_set_args[lhs] = { modes = modes, rhs = rhs, opts = opts }
        end
        M.open_buffer('HEAD')
    ]])

    local modes = child.lua_get([[_G.fixture.keymap_set_args['<Esc>'].modes]])
    local silent = child.lua_get([[_G.fixture.keymap_set_args['<Esc>'].opts.silent]])
    eq(modes, 'n')
    eq(silent, true)
end

T['open_buffer()']['returns nil when file is not readable'] = function()
    child.lua([[
        vim.fn.filereadable = function(_) return 0 end
    ]])

    local result = child.lua_get([[(function()
        local ok, val = pcall(M.open_buffer, 'HEAD')
        if not ok then return nil end
        return val
    end)()]])

    eq(result, vim.NIL)
end

-- ──────────────────────────────────────────────────────────────────────────────────────────────
-- get_cursor_position() - example based tests

T['get_cursor_position()'] = new_set()

T['get_cursor_position()']['returns winnr and cursor for current window'] = function()
    child.lua([[
        local buf = vim.api.nvim_create_buf(true, true)
        vim.api.nvim_buf_set_lines(buf, 0, -1, false, { 'line1', 'line2' })
        local winnr, cursor = ...
        vim.api.nvim_set_current_win(winnr)
        vim.api.nvim_set_current_buf(buf)
        vim.api.nvim_win_set_cursor(winnr, cursor)
        _G.fixture.winnr = winnr
    ]], { 1000, { 2, 3 } })

    child.lua([[
        local pos = M.get_cursor_position()
        _G.fixture.result = pos
    ]])

    local result = child.lua_get([[_G.fixture.result]])
    eq(result.winnr, 1000)
    eq(result.cursor, { 2, 3 })
end

return T