cpp-argument-parser/test/options_test.cpp

//
//  options_test.cpp
//  program_args-test
//
//  Created by Sam Jaffe on 2/7/21.
//

#include "program_args/arguments.h"

#include "xcode_gtest_helper.h"

using testing::Eq;

template <typename T, size_t N> static T parse(char const * const (&argv)[N]) {
  return T(N, argv);
}

struct LongOptionTest : program::Arguments<LongOptionTest> {
  using program::Arguments<LongOptionTest>::Arguments;

  std::string endpoint = option("endpoint");
  int port = option("port");
};

TEST(LongOptionTest, ArgumentsAreDefaultedNaturally) {
  auto const options = parse<LongOptionTest>({""});
  EXPECT_THAT(options.endpoint, Eq(""));
  EXPECT_THAT(options.port, Eq(0));
}

TEST(LongOptionTest, CanProvideStringArgument) {
  auto const options = parse<LongOptionTest>({"", "--endpoint", "/null"});
  EXPECT_THAT(options.endpoint, Eq("/null"));
}

TEST(LongOptionTest, CanProvideNumericArgument) {
  auto const options = parse<LongOptionTest>({"", "--port", "443"});
  EXPECT_THAT(options.port, Eq(443));
}

TEST(LongOptionTest, WillThrowOnInvalidNumericArgument) {
  EXPECT_THROW(parse<LongOptionTest>({"", "--port", "one"}),
               program::ProgramArgumentsError);
}

TEST(LongOptionTest, WillThrowOnRepeatedArgument) {
  EXPECT_THROW(parse<LongOptionTest>({"", "--port", "8080", "--port", "443"}),
               program::ArgumentStructureError);
}

TEST(LongOptionTest, WillThrowOnUnknownArgument) {
  EXPECT_THROW(parse<LongOptionTest>({"", "--path", "/null"}),
               program::NotAnArgumentError);
}

TEST(LongOptionTest, DoesNotImplicitlyShortenArgs) {
  EXPECT_THROW(parse<LongOptionTest>({"", "-p", "443"}),
               program::NotAnArgumentError);
}

struct LongOptionWithDefaultTest
    : program::Arguments<LongOptionWithDefaultTest> {
  using program::Arguments<LongOptionWithDefaultTest>::Arguments;

  std::string endpoint = option("endpoint") = "/default";
  int port = option("port") = 8080;
};

TEST(LongOptionWithDefaultTest, ArgumentsAreDefaultedNaturally) {
  auto const options = parse<LongOptionWithDefaultTest>({""});
  EXPECT_THAT(options.endpoint, Eq("/default"));
  EXPECT_THAT(options.port, Eq(8080));
}

TEST(LongOptionWithDefaultTest, CanProvideStringArgument) {
  auto const options =
      parse<LongOptionWithDefaultTest>({"", "--endpoint", "/null"});
  EXPECT_THAT(options.endpoint, Eq("/null"));
}

TEST(LongOptionWithDefaultTest, CanProvideNumericArgument) {
  auto const options = parse<LongOptionWithDefaultTest>({"", "--port", "443"});
  EXPECT_THAT(options.port, Eq(443));
}

struct LongOptionWithAbbrevTest : program::Arguments<LongOptionWithAbbrevTest> {
  using program::Arguments<LongOptionWithAbbrevTest>::Arguments;

  std::string endpoint = option("endpoint", 'e');
  int port = option("port", 'p');
};

TEST(LongOptionWithAbbrevTest, CanProvideStringArgument) {
  auto const options =
      parse<LongOptionWithAbbrevTest>({"", "--endpoint", "/null"});
  EXPECT_THAT(options.endpoint, Eq("/null"));
}

TEST(LongOptionWithAbbrevTest, CanProvideAbbrevStringArgument) {
  auto const options = parse<LongOptionWithAbbrevTest>({"", "-e", "/null"});
  EXPECT_THAT(options.endpoint, Eq("/null"));
}

TEST(LongOptionWithAbbrevTest, CanProvideNumericArgument) {
  auto const options = parse<LongOptionWithAbbrevTest>({"", "--port", "443"});
  EXPECT_THAT(options.port, Eq(443));
}

TEST(LongOptionWithAbbrevTest, CanProvideAbbrevNumericArgument) {
  auto const options = parse<LongOptionWithAbbrevTest>({"", "-p", "443"});
  EXPECT_THAT(options.port, Eq(443));
}

TEST(LongOptionWithAbbrevTest, ShortAndLongArgsGoToSamePool) {
  EXPECT_THROW(
      parse<LongOptionWithAbbrevTest>({"", "--port", "8080", "-p", "443"}),
      program::ArgumentStructureError);
}