snake/tests/Interpreter.cpp

#include <catch2/catch.hpp>
#include "../src/Interpreter.hpp"

#define TEST_RUN(SRC, ...) \
  test_run(SRC, {__VA_ARGS__})

using namespace sn;

struct StateMock: public State {
  std::vector<std::filesystem::path> modified_files;

  StateMock(std::vector<std::filesystem::path> const& p_modified_files)
    : modified_files { p_modified_files }
  {
  }

  virtual void init(std::vector<std::filesystem::path> const&) override
  {
  }

  virtual void update(std::filesystem::path) override
  {
  }

  virtual std::vector<std::filesystem::path>
  get_modified_files(std::vector<std::filesystem::path> const&) override
  {
    return modified_files;
  }
};

struct LoaderMock: public Loader {
  std::string snakefile;

  LoaderMock(std::string const& p_snakefile)
    : snakefile { p_snakefile }
  {
  }

  virtual std::filesystem::path find_snakefile() override { return ""; }

  virtual std::string load_snakefile() override
  {
    return snakefile;
  }
};

struct ExecutorMock: public Executor {
  std::vector<std::string> history;

  virtual std::string execute(std::string const& command) override
  {
    history.push_back(command);
    return "";
  }
};

class InterpreterTest
{
public:
  explicit InterpreterTest() {}
  virtual ~InterpreterTest() {}

  std::vector<std::string>
  test_run(std::string const& snakefile,
           std::vector<std::filesystem::path> const& modified)
  {
    auto state = std::make_shared<StateMock>(modified);

    auto loader = std::make_shared<LoaderMock>(snakefile);
    auto executor = std::make_shared<ExecutorMock>();

    Interpreter interpreter {state, loader, executor};
    interpreter.run();

    return executor->history;
  }

  void test_contains(std::string const& str, std::vector<std::string> vec)
  {
    INFO("'" << str << "' not found");
    REQUIRE(std::find(std::begin(vec), std::end(vec), str)
            != std::end(vec));
  }

protected:
};

TEST_CASE_METHOD(InterpreterTest, "Interpreter_simple_var")
{
  auto modified = std::vector<std::filesystem::path> {
    std::filesystem::path("a"),
  };

  std::stringstream ss;
  ss << "$X = a" << std::endl;
  ss << "b -> $X {" << std::endl;
  ss << "executed" << std::endl;
  ss << "}" << std::endl;

  auto res = TEST_RUN(ss.str(), std::filesystem::path("a"));
  test_contains("executed", res);
}