self-tests.cpp

#include "JsonGenerator.h"

#include <filesystem>
#include <iostream>
#include <format>

#include <backward.hpp>
#include <cxxopts.hpp>
#include <rapidcheck.h>

#include <nlohmann/json.hpp>
#include <nlohmann/json-schema.hpp>


// @author Dániel Lukács (https://github.com/daniel-lukacs), ELTE IK, 2025.

namespace nj = nlohmann;

class CmdArgs {

  public:
    CmdArgs(int argc, char* argv[]){

      cxxopts::Options options("Tests the JSON configuration tester");
      std::string curr_path = std::filesystem::current_path().string();
      options.add_options()
        ("h,help", "Shows this help and exit.")
        ("testDir", "Custom path to folder containing test files listing JSON schemas", 
                             cxxopts::value<std::string>()->default_value(""))
                   ;

      options.parse_positional({"testDir"});

      auto result{options.parse(argc, argv)};

      if(result.count("help") > 0){
          std::cout <<  options.help() << std::endl; 
          exit(0);
      }

      this->testDir = result["testDir"].as<std::string>();
    }

    std::string testDir;

};

class ValidationAgainstSchemaFailed : public std::runtime_error {
    public:
    ValidationAgainstSchemaFailed(std::string message) throw()
    : std::runtime_error(message) { }
}; 



bool validateJson(const nj::json & schema, const nj::json & result, jg::LogSet &){
  nj::json_schema::json_validator validator;
  try {
      validator.set_root_schema(schema); 
  } catch (const std::exception &e) {
      throw ValidationAgainstSchemaFailed(std::format("set_root_schema({}). Error: {}", nj::to_string(schema), e.what()));
      return false;
  }

  try {

      validator.validate(result);
  } catch (const std::exception &e) {
      throw ValidationAgainstSchemaFailed(std::format("validate({}). Schema: {}. Error: {}", nj::to_string(result), nj::to_string(schema), e.what()));
      return false;
  }
  return true;
}

bool testSchema(std::string testName, const nj::json & schemas, const bool negativeTests=false){

  int noItems = schemas.size();
  int testIdx = 1;
  for(const auto & schema : schemas){
      auto cit = schema.find("$comment");    
      std::string desc = cit == schema.end() ? "unnamed" : *cit;

      std::string msg = std::format("Testing schema '{}' ({}/{} in {}).", desc, testIdx, noItems, testName);

      // std::cout << desc << "\n";
      
      jg::LogSet log;
      try{
        bool b = jg::check(msg, schema,
          [&schema, &log](const nj::json & doc){
              bool b = validateJson(schema, doc, log);
              return b;   
        }, log);

        if(negativeTests && b){          
          std::cout << "Self-test failed. Reason: Expected test to fail, but it did not happen.\n";
          return false; 
        } else if(!negativeTests && !b){
          return false;
        } // otherwise: keep going

      } catch(const jg::GenerationFailed & e){

        std::cout << log.str() << std::flush; 
        
        std::cout << "Generation failed. Reason: " << e.what() << "\n";
        if(!negativeTests){
          return false;
        } // otherwise: keep going
      
      } 

      testIdx += 1;
  }
  return true;
}


const std::string TEST_DIR = "tests/positive";
const std::string FAILING_TEST_DIR = "tests/negative";

// TODO rc does not generate empty by default. add elementOf([], myGen) for strings and arrays;
int main(int argc, char* argv[]){
  backward::SignalHandling sh{};

  const CmdArgs args(argc, argv);

  std::string posTestDir = (args.testDir.empty() ? TEST_DIR : args.testDir);
  std::list<std::pair<std::string, bool>> testDirs = 
    { { posTestDir, false }
    , { FAILING_TEST_DIR, true }
    };

  for(const auto & [testDir, isNegative] : testDirs){
    std::set<std::string> sortedPaths;
    for (const auto & entry : std::filesystem::directory_iterator(testDir)){
      sortedPaths.insert(entry.path());
    }
    
    for (const auto & path : sortedPaths){
          nj::json schemas;
          try {
            std::ifstream ifs(path);
            schemas = nj::json::parse(ifs);
          } catch(const std::exception &e){
            throw jg::JsonParsingFailed(std::format("Failed to parse '{}'. {}", path, e.what()));
          }
          bool b = testSchema(path, schemas, isNegative);
          if(!b){
            std::cout << "Verdict: There were failed tests :(\n";
            return 1;
          }

        
    }
  }

  std::cout << "\nVerdict: All tests passed :)\n";
  return 0;
}