json-validator/tests/annotation_test.cxx

#include <gmock/gmock.h>
#include <gtest/gtest.h>

#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/validation_result.h>
#include <jvalidate/validator.h>

#include "matchers.h"

using enum jvalidate::schema::Version;
using testing::Not;

auto validate(Json::Value const & schema_doc, Json::Value const & instance_doc,
              jvalidate::schema::Version version = Draft2020_12) {
  jvalidate::Schema const schema(schema_doc, version);

  jvalidate::ValidationResult result;
  (void)jvalidate::Validator(schema).validate(instance_doc, &result);

  return result;
}

TEST(Annotation, AttachesFormattingAnnotation) {
  auto const schema = R"({
    "format": "uri"
  })"_json;

  auto const instance = R"("http://json-schema.org")"_json;

  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result, AnnotationAt("format", "uri"));
}

TEST(Annotation, AnnotatesErrors) {
  auto const schema = R"({
    "minimum": 5
  })"_json;

  auto const instance = R"(4)"_json;

  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result, ErrorAt("minimum", "4 < 5"));
}

TEST(Annotation, DoesNotAnnotatesValid) {
  auto const schema = R"({
    "minimum": 5
  })"_json;

  auto const instance = R"(6)"_json;

  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result, Not(HasAnnotationsFor(""_jptr)));
}

TEST(Annotation, NotSchemaFlipsAnnotationRule) {
  auto const schema = R"({
    "not": { "minimum": 5 }
  })"_json;

  auto const instance = R"(6)"_json;

  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result, ErrorAt(""_jptr, "/not"_jptr, "minimum", "6 >= 5"));
}

TEST(Annotation, NotSchemaPropogatesDeeply) {
  auto const schema = R"({
    "not": {
      "properties": {
        "A": {
          "enum": [ 1, 3, 4 ]
        }
      }
    }
  })"_json;

  auto const instance = R"({"A": 3})"_json;

  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result, ErrorAt("/A"_jptr, "/not/properties/A"_jptr, "enum", "1"));
}

TEST(Annotation, PathFollowsSchemaNotConstraintModel) {
  auto const schema = R"({
    "$comment": "disallow is implemented in the form of NotConstraint[TypeConstraint]",
    "disallow": "string"
  })"_json;

  auto const instance = R"("hello")"_json;

  jvalidate::ValidationResult result = validate(schema, instance, Draft03);

  EXPECT_THAT(result, ErrorAt("disallow", "string is in types [string]"));
}

TEST(Annotation, AttachesAlwaysFalseSensibly) {
  auto const schema = R"({
    "properties": {
      "A": false
    }
  })"_json;

  auto const instance = R"({
    "A": null
  })"_json;
  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result, ErrorAt("/A"_jptr, "/properties/A"_jptr, "", "always false"));
}

TEST(Annotation, IfThenCanGiveABecauseReason) {
  auto const schema = R"({
    "if": {
      "properties": {
        "A": { "const": true }
      },
      "required": [ "A" ]
    },
    "then": {
      "properties": {
        "B": { "multipleOf": 3 }
      }
    },
    "else": {
      "properties": {
        "B": { "multipleOf": 5 }
      }
    }
  })"_json;

  auto const instance = R"({
    "A": true,
    "B": 4
  })"_json;

  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result,
              ErrorAt(""_jptr, "/if"_jptr, "required", "contains all required properties A"));
  EXPECT_THAT(result, ErrorAt("/A"_jptr, "/if/properties/A"_jptr, "const", "matches value"));
  EXPECT_THAT(result, ErrorAt("/B"_jptr, "/then/properties/B"_jptr, "multipleOf",
                              "4 is not a multiple of 3"));
}

TEST(Annotation, IfElseCanGiveABecauseReason) {
  auto const schema = R"({
    "if": {
      "properties": {
        "A": { "const": true }
      },
      "required": [ "A" ]
    },
    "then": {
      "properties": {
        "B": { "multipleOf": 3 }
      }
    },
    "else": {
      "properties": {
        "B": { "multipleOf": 5 }
      }
    }
  })"_json;

  auto const instance = R"({
    "A": false,
    "B": 4
  })"_json;

  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result,
              ErrorAt(""_jptr, "/if"_jptr, "required", "contains all required properties A"));
  EXPECT_THAT(result, ErrorAt("/A"_jptr, "/if/properties/A"_jptr, "const", "true was expected"));
  EXPECT_THAT(result, ErrorAt("/B"_jptr, "/else/properties/B"_jptr, "multipleOf",
                              "4 is not a multiple of 5"));
}

TEST(Annotation, OneOfGivesAllReasonsOnTooMany) {
  auto const schema = R"({
    "oneOf": [
      { "minimum": 5 },
      { "multipleOf": 3 },
      { "maximum": 2 }
    ]
  })"_json;

  auto const instance = R"(6)"_json;

  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result, ErrorAt(""_jptr, ""_jptr, "oneOf", "validates multiple subschemas [ 0, 1 ]"));
  EXPECT_THAT(result, ErrorAt(""_jptr, "/oneOf/0"_jptr, "minimum", "6 >= 5"));
  EXPECT_THAT(result, ErrorAt(""_jptr, "/oneOf/1"_jptr, "multipleOf", "6 is a multiple of 3"));
  EXPECT_THAT(result, ErrorAt(""_jptr, "/oneOf/2"_jptr, "maximum", "6 > 2"));
}

TEST(Annotation, OneOfGivesAllReasonsOnNoMatches) {
  auto const schema = R"({
    "oneOf": [
      { "minimum": 5 },
      { "multipleOf": 3 },
      { "maximum": 2 }
    ]
  })"_json;

  auto const instance = R"(4)"_json;

  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result, ErrorAt(""_jptr, ""_jptr, "oneOf", "validates no subschemas"));
  EXPECT_THAT(result, ErrorAt(""_jptr, "/oneOf/0"_jptr, "minimum", "4 < 5"));
  EXPECT_THAT(result, ErrorAt(""_jptr, "/oneOf/1"_jptr, "multipleOf", "4 is not a multiple of 3"));
  EXPECT_THAT(result, ErrorAt(""_jptr, "/oneOf/2"_jptr, "maximum", "4 > 2"));
}

TEST(Annotation, OneOfGivesAllReasonsOnMatch) {
  auto const schema = R"({
    "oneOf": [
      { "minimum": 5 },
      { "multipleOf": 3 },
      { "maximum": 2 }
    ]
  })"_json;

  auto const instance = R"(3)"_json;

  jvalidate::ValidationResult result = validate(schema, instance);

  EXPECT_THAT(result, Not(HasAnnotationAt(""_jptr, ""_jptr)));
  EXPECT_THAT(result, ErrorAt(""_jptr, "/oneOf/1"_jptr, "multipleOf", "3 is a multiple of 3"));
}

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