path: root/test/functional/plugin/zip_spec.lua

local n = require('test.functional.testnvim')()
local t = require('test.testutil')

local describe, it, before_each, after_each = t.describe, t.it, t.before_each, t.after_each
local api = n.api
local eq = t.eq
local exec_capture = n.exec_capture
local exec_lua = n.exec_lua
local feed = n.feed
local fn = n.fn
local poke_eventloop = n.poke_eventloop

local fixtures = vim.fs.joinpath(t.paths.test_source_path, 'test/functional/fixtures/zip')
local old_samples = vim.fs.joinpath(t.paths.test_source_path, 'test/old/testdir/samples')

local function lines()
  return api.nvim_buf_get_lines(0, 0, -1, false)
end

local function edit(path)
  api.nvim_cmd({ cmd = 'edit', args = { path }, magic = { file = false, bar = false } }, {})
end

local function clear_zip()
  n.clear({ args = { '--clean' } })
end

local function line_of(text)
  for i, line in ipairs(lines()) do
    if line == text then
      return i
    end
  end
  error(('missing line %q in %s'):format(text, vim.inspect(lines())))
end

describe('nvim.zip', function()
  local root

  --- Copy an archive into the test directory and return its path.
  local function stage(source_dir, source, as)
    local target = vim.fs.joinpath(root, as or source)
    assert(vim.uv.fs_copyfile(vim.fs.joinpath(source_dir, source), target))
    return target
  end

  --- Stage the browsing fixture, restart, and open it.
  local function browse(as)
    local archive = stage(fixtures, 'browser.zip', as)
    clear_zip()
    edit(archive)
    return archive
  end

  before_each(function()
    t.skip(vim.fn.executable('unzip') == 0, 'unzip not available')
    root = vim.fs.normalize(t.tmpname(false) .. ' space%#')
    t.mkdir(root)
  end)

  after_each(function()
    n.rmdir(root)
  end)

  describe('activation', function()
    it('uses zip.lua by default', function()
      browse()

      eq('folder/', lines()[1])
      eq(true, exec_lua('return vim.g.loaded_nvim_zip_plugin == true'))
      eq(false, exec_lua('return vim.g.loaded_zipPlugin ~= nil'))
    end)

    it('defers to zipPlugin.vim loaded before startup plugins', function()
      local archive = stage(old_samples, 'test.zip', 'legacy.zip')
      n.clear({ args = { '--clean', '--cmd', 'packadd old-zip' } })

      edit(archive)

      eq(true, lines()[1]:find('" zip.vim version', 1, true) ~= nil)
      eq(0, fn.exists('#nvim.zip'))
      eq(false, exec_lua('return vim.g.loaded_nvim_zip_plugin ~= nil'))
    end)

    it('yields to zipPlugin.vim loaded after startup', function()
      local archive = stage(old_samples, 'test.zip', 'legacy.zip')
      clear_zip()
      exec_lua([[vim.cmd.packadd('old-zip')]])

      edit(archive)

      eq(true, lines()[1]:find('" zip.vim version', 1, true) ~= nil)
      eq(1, fn.exists('#nvim.zip'))
      eq(true, exec_lua('return vim.g.loaded_nvim_zip_plugin == true'))
    end)

    it('can be disabled', function()
      local archive = stage(fixtures, 'browser.zip')
      n.clear({
        args = { '--clean', '--cmd', 'let g:loaded_nvim_zip_plugin = 1' },
      })

      edit(archive)

      eq(0, fn.exists('#nvim.zip'))
      eq('', api.nvim_get_option_value('filetype', { buf = 0 }))
    end)

    it('can source zip.lua repeatedly', function()
      clear_zip()

      -- Re-sourcing must reuse the augroup rather than stack duplicate autocmds.
      eq(
        2,
        exec_lua(function()
          vim.cmd.runtime('plugin/zip.lua')
          vim.cmd.runtime('plugin/zip.lua')
          local ids = {}
          for _, autocmd in ipairs(vim.api.nvim_get_autocmds({ group = 'nvim.zip' })) do
            ids[autocmd.id] = true
          end
          return vim.tbl_count(ids)
        end)
      )
    end)

    it('reports an unavailable backend without claiming the buffer', function()
      local archive = stage(fixtures, 'browser.zip')
      clear_zip()
      exec_lua([[vim.env.PATH = '']])

      edit(archive)
      poke_eventloop()

      eq(true, exec_capture('messages'):find('unzip executable not found', 1, true) ~= nil)
      eq(false, exec_lua('return vim.b.nvim_dir ~= nil'))
    end)
  end)

  describe('browsing', function()
    it('opens zip-compatible file types', function()
      browse('browser.jar')

      eq('folder/', lines()[1])
      eq('zip', api.nvim_get_option_value('filetype', { buf = 0 }))
    end)

    it('browses directories and opens entries', function()
      browse()

      eq({
        'folder/',
        'inner.zip',
        '../escape.txt',
        '/absolute.txt',
        'crlf.txt',
        'noeol.txt',
        'names/',
      }, lines())
      eq('zip', api.nvim_get_option_value('filetype', { buf = 0 }))
      eq(true, exec_capture('syntax list zipDirectory'):find('zipDirectory', 1, true) ~= nil)

      feed('<CR>')
      poke_eventloop()
      eq({ 'nested/', 'root.txt', 'root.java' }, lines())

      feed('<CR>')
      poke_eventloop()
      eq({ 'file.txt' }, lines())

      feed('-')
      poke_eventloop()
      eq({ 'nested/', 'root.txt', 'root.java' }, lines())
      eq('nested/', api.nvim_get_current_line())

      api.nvim_win_set_cursor(0, { 2, 0 })
      feed('<CR>')
      poke_eventloop()
      eq({ 'root text' }, lines())
      eq('nowrite', api.nvim_get_option_value('buftype', { buf = 0 }))
      eq(true, api.nvim_get_option_value('readonly', { buf = 0 }))
      eq(false, api.nvim_get_option_value('modifiable', { buf = 0 }))
      eq(false, api.nvim_get_option_value('swapfile', { buf = 0 }))
    end)

    it('opens the containing directory from the archive root', function()
      browse()
      feed('-')
      poke_eventloop()

      eq(root, vim.fs.normalize(api.nvim_buf_get_name(0)))
      eq('browser.zip', api.nvim_get_current_line())
      eq('directory', api.nvim_get_option_value('filetype', { buf = 0 }))
    end)

    it('opens entries at quickfix locations', function()
      local archive = stage(fixtures, 'browser.zip')
      clear_zip()
      local uri = ('zip://%s/crlf.txt'):format(archive)
      fn.setqflist({}, 'r', { items = { { filename = uri, lnum = 2, col = 1 } } })

      api.nvim_cmd({ cmd = 'cfirst' }, {})

      eq(uri, api.nvim_buf_get_name(0))
      eq({ 2, 0 }, api.nvim_win_get_cursor(0))
      eq('text', api.nvim_get_option_value('filetype', { buf = 0 }))
    end)

    it('does not reinterpret an entry ending in .zip as an archive', function()
      browse()
      api.nvim_win_set_cursor(0, { line_of('inner.zip'), 0 })
      feed('<CR>')
      poke_eventloop()

      eq({ 'nested payload' }, lines())
      eq(false, exec_lua('return vim.b.nvim_dir ~= nil'))
    end)

    it('preserves normal file reading details for entries', function()
      local archive = stage(fixtures, 'browser.zip')
      clear_zip()

      edit(('zip://%s/crlf.txt'):format(archive))
      eq({ 'one', 'two' }, lines())
      eq('dos', api.nvim_get_option_value('fileformat', { buf = 0 }))
      eq(true, api.nvim_get_option_value('endofline', { buf = 0 }))

      edit(('zip://%s/noeol.txt'):format(archive))
      eq({ 'no final newline' }, lines())
      eq(false, api.nvim_get_option_value('endofline', { buf = 0 }))
    end)

    it('keeps suspicious entry paths visible and readable', function()
      browse()
      api.nvim_win_set_cursor(0, { line_of('../escape.txt'), 0 })
      feed('<CR>')
      poke_eventloop()

      eq({ 'escape payload' }, lines())
    end)

    it('opens non-zip files normally', function()
      local archive = vim.fs.joinpath(root, 'plain.zip')
      t.write_file(archive, 'plain text', true)
      clear_zip()

      edit(archive)

      eq({ 'plain text' }, lines())
      eq(false, exec_lua('return vim.b.nvim_dir ~= nil'))
    end)

    it('lists a valid empty archive as empty', function()
      local archive = vim.fs.joinpath(root, 'empty.zip')
      local file = assert(io.open(archive, 'wb'))
      -- An end-of-central-directory record with no entries: a valid, empty archive.
      file:write('PK\5\6' .. string.rep('\0', 18))
      file:close()
      clear_zip()

      edit(archive)

      eq({ '' }, lines())
      eq('zip', api.nvim_get_option_value('filetype', { buf = 0 }))
      eq(true, exec_lua('return vim.b.nvim_zip ~= nil'))
    end)

    it('keeps the current level when reload fails', function()
      local archive = browse()
      feed('<CR>')
      poke_eventloop()
      eq({ 'nested/', 'root.txt', 'root.java' }, lines())

      assert(</