audit: comprehensive cleanup — delete 8 files, fix buffer bug, cut bloat

tests/helpers.lua

@@ -0,0 +1,9 @@
+local M = {}
+
+function M.assert_eq(a, b, msg)
+  if a ~= b then
+    error(string.format("FAIL: %s — expected %s, got %s", msg, vim.inspect(b), vim.inspect(a)))
+  end
+end
+
+return M

tests/minimal_init.lua

@@ -1,2 +1,3 @@
 -- Minimal init for testing tiny-debugger.nvim
 vim.opt.runtimepath:prepend(vim.fn.getcwd())
+package.path = vim.fn.getcwd() .. "/tests/?.lua;" .. package.path

tests/test_adapters.lua

@@ -1,41 +1,30 @@
--- tests for adapter loader and path resolution
+local assert_eq = require("helpers").assert_eq
 local loader = require("tiny-debugger.adapters.init")
+local dap = require("dap")
 
-local function assert_eq(a, b, msg)
-  if a ~= b then
-    error(string.format("FAIL: %s — expected %s, got %s", msg, vim.inspect(b), vim.inspect(a)))
-  end
-end
-
--- test 1: find_executable returns nil for non-existent binaries
+-- find_executable returns nil for non-existent binaries
 assert_eq(loader.find_executable({ "totally-fake-binary-xyz" }), nil, "non-existent binary returns nil")
 
--- test 2: find_executable finds common system binaries
-local found = loader.find_executable({ "sh" })
-assert_eq(found ~= nil, true, "find_executable finds sh")
+-- find_executable finds common system binaries
+assert_eq(loader.find_executable({ "sh" }) ~= nil, true, "find_executable finds sh")
 
--- test 3: python adapter module loads and has register function
-local py = require("tiny-debugger.adapters.python")
-assert_eq(type(py.register), "function", "python adapter has register()")
+-- all adapter modules load and have register()
+for _, name in ipairs({ "python", "go", "c", "javascript" }) do
+  assert_eq(type(require("tiny-debugger.adapters." .. name).register), "function", name .. " has register()")
+end
 
--- test 4: go adapter module loads and has register function
-local go = require("tiny-debugger.adapters.go")
-assert_eq(type(go.register), "function", "go adapter has register()")
-
--- test 5: register doesn't override existing adapter
-local dap = require("dap")
+-- register doesn't override existing adapter
 dap.adapters.test_adapter = { type = "executable", command = "test" }
 loader.register(dap, "test_adapter", { type = "executable", command = "new" }, {}, {})
 assert_eq(dap.adapters.test_adapter.command, "test", "register doesn't override existing")
 dap.adapters.test_adapter = nil
 
--- test 6: register sets adapter and configs for new adapter
+-- register sets adapter and configs for new adapter
 loader.register(dap, "test_new", { type = "executable", command = "test" }, {
   { type = "test_new", request = "launch", name = "test" },
 }, { "testlang" })
 assert_eq(dap.adapters.test_new.command, "test", "new adapter registered")
 assert_eq(#dap.configurations.testlang, 1, "configs registered for filetype")
--- cleanup
 dap.adapters.test_new = nil
 dap.configurations.testlang = nil
 

tests/test_breakpoints.lua

@@ -1,22 +1,14 @@
--- tests for persistent breakpoints
+local assert_eq = require("helpers").assert_eq
 local td = require("tiny-debugger")
 td.setup()
 
-local function assert_eq(a, b, msg)
-  if a ~= b then
-    error(string.format("FAIL: %s — expected %s, got %s", msg, vim.inspect(b), vim.inspect(a)))
-  end
-end
+-- global x mapping exists
+assert_eq(vim.fn.maparg("x", "n", false, true).desc, "tiny-debugger: toggle breakpoint", "global x mapping")
 
--- test 1: global x mapping exists
-local maparg = vim.fn.maparg("x", "n", false, true)
-assert_eq(maparg.desc, "tiny-debugger: toggle breakpoint", "global x mapping exists")
+-- global X mapping exists
+assert_eq(vim.fn.maparg("X", "n", false, true).desc, "tiny-debugger: conditional breakpoint", "global X mapping")
 
--- test 2: global X mapping exists
-maparg = vim.fn.maparg("X", "n", false, true)
-assert_eq(maparg.desc, "tiny-debugger: conditional breakpoint", "global X mapping exists")
-
--- test 3: persistent-breakpoints API is callable
+-- persistent-breakpoints API is callable
 local api = require("persistent-breakpoints.api")
 assert_eq(type(api.toggle_breakpoint), "function", "toggle_breakpoint is a function")
 assert_eq(type(api.set_conditional_breakpoint), "function", "set_conditional_breakpoint is a function")

tests/test_config.lua

@@ -1,36 +1,29 @@
--- tests for config module
+local assert_eq = require("helpers").assert_eq
 local config = require("tiny-debugger.config")
 
-local function assert_eq(a, b, msg)
-  if a ~= b then
-    error(string.format("FAIL: %s — expected %s, got %s", msg, vim.inspect(b), vim.inspect(a)))
-  end
-end
-
--- test 1: defaults unchanged after empty merge
+-- defaults unchanged after empty merge
 local opts = config.merge({})
 assert_eq(opts.keys.continue, "c", "default continue key")
 assert_eq(opts.help_on_enter, true, "default help_on_enter")
 assert_eq(opts.builtin_adapters, true, "default builtin_adapters")
-assert_eq(#opts.dapui.layouts, 2, "default layout count")
 
--- test 2: partial key override
+-- partial key override
 opts = config.merge({ keys = { continue = "g" } })
 assert_eq(opts.keys.continue, "g", "overridden continue key")
 assert_eq(opts.keys.step_over, "s", "preserved step_over key")
 assert_eq(opts.keys.terminate, "q", "preserved terminate key")
 
--- test 3: disable a key with false
+-- disable a key with false
 opts = config.merge({ keys = { continue = false } })
 assert_eq(opts.keys.continue, false, "disabled continue key")
 assert_eq(opts.keys.step_over, "s", "preserved step_over after disable")
 
--- test 4: override help_on_enter
+-- override help_on_enter
 opts = config.merge({ help_on_enter = false })
 assert_eq(opts.help_on_enter, false, "overridden help_on_enter")
 assert_eq(opts.keys.continue, "c", "keys preserved after help override")
 
--- test 5: merge doesn't mutate defaults
+-- merge doesn't mutate defaults
 config.merge({ keys = { continue = "z" } })
 assert_eq(config.defaults.keys.continue, "c", "defaults not mutated")
 

tests/test_help.lua

@@ -1,40 +1,26 @@
--- tests for help box
+local assert_eq = require("helpers").assert_eq
 local help = require("tiny-debugger.help")
 local config = require("tiny-debugger.config")
 
-local function assert_eq(a, b, msg)
-  if a ~= b then
-    error(string.format("FAIL: %s — expected %s, got %s", msg, vim.inspect(b), vim.inspect(a)))
-  end
-end
-
--- test 1: open creates a valid window
+-- open creates a valid window
 help.open()
 assert_eq(help.is_open(), true, "help window is open")
 
--- test 2: close removes the window
+-- close removes the window
 help.close()
 assert_eq(help.is_open(), false, "help window is closed")
 
--- test 3: remapped key shows in help content
+-- remapped key shows in help content
 config.merge({ keys = { continue = "g" } })
 help.open()
--- read the buffer content
-local wins = vim.api.nvim_list_wins()
 local found_g = false
-for _, w in ipairs(wins) do
-  local buf = vim.api.nvim_win_get_buf(w)
-  local lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
-  for _, line in ipairs(lines) do
-    if line:find("g%s+Continue") then
-      found_g = true
-    end
+for _, w in ipairs(vim.api.nvim_list_wins()) do
+  for _, line in ipairs(vim.api.nvim_buf_get_lines(vim.api.nvim_win_get_buf(w), 0, -1, false)) do
+    if line:find("g%s+Continue") then found_g = true end
   end
 end
 assert_eq(found_g, true, "remapped key 'g' appears in help")
 help.close()
-
--- reset config
 config.merge({})
 
 print("ALL HELP TESTS PASSED")

tests/test_keys.lua

@@ -1,15 +1,8 @@
--- tests for keybinding stash/restore
+local assert_eq = require("helpers").assert_eq
 local td = require("tiny-debugger")
 
-local function assert_eq(a, b, msg)
-  if a ~= b then
-    error(string.format("FAIL: %s — expected %s, got %s", msg, vim.inspect(b), vim.inspect(a)))
-  end
-end
-
 -- set a custom mapping for 'c'
-local custom_called = false
-vim.keymap.set("n", "c", function() custom_called = true end, { buffer = 0, desc = "custom c" })
+vim.keymap.set("n", "c", function() end, { buffer = 0, desc = "custom c" })
 
 -- verify custom mapping exists
 local maparg = vim.fn.maparg("c", "n", false, true)

tests/test_mode.lua

@@ -1,42 +1,32 @@
--- tests for debug mode enter/exit
+local assert_eq = require("helpers").assert_eq
 local td = require("tiny-debugger")
-local mode = require("tiny-debugger.mode")
-
-local function assert_eq(a, b, msg)
-  if a ~= b then
-    error(string.format("FAIL: %s — expected %s, got %s", msg, vim.inspect(b), vim.inspect(a)))
-  end
-end
 
 local function has_buf_map(key)
-  local maps = vim.api.nvim_buf_get_keymap(0, "n")
-  for _, m in ipairs(maps) do
+  for _, m in ipairs(vim.api.nvim_buf_get_keymap(0, "n")) do
     if m.lhs == key then return true end
   end
   return false
 end
 
--- test 1: starts inactive
+-- starts inactive
 assert_eq(td.active(), false, "starts inactive")
 
--- test 2: toggle enters debug mode
+-- toggle enters debug mode
 td.toggle()
 assert_eq(td.active(), true, "active after toggle")
 
--- test 3: keymaps are set
-assert_eq(has_buf_map("c"), true, "continue key mapped")
-assert_eq(has_buf_map("s"), true, "step_over key mapped")
-assert_eq(has_buf_map("d"), true, "step_into key mapped")
-assert_eq(has_buf_map("r"), true, "step_out key mapped")
-assert_eq(has_buf_map("q"), true, "terminate key mapped")
+-- keymaps are set
+for _, key in ipairs({ "c", "s", "d", "r", "q" }) do
+  assert_eq(has_buf_map(key), true, key .. " key mapped")
+end
 
--- test 4: toggle exits debug mode
+-- toggle exits debug mode
 td.toggle()
 assert_eq(td.active(), false, "inactive after second toggle")
 
--- test 5: keymaps are removed
-assert_eq(has_buf_map("c"), false, "continue key removed")
-assert_eq(has_buf_map("s"), false, "step_over key removed")
-assert_eq(has_buf_map("q"), false, "terminate key removed")
+-- keymaps are removed
+for _, key in ipairs({ "c", "s", "d", "r", "q" }) do
+  assert_eq(has_buf_map(key), false, key .. " key removed")
+end
 
 print("ALL MODE TESTS PASSED")