json-validator/tests/selfvalidate_test.cxx

#include "gmock/gmock.h"
#include "gtest/gtest-param-test.h"
#include "gtest/gtest.h"
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>

#include <jvalidate/adapter.h>
#include <jvalidate/adapters/jsoncpp.h>
#include <jvalidate/enum.h>
#include <jvalidate/schema.h>
#include <jvalidate/status.h>
#include <jvalidate/uri.h>
#include <jvalidate/validator.h>

#include <json/reader.h>
#include <json/value.h>
#include <json/writer.h>

#include "./json_schema_test_suite.h"

using jvalidate::schema::Version;

using testing::Combine;
using testing::TestWithParam;
using testing::Values;

bool load_file(std::filesystem::path const & path, Json::Value & out) {
  std::ifstream in(path);
  Json::CharReaderBuilder builder;
  return Json::parseFromStream(builder, in, &out, nullptr);
}

bool load_external_for_test(jvalidate::URI const & uri, Json::Value & out) {
  constexpr std::string_view g_fake_url = "localhost:1234/";
  if (uri.scheme() == "http" && uri.resource().starts_with(g_fake_url)) {
    std::string_view path = uri.resource().substr(g_fake_url.size());
    return load_file(JSONSchemaTestSuiteDir() / "remotes" / path, out);
  } else if (uri.scheme() == "file") {
    return load_file(uri.resource(), out);
  } else {
    return false;
  }
}

struct JsonSchema : TestWithParam<std::tuple<Version, std::filesystem::path>> {};

TEST_P(JsonSchema, TestSuite) {
  auto const & [version, file] = GetParam();
  Json::Value spec;

  EXPECT_TRUE(load_file(file, spec));

  for (auto const & suite : spec) {
    std::cout << "\033[0;32m[ SUITE    ] \033[0;0m" << suite["description"].asString() << std::endl;
    jvalidate::Schema schema(suite["schema"], version, &load_external_for_test);
    for (auto const & test : suite["tests"]) {
      try {
        std::cout << "\033[0;32m[ CASE     ] \033[0;0m    " << test["description"].asString()
                  << std::endl;
        auto status = jvalidate::Validator(schema).validate(test["data"]);
        EXPECT_THAT(status != jvalidate::Status::Reject, test["valid"].asBool()) << test["data"];
      } catch (std::exception const & ex) { FAIL() << ex.what() << "\n" << test; }
    }
  }
}

INSTANTIATE_TEST_SUITE_P(Draft7, JsonSchema,
                         Combine(Values(Version::Draft07), SchemaTests("draft7")), SchemaTestName);

int main(int argc, char ** argv) {
  testing::InitGoogleMock(&argc, argv);
  return RUN_ALL_TESTS();
}