cpp-argument-parser/test/action_test.cpp

//
//  action_test.cpp
//  program_args-test
//
//  Created by Sam Jaffe on 2/13/22.
//

#include "program_args/arguments.h"

#include "xcode_gtest_helper.h"

using testing::NotNull;

namespace program {
struct ArgumentTestHelper {
  template <typename Impl> bool has_main(Impl const & args) const {
    return static_cast<bool>(args.main_callback);
  }
  template <typename Impl> int main(Impl const & args) const {
    return args.main_callback(args);
  }
};
}

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

program::detail::Any g_action;

template <typename Args, typename Action>
int typed_main(Args const &, Action const & action) {
  g_action = program::detail::Any(&action);
  return 0;
}

struct Checkout : program::Arguments<Checkout> {
  using Arguments::Arguments;
  std::string commitish = argument(0, "commit-ish");
};

struct Commit : program::Arguments<Commit> {
  using Arguments::Arguments;
  std::string message = option("message", 'm');
};

class Push : public program::Arguments<Push> {
public:
  using Arguments::Arguments;
  std::string remote = argument(0, "repository") = PROGRAM_DEFER(_remote());

private:
  std::string _remote() const;
};

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

  Commit commit = action("commit");
  std::string arg0 = argument(0, "arg0");
};

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

  std::string arg0 = argument(0, "arg0");
  Commit commit = action("commit");
};

class Git : program::Arguments<Git> {
public:
  using Arguments::Arguments;

  std::string pwd = option('C');
  bool verbose = flag("verbose", 'v');

private:
  Commit commit = action("commit");
  Checkout checkout = action("checkout");
  Push push = action("push");
};

std::string Push::_remote() const {
  if (Git const * git = Arguments::parent<Git>()) { return git->pwd; }
  return "";
}

TEST(ActionTest, CannotMixActionAndArgument) {
  EXPECT_THROW(Bad1(), program::ArgumentMixingError);
  EXPECT_THROW(Bad2(), program::ArgumentMixingError);
}

TEST(ActionTest, CanRunWithMultipleActions) { EXPECT_NO_THROW(Git()); }

TEST(ActionTest, ActionIsRouted) {
  Git git = parse<Git>({"", "-v", "commit", "-m", "this is a message"});
  program::ArgumentTestHelper helper;
  EXPECT_TRUE(helper.has_main(git));
  helper.main(git);
  EXPECT_THAT(g_action.get<Commit>(), NotNull());
  EXPECT_THAT(g_action.get<Commit>()->message, "this is a message");
}

TEST(ActionTest, CanFetchParentInfo) {
  Git git = parse<Git>({"", "-C", "./submodules/X", "push"});
  program::ArgumentTestHelper helper;
  EXPECT_TRUE(helper.has_main(git));
  helper.main(git);

  EXPECT_THAT(g_action.get<Push>(), NotNull());
  EXPECT_THAT(g_action.get<Push>()->remote, "./submodules/X");
}