Update tests to more accurately measure highlights

Author: aaronik

lua/treewalker/operations.lua

@@ -39,24 +39,18 @@ end
 ---@param hl_group string
 function M.highlight(range, duration, hl_group)
   local start_row, start_col, end_row, end_col = range[1], range[2], range[3], range[4]
-  local ns_prefix = "treewalker.nvim-movement-highlight-"
-  local ns_name =  ns_prefix .. util.guid()
-  local local_ns_id = vim.api.nvim_create_namespace(ns_name)
+  local ns_name = "treewalker.nvim-movement-highlight"
+  local ns_id = vim.api.nvim_create_namespace(ns_name)
 
   -- clear any previous highlights so there aren't multiple active at the same time
-  -- Find them by prefix, whole local name will only be used for timeout below
-  for name, id in pairs(vim.api.nvim_get_namespaces()) do
-    if vim.startswith(name, ns_prefix) then
-      vim.api.nvim_buf_clear_namespace(0, id, 0, -1)
-    end
-  end
+  vim.api.nvim_buf_clear_namespace(0, ns_id, 0, -1)
 
   if vim.hl then
     -- vim.hl.range (Neovim 0.10+ replacement for nvim_buf_add_highlight)
     -- Has timeout option, but when it expires, _auto clears whole namespace_ for pete's sake
     vim.hl.range(
       0,
-      local_ns_id,
+      ns_id,
       hl_group,
       { start_row, start_col },
       { end_row, end_col },
@@ -65,13 +59,13 @@ function M.highlight(range, duration, hl_group)
   else
     -- support for lower versions of neovim
     for row = start_row, end_row do
-      vim.api.nvim_buf_add_highlight(0, local_ns_id, hl_group, row, 0, -1)
+      vim.api.nvim_buf_add_highlight(0, ns_id, hl_group, row, 0, -1)
     end
   end
 
   -- Remove the local highlight after delay
   vim.defer_fn(function()
-    vim.api.nvim_buf_clear_namespace(0, local_ns_id, start_row, end_row + 1)
+    vim.api.nvim_buf_clear_namespace(0, ns_id, start_row, end_row + 1)
   end, duration)
 end
 

tests/treewalker/helpers.lua

@@ -81,16 +81,40 @@ end
 ---@param scol integer
 ---@param erow integer
 ---@param ecol integer
----@param stoob any
----@param desc string | nil
-function M.assert_highlighted(srow, scol, erow, ecol, stoob, desc)
-  assert(#stoob.calls >= 1, "highlight was not called at all")
-
-  assert.same(
-    { srow - 1, scol - 1, erow - 1, ecol },
-    stoob.calls[#stoob.calls].refs[1],
-    "highlight wrong for: " .. (desc or "")
-  )
+function M.assert_highlighted(srow, scol, erow, ecol)
+  local ns_id = vim.api.nvim_create_namespace("treewalker.nvim-movement-highlight")
+  local highlights = vim.api.nvim_buf_get_extmarks(0, ns_id, 0, -1, { details = true })
+
+  for _, highlight in ipairs(highlights) do
+    local actual_srow = highlight[2] + 1
+    local actual_scol = highlight[3] + 1
+    local actual_erow = highlight[4].end_row + 1
+    local actual_ecol = highlight[4].end_col
+
+    -- print("actual_srow:", actual_srow)
+    -- print("actual_scol:", actual_scol)
+    -- print("actual_erow:", actual_erow)
+    -- print("actual_ecol:", actual_ecol)
+
+    if
+        srow == actual_srow
+        and scol == actual_scol
+        and erow == actual_erow
+        and ecol == actual_ecol
+    then
+      return true
+    end
+  end
+
+  assert(false, "Specified highlight not found")
+end
+
+-- Get count of active treewalker highlights
+---@return integer
+function M.get_highlight_count()
+  local ns_id = vim.api.nvim_create_namespace("treewalker.nvim-movement-highlight")
+  local highlights = vim.api.nvim_buf_get_extmarks(0, ns_id, 0, -1, {})
+  return #highlights
 end
 
 return M

tests/treewalker/highlight_spec.lua

@@ -1,199 +1,181 @@
-local spy = require('luassert.spy')
-local match = require('luassert.match')
 local load_fixture = require "tests.load_fixture"
-local stub = require 'luassert.stub'
 local assert = require "luassert"
+local stub = require 'luassert.stub'
 local tw = require 'treewalker'
 local h = require 'tests.treewalker.helpers'
 local operations = require 'treewalker.operations'
 
--- Test for highlight clear-before-highlight behavior
-describe("Clears previous highlights before applying new", function()
-  local clear_spy, hlrange_spy
+describe("Highlights", function()
+  load_fixture("/lua.lua")
 
   before_each(function()
-    clear_spy = spy.on(vim.api, "nvim_buf_clear_namespace")
-    hlrange_spy = spy.on(vim.hl, "range")
-  end)
-
-  after_each(function()
-    clear_spy:revert()
-    hlrange_spy:revert()
-  end)
-
-  it("calls clear_namespace before every highlight", function()
-    local range1 = { 1, 2, 3, 4 }
-    local range2 = { 10, 2, 12, 4 }
-    operations.highlight(range1, 50, "CursorLine")
-    operations.highlight(range2, 50, "CursorLine")
-
-    -- For each highlight call, we should first clear, then range highlight
-    assert.spy(clear_spy).was.called_with(0, match.is_number(), 0, -1)
-    assert.spy(clear_spy).was.called(3)
-    assert.spy(hlrange_spy).was.called(2)
-    -- check arguments
-    local call1 = hlrange_spy.calls[1].vals
-    local call2 = hlrange_spy.calls[2].vals
-    assert.equal(0, call1[1])
-    assert.is_number(call1[2])
-    assert.equal("CursorLine", call1[3])
-    assert.same({1,2}, call1[4])
-    assert.same({3,4}, call1[5])
-    assert.same({ inclusive = true }, call1[6])
-
-    assert.equal(0, call2[1])
-    assert.is_number(call2[2])
-    assert.equal("CursorLine", call2[3])
-    assert.same({10,2}, call2[4])
-    assert.same({12,4}, call2[5])
-    assert.same({ inclusive = true }, call2[6])
-  end)
-end)
+    -- Clear any leftover namespaces from previous tests
+    local ns_id = vim.api.nvim_create_namespace("treewalker.nvim-movement-highlight")
+    vim.api.nvim_buf_clear_namespace(0, ns_id, 0, -1)
 
-describe("Highlights in a lua spec file: ", function()
-  local highlight_stub
+    tw.setup({ highlight = true, highlight_duration = 5 })
+  end)
 
-  load_fixture("/lua-spec.lua")
+  it("creates visible highlights when moving and clears them after timeout", function()
+    -- Start with clean state - count initial highlights
+    local initial_count = h.get_highlight_count()
+    assert.equal(0, initial_count)
 
-  before_each(function()
-    highlight_stub = stub.new(operations, "highlight")
-  end)
+    vim.fn.cursor(10, 1)
+    tw.move_down()
 
-  after_each(function()
-    highlight_stub:revert()
-  end)
+    local after_move_count = h.get_highlight_count()
+    assert.equal(1, after_move_count, "No OG highlight detected")
 
-  it("highlights full block on move_in() (identified in gh #30)", function()
-    vim.fn.cursor(64, 3)
-    tw.move_in()
-    h.assert_highlighted(67, 5, 85, 8, highlight_stub, "it block")
+    -- Wait for timeout and verify highlights are cleared
+    vim.wait(20, function() return false end)
+    local after_timeout_count = h.get_highlight_count()
+    assert.equal(0, after_timeout_count, "Highlights not cleared after timeout")
   end)
-end)
 
-describe("Highlights in a regular lua file: ", function()
-  local highlight_stub
+  it("clears previous highlights when making new movement", function()
+    assert.equal(0, h.get_highlight_count())
 
-  load_fixture("/lua.lua")
+    vim.fn.cursor(10, 1)
+    tw.move_down()
+    tw.move_up()
 
-  before_each(function()
-    highlight_stub = stub.new(operations, "highlight")
+    assert.equal(1, h.get_highlight_count())
   end)
 
-  after_each(function()
-    highlight_stub:revert()
-  end)
+  it("does not create highlights when highlight option is disabled", function()
+    tw.setup({ highlight = false })
+    assert.equal(0, h.get_highlight_count())
 
-  it("respects default highlight option", function()
-    tw.setup() -- highlight defaults to true, doesn't blow up with empty setup
-    vim.fn.cursor(23, 5)
-    tw.move_out()
+    vim.fn.cursor(10, 1)
     tw.move_down()
     tw.move_up()
     tw.move_in()
-    assert.equal(4, #highlight_stub.calls)
+    tw.move_out()
+
+    assert.equal(0, h.get_highlight_count(), "Highlights created when disabled")
   end)
 
-  it("respects highlight config option", function()
-    highlight_stub = stub.new(operations, "highlight")
-    tw.setup({ highlight = false })
-    vim.fn.cursor(23, 5)
-    tw.move_out()
-    tw.move_down()
-    tw.move_up()
+  it("highlights appear when moving in any direction", function()
+    assert.equal(0, h.get_highlight_count())
+
+    vim.fn.cursor(10, 1)
     tw.move_in()
-    assert.equal(0, #highlight_stub.calls)
 
-    highlight_stub = stub(operations, "highlight")
-    tw.setup({ highlight = true })
-    vim.fn.cursor(23, 5)
-    tw.move_out()
-    tw.move_down()
-    tw.move_up()
+    assert.equal(1, h.get_highlight_count())
+  end)
+
+  it("highlights full block on move_in() (identified in gh #30)", function()
+    vim.fn.cursor(21, 1)
     tw.move_in()
-    assert.equal(4, #highlight_stub.calls)
+    h.assert_highlighted(22, 3, 26, 5)
   end)
 
   it("respects default highlight_duration", function()
-    tw.setup({ highlight = true })
-    tw.move_out()
-    local duration_arg = highlight_stub.calls[1].refs[2]
-    assert.equal(250, duration_arg)
-  end)
+    -- Clear any leftover namespaces from previous tests
+    local ns_id = vim.api.nvim_create_namespace("treewalker.nvim-movement-highlight")
+    vim.api.nvim_buf_clear_namespace(0, ns_id, 0, -1)
+
+    -- Directly set opts to default values to bypass before_each
+    local tw_init = require('treewalker')
+    tw_init.opts = {
+      highlight = true,
+      highlight_duration = 250,
+      highlight_group = "CursorLine",
+      jumplist = true,
+    }
+
+    -- Stub the highlight function to capture arguments
+    local highlight_stub = stub.new(operations, "highlight")
 
-  it("respects highlight_duration config option", function()
-    local duration = 50
-    tw.setup({ highlight = true, highlight_duration = duration })
-    tw.move_out()
+    vim.fn.cursor(10, 1)
     tw.move_down()
-    tw.move_up()
-    tw.move_in()
-    assert.stub(highlight_stub).was.called(4)
+
+    -- Verify highlight function was called with default duration (250)
+    assert.stub(highlight_stub).was.called(1)
     local duration_arg = highlight_stub.calls[1].refs[2]
-    assert.equal(duration, duration_arg)
+    assert.equal(250, duration_arg)
+
+    -- Restore the original function
+    highlight_stub:revert()
   end)
 
   it("respects default highlight_group", function()
-    tw.setup({ highlight = true, highlight_duration = 250 })
+    tw.setup({ highlight = true })
+
+    vim.fn.cursor(10, 1)
     tw.move_down()
-    local hl_group_arg = highlight_stub.calls[1].refs[3]
-    assert.equal("CursorLine", hl_group_arg)
+
+    -- Verify the highlight uses the default group
+    local ns_id = vim.api.nvim_create_namespace("treewalker.nvim-movement-highlight")
+    local highlights = vim.api.nvim_buf_get_extmarks(0, ns_id, 0, -1, { details = true })
+
+    assert.equal(1, #highlights)
+    assert.equal("CursorLine", highlights[1][4].hl_group)
   end)
 
   it("respects highlight_group config option", function()
-    tw.setup({ highlight = true, highlight_duration = 50, highlight_group = "DiffAdd" })
+    tw.setup({ highlight = true, highlight_group = "DiffAdd" })
+
+    vim.fn.cursor(10, 1)
     tw.move_down()
-    local hl_group_arg = highlight_stub.calls[1].refs[3]
-    assert.equal("DiffAdd", hl_group_arg)
+
+    -- Verify the highlight uses the configured group
+    local ns_id = vim.api.nvim_create_namespace("treewalker.nvim-movement-highlight")
+    local highlights = vim.api.nvim_buf_get_extmarks(0, ns_id, 0, -1, { details = true })
+
+    assert.equal(1, #highlights)
+    assert.equal("DiffAdd", highlights[1][4].hl_group)
   end)
 
   it("highlights whole functions", function()
     vim.fn.cursor(10, 1)
     tw.move_down()
-    h.assert_highlighted(21, 1, 28, 3, highlight_stub, "is_jump_target function")
+    h.assert_highlighted(21, 1, 28, 3)
   end)
 
   it("highlights whole lines starting with identifiers", function()
     vim.fn.cursor(134, 5)
     tw.move_up()
-    h.assert_highlighted(133, 5, 133, 33, highlight_stub, "table.insert call")
+    h.assert_highlighted(133, 5, 133, 33)
   end)
 
   it("highlights whole lines starting with assignments", function()
     vim.fn.cursor(133, 5)
     tw.move_down()
-    h.assert_highlighted(134, 5, 134, 18, highlight_stub, "child = iter()")
+    h.assert_highlighted(134, 5, 134, 18)
   end)
 
   it("highlights out reliably", function()
     vim.fn.cursor(133, 5)
     tw.move_out()
-    h.assert_highlighted(132, 3, 135, 5, highlight_stub, "while child")
+    h.assert_highlighted(132, 3, 135, 5)
   end)
 
   it("highlights out reliably", function()
     vim.fn.cursor(132, 3)
     tw.move_out()
-    h.assert_highlighted(128, 1, 137, 3, highlight_stub, "local f get_children")
+    h.assert_highlighted(128, 1, 137, 3)
   end)
 
   it("doesn't highlight the whole file", function()
     vim.fn.cursor(3, 1)
     tw.move_up()
-    h.assert_highlighted(1, 1, 1, 39, highlight_stub, "first line")
+    h.assert_highlighted(1, 1, 1, 39)
   end)
 
   -- Note this is highly language dependent, so this test is not so powerful
   it("highlights only the first item in a block", function()
     vim.fn.cursor(27, 3)
     tw.move_up()
-    h.assert_highlighted(22, 3, 26, 5, highlight_stub, "for _")
+    h.assert_highlighted(22, 3, 26, 5)
   end)
 
   it("given in a line with no parent, move_out highlights the whole node", function()
     vim.fn.cursor(21, 16) -- |is_jump_target
     tw.move_out()
     h.assert_cursor_at(21, 1)
-    h.assert_highlighted(21, 1, 28, 3, highlight_stub, "is_jump_target function")
+    h.assert_highlighted(21, 1, 28, 3)
   end)
 end)