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> static int main(Impl const & args) {
    return args.invoke();
  }
};
}

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;
}

template <typename Args, typename Action, typename SubAction>
int typed_main(Args const &, Action const &, SubAction 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 SetUrl : program::Arguments<SetUrl> {
  using Arguments::Arguments;
  bool push = flag("push") = false;
  std::string name = argument(0, "name");
  std::string new_url = argument(1, "newurl");
  std::string old_url = argument(2, "oldurl") = "";
};

struct Show : program::Arguments<Show> {
  using Arguments::Arguments;
  bool use_cached = flag('n') = false;
};

struct Remote : public program::Arguments<Remote> {
  PROGRAM_ARGS_INVOKE_WITH_DEFAULT(show, show, set_url);

  bool verbose = flag('v') = false;
  SetUrl set_url = action("set-url");
  Show show = action("show");
};

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");
};

struct Git : program::Arguments<Git> {
  PROGRAM_ARGS_INVOKE(commit, checkout, push, remote);

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

  Commit commit = action("commit");
  Checkout checkout = action("checkout");
  Push push = action("push");
  Remote remote = action("remote");
};

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"});
  EXPECT_THAT(git.commit.message, "this is a message");
}

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

TEST(ActionTest, CanFetchParentInfo) {
  Git git = parse<Git>({"", "-C", "./submodules/X", "push"});
  EXPECT_THAT(git.push.remote, "./submodules/X");
}

TEST(ActionTest, ReturnsFailureOnNoAction) {
  Git git = parse<Git>({""});

  EXPECT_THAT(program::ArgumentTestHelper::main(git), 1);
}

TEST(ActionTest, CanRecursivelyPerformActions) {
  Git git = parse<Git>({"", "remote", "-v", "show", "-n"});
  EXPECT_TRUE(git.remote.verbose);
  EXPECT_TRUE(git.remote.show.use_cached);

  program::ArgumentTestHelper::main(git);
  EXPECT_THAT(g_action.get<Show>(), NotNull());
}

TEST(ActionTest, CanStoreDefaultAction) {
  Git git = parse<Git>({"", "remote"});

  program::ArgumentTestHelper::main(git);
  EXPECT_THAT(g_action.get<Show>(), NotNull());
}