neovim/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 copy_fixture(source, target)
  assert(vim.uv.fs_copyfile(source, target))
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

  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)

  it('uses zip.lua by default', function()
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()

    edit(archive)

    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 = vim.fs.joinpath(root, 'legacy.zip')
    copy_fixture(vim.fs.joinpath(old_samples, 'test.zip'), archive)
    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 = vim.fs.joinpath(root, 'legacy.zip')
    copy_fixture(vim.fs.joinpath(old_samples, 'test.zip'), archive)
    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 = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    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()

    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('opens zip-compatible file types', function()
    local archive = vim.fs.joinpath(root, 'browser.jar')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()

    edit(archive)

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

  it('browses directories and opens entries', function()
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()

    edit(archive)

    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()
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()

    edit(archive)
    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 = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()
    local uri = ('zipfile://%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()
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()

    edit(archive)
    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 = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()

    edit(('zipfile://%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(('zipfile://%s::noeol.txt'):format(archive))
    eq({ 'no final newline' }, lines())
    eq(false, api.nvim_get_option_value('endofline', { buf = 0 }))
  end)

  it('integrates Java sources with zip.lua and zipPlugin.vim', function()
    local archive = vim.fs.joinpath(root, 'source.jar')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)

    for _, legacy in ipairs({ false, true }) do
      if legacy then
        n.clear({
          args = { '--clean', '--cmd', 'packadd old-zip' },
        })
      else
        clear_zip()
      end
      exec_lua('vim.g.ftplugin_java_source_path = ...', archive)
      api.nvim_buf_set_name(0, vim.fs.joinpath(root, 'Test.java'))
      api.nvim_buf_set_lines(0, 0, -1, false, { 'folder.root' })
      api.nvim_cmd({ cmd = 'setfiletype', args = { 'java' } }, {})
      api.nvim_cmd({ cmd = 'runtime', args = { 'ftplugin/java.vim' } }, {})

      feed('gf')
      poke_eventloop()

      eq(('zipfile://%s::folder/root.java'):format(archive), api.nvim_buf_get_name(0))
      eq({ 'class root {}' }, lines())
      eq('java', api.nvim_get_option_value('filetype', { buf = 0 }))
    end
  end)

  it('reads entry selectors literally', function()
    t.skip(t.is_os('win'), 'N/A: archive contains backslashes in entry paths')
    local archive = vim.fs.joinpath(root, 'special.zip')
    copy_fixture(vim.fs.joinpath(old_samples, 'testa.zip'), archive)
    clear_zip()

    local cases = {
      { 'zipglob/a[a].txt', 'a test file with []' },
      { 'zipglob/a*.txt', 'a test file with a*' },
      { 'zipglob/a?.txt', 'a test file with a?' },
      { [[zipglob/a\.txt]], [[a test file with a\]] },
      { [[zipglob/a\\.txt]], [[a test file with a double \]] },
    }
    for _, case in ipairs(cases) do
      edit(('zipfile://%s::%s'):format(archive, case[1]))
      eq({ case[2] }, lines())
    end
  end)

  it('lists and opens entries with difficult names', function()
    t.skip(t.is_os('win'), 'N/A: Windows filenames cannot contain these characters')
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()

    local names = {
      'space name.txt',
      'two  spaces.txt',
      ' leading.txt',
      'trailing .txt',
      [[back\slash.txt]],
      [[single'quote.txt]],
      'double"quote.txt',
      'dollar$name.txt',
      'backtick`name.txt',
      'semi;name.txt',
      'pipe|name.txt',
      'amp&name.txt',
      'paren(name).txt',
      'bang!name.txt',
      'hash#name.txt',
      'percent%name.txt',
      'star*.txt',
      'question?.txt',
      '[bracket].txt',
      '-dash.txt',
    }

    edit(archive)
    api.nvim_win_set_cursor(0, { line_of('names/'), 0 })
    feed('<CR>')
    poke_eventloop()
    eq(names, lines())

    api.nvim_win_set_cursor(0, { line_of('star*.txt'), 0 })
    feed('<CR>')
    poke_eventloop()
    eq(('zipfile://%s::names/star*.txt'):format(archive), api.nvim_buf_get_name(0))
    eq({ 'content of star*.txt' }, lines())

    for _, name in ipairs(names) do
      edit(('zipfile://%s::names/%s'):format(archive, name))
      eq({ 'content of ' .. name }, lines())
    end
  end)

  it('keeps a leading dash in a path from becoming a backend option', function()
    local archive = vim.fs.joinpath(root, 'poc.zip')
    copy_fixture(vim.fs.joinpath(old_samples, 'poc.zip'), archive)
    clear_zip()

    edit(archive)
    eq({ '-d/', 'pwned' }, lines())

    edit(('zipfile://%s::-d/tmp'):format(archive))
    eq({ '' }, lines())
  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'))
    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('treats archive glob characters literally', function()
    t.skip(t.is_os('win'), 'N/A: Windows filenames cannot contain these characters')
    local archive = vim.fs.joinpath(root, 'archive::[*?].zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    copy_fixture(vim.fs.joinpath(old_samples, 'test.zip'), vim.fs.joinpath(root, 'archivex.zip'))
    clear_zip()

    edit(archive)

    eq('folder/', lines()[1])
    api.nvim_win_set_cursor(0, { line_of('inner.zip'), 0 })
    feed('<CR>')
    poke_eventloop()
    eq({ 'nested payload' }, lines())

    local uri = ('zipfile://%s::crlf.txt'):format(archive)
    edit(uri)
    eq(uri, api.nvim_buf_get_name(0))
    eq({ 'one', 'two' }, lines())
  end)

  it('keeps suspicious entry paths visible and readable', function()
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()

    edit(archive)
    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('keeps the current level when reload fails', function()
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()

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

    assert(os.remove(archive))
    feed('R')
    poke_eventloop()
    eq({ 'nested/', 'root.txt', 'root.java' }, lines())

    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    feed('R')
    poke_eventloop()
    eq({ 'nested/', 'root.txt', 'root.java' }, lines())
  end)

  it('extracts the entry under the cursor into the current directory', function()
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()
    api.nvim_set_current_dir(root)

    edit(archive)
    feed('<CR>')
    poke_eventloop()
    api.nvim_win_set_cursor(0, { line_of('root.java'), 0 })
    feed('x')
    poke_eventloop()

    eq('class root {}\n', t.read_file(vim.fs.joinpath(root, 'root.java')))
  end)

  it('refuses to extract a directory', function()
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    clear_zip()
    api.nvim_set_current_dir(root)

    edit(archive)
    api.nvim_win_set_cursor(0, { line_of('folder/'), 0 })
    feed('x')
    poke_eventloop()

    eq(true, exec_capture('messages'):find('not a directory', 1, true) ~= nil)
    eq(nil, vim.uv.fs_stat(vim.fs.joinpath(root, 'folder')))
  end)

  it('refuses to overwrite an existing file when extracting', function()
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    local target = vim.fs.joinpath(root, 'root.java')
    t.write_file(target, 'untouched', true)
    clear_zip()
    api.nvim_set_current_dir(root)

    edit(archive)
    feed('<CR>')
    poke_eventloop()
    api.nvim_win_set_cursor(0, { line_of('root.java'), 0 })
    feed('x')
    poke_eventloop()

    eq(true, exec_capture('messages'):find('already exists', 1, true) ~= nil)
    eq('untouched', t.read_file(target))
  end)

  it('extracts suspicious entries without escaping the current directory', function()
    local archive = vim.fs.joinpath(root, 'evil.zip')
    copy_fixture(vim.fs.joinpath(old_samples, 'evil.zip'), archive)
    clear_zip()
    api.nvim_set_current_dir(root)

    edit(archive)
    eq({
      '../../../../etc/ax-pwn',
      'a/../../../../../../../../../../../../../../../../../../tmp/foobar',
      '/tmp/vim_zip/a/b/payload.txt',
    }, lines())

    for _, entry in ipairs(lines()) do
      api.nvim_win_set_cursor(0, { line_of(entry), 0 })
      feed('x')
      poke_eventloop()
    end

    for _, name in ipairs({ 'ax-pwn', 'foobar', 'payload.txt' }) do
      eq(true, vim.uv.fs_stat(vim.fs.joinpath(root, name)) ~= nil)
    end
    eq(nil, vim.uv.fs_stat(vim.fs.joinpath(root, '..', 'ax-pwn')))
  end)

  it('reports an unavailable backend without claiming the buffer', function()
    local archive = vim.fs.joinpath(root, 'browser.zip')
    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
    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)