argparse/spec/options_spec.lua

local argparse = require "argparse"

describe("tests related to options", function()
   local function curry(f, ...)
      local args = {...}
      local unpack = unpack or table.unpack
      return function() return f(unpack(args)) end
   end

   describe("passing correct options", function()
      it("handles no options passed correctly", function()
         local parser = argparse.parser()
         parser:option("-s", "--server")
         local args = parser:parse({})
         assert.same(args, {})
      end)

      it("handles one option correctly", function()
         local parser = argparse.parser()
         parser:option("-s", "--server")
         local args = parser:parse({"--server", "foo"})
         assert.same(args, {server = "foo"})
      end)

      it("handles GNU-style long options", function()
         local parser = argparse.parser()
         parser:option("-s", "--server")
         local args = parser:parse({"--server=foo"})
         assert.same(args, {server = "foo"})
      end)

      it("handles GNU-style long options even when it could take more arguments", function()
         local parser = argparse.parser()
         parser:option("-s", "--server", {
            args = "*"
         })
         local args = parser:parse({"--server=foo"})
         assert.same(args, {server = {"foo"}})
      end)

      it("handles GNU-style long options for multi-argument options", function()
         local parser = argparse.parser()
         parser:option("-s", "--server", {
            args = "1-2"
         })
         local args = parser:parse({"--server=foo", "bar"})
         assert.same(args, {server = {"foo", "bar"}})
      end)

      it("handles short option correclty", function()
         local parser = argparse.parser()
         parser:option("-s", "--server")
         local args = parser:parse({"-s", "foo"})
         assert.same(args, {server = "foo"})
      end)

      it("handles flag correclty", function()
         local parser = argparse.parser()
         parser:flag("-q", "--quiet")
         local args = parser:parse({"--quiet"})
         assert.same(args, {quiet = true})
      end)

      it("handles combined flags correclty", function()
         local parser = argparse.parser()
         parser:flag("-q", "--quiet")
         parser:flag("-f", "--fast")
         local args = parser:parse({"-qf"})
         assert.same(args, {quiet = true, fast = true})
      end)

      it("handles short options without space between option and argument", function()
         local parser = argparse.parser()
         parser:option("-s", "--server")
         local args = parser:parse({"-sfoo"})
         assert.same(args, {server = "foo"})
      end)

      it("handles flags combined with short option correclty", function()
         local parser = argparse.parser()
         parser:flag("-q", "--quiet")
         parser:option("-s", "--server")
         local args = parser:parse({"-qsfoo"})
         assert.same(args, {quiet = true, server = "foo"})
      end)

      describe("Options with optional argument", function()
         it("handles emptiness correctly", function()
            local parser = argparse.parser()
            parser:option("-p", "--password", {
               args = "?"
            })
            local args = parser:parse({})
            assert.same(args, {})
         end)

         it("handles option without argument correctly", function()
            local parser = argparse.parser()
            parser:option("-p", "--password", {
               args = "?"
            })
            local args = parser:parse({"-p"})
            assert.same(args, {password = {}})
         end)

         it("handles option with argument correctly", function()
            local parser = argparse.parser()
            parser:option("-p", "--password", {
               args = "?"
            })
            local args = parser:parse({"-p", "password"})
            assert.same(args, {password = {"password"}})
         end)
      end)

      it("handles multi-argument options correctly", function()
         local parser = argparse.parser()
         parser:option("--pair", {
            args = 2
         })
         local args = parser:parse({"--pair", "Alice", "Bob"})
         assert.same(args, {pair = {"Alice", "Bob"}})
      end)

      describe("Multi-count options", function()
         it("handles multi-count option correctly", function()
            local parser = argparse.parser()
            parser:option("-e", "--exclude", {
               count = "*"
            })
            local args = parser:parse({"-efoo", "--exclude=bar", "-e", "baz"})
            assert.same(args, {exclude = {"foo", "bar", "baz"}})
         end)

         it("handles not used multi-count option correctly", function()
            local parser = argparse.parser()
            parser:option("-e", "--exclude", {
               count = "*"
            })
            local args = parser:parse({})
            assert.same(args, {exclude = {}})
         end)

         it("handles multi-count multi-argument option correctly", function()
            local parser = argparse.parser()
            parser:option("-e", "--exclude", {
               count = "*",
               args = 2
            })
            local args = parser:parse({"-e", "Alice", "Bob", "-e", "Emma", "Jacob"})
            assert.same(args, {exclude = {{"Alice", "Bob"}, {"Emma", "Jacob"}}})
         end)

         it("handles multi-count option with optional argument correctly", function()
            local parser = argparse.parser()
            parser:option("-w", "--why", "--why-would-someone-use-this", {
               count = "*",
               args = "?"
            })
            local args = parser:parse({"-w", "-wfoo", "--why=because", "-ww"})
            assert.same(args, {why = {{}, {"foo"}, {"because"}, {}, {}}})
         end)

         it("handles multi-count flag correctly", function()
            local parser = argparse.parser()
            parser:flag("-q", "--quiet", {
               count = "*"
            })
            local args = parser:parse({"-qq", "--quiet"})
            assert.same(args, {quiet = 3})
         end)

         it("overwrites old invocations", function()
            local parser = argparse.parser()
            parser:option("-u", "--user", {
               count = "0-2"
            })
            local args = parser:parse({"-uAlice", "--user=Bob", "--user", "John"})
            assert.same(args, {user = {"Bob", "John"}})
         end)

         it("handles not used multi-count flag correctly", function()
            local parser = argparse.parser()
            parser:flag("-q", "--quiet", {
               count = "*"
            })
            local args = parser:parse({})
            assert.same(args, {quiet = 0})
         end)
      end)
   end)

   describe("passing incorrect options", function()
      local old_parser = argparse.parser

      setup(function()
         argparse.parser = old_parser:extends()
         function argparse.parser:error(fmt, ...)
            error(fmt:format(...))
         end
      end)

      it("handles lack of required argument correctly", function()
         local parser = argparse.parser()
         parser:option("-s", "--server")
         assert.has_error(curry(parser.parse, parser, {"--server"}), "too few arguments")
      end)

      it("handles too many arguments correctly", function()
         local parser = argparse.parser()
         parser:option("-s", "--server")
         assert.has_error(curry(parser.parse, parser, {"-sfoo", "bar"}), "too many arguments")
      end)

      it("doesn't accept GNU-like long options when it doesn't need arguments", function()
         local parser = argparse.parser()
         parser:flag("-q", "--quiet")
         assert.has_error(curry(parser.parse, parser, {"--quiet=very_quiet"}), "option --quiet doesn't take arguments")
      end)

      it("handles too many invocations correctly", function()
         local parser = argparse.parser()
         parser:flag("-q", "--quiet", {
            count = 1,
            no_overwrite = true
         })
         assert.has_error(curry(parser.parse, parser, {"-qq"}), "option -q must be used at most 1 times")
      end)
   end)
end)