JSONSchemaTest.cpp File Reference

#include <folly/experimental/JSONSchema.h>
#include <folly/json.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
bool	check (const dynamic &schema, const dynamic &value, bool check=true)
	TEST (JSONSchemaTest, TestMultipleOfInt)
	TEST (JSONSchemaTest, TestMultipleOfDouble)
	TEST (JSONSchemaTest, TestMinimumIntInclusive)
	TEST (JSONSchemaTest, TestMinimumIntExclusive)
	TEST (JSONSchemaTest, TestMaximumIntInclusive)
	TEST (JSONSchemaTest, TestMaximumIntExclusive)
	TEST (JSONSchemaTest, TestMinimumDoubleInclusive)
	TEST (JSONSchemaTest, TestMinimumDoubleExclusive)
	TEST (JSONSchemaTest, TestMaximumDoubleInclusive)
	TEST (JSONSchemaTest, TestMaximumDoubleExclusive)
	TEST (JSONSchemaTest, TestInvalidSchema)
	TEST (JSONSchemaTest, TestMinimumStringLength)
	TEST (JSONSchemaTest, TestMaximumStringLength)
	TEST (JSONSchemaTest, TestStringPattern)
	TEST (JSONSchemaTest, TestMinimumArrayItems)
	TEST (JSONSchemaTest, TestMaximumArrayItems)
	TEST (JSONSchemaTest, TestArrayUniqueItems)
	TEST (JSONSchemaTest, TestArrayItems)
	TEST (JSONSchemaTest, TestArrayAdditionalItems)
	TEST (JSONSchemaTest, TestArrayNoAdditionalItems)
	TEST (JSONSchemaTest, TestArrayItemsNotPresent)
	TEST (JSONSchemaTest, TestRef)
	TEST (JSONSchemaTest, TestRecursiveRef)
	TEST (JSONSchemaTest, TestDoubleRecursiveRef)
	TEST (JSONSchemaTest, TestInfinitelyRecursiveRef)
	TEST (JSONSchemaTest, TestRequired)
	TEST (JSONSchemaTest, TestMinMaxProperties)
	TEST (JSONSchemaTest, TestProperties)
	TEST (JSONSchemaTest, TestPropertyAndPattern)
	TEST (JSONSchemaTest, TestPropertyDependency)
	TEST (JSONSchemaTest, TestSchemaDependency)
	TEST (JSONSchemaTest, TestEnum)
	TEST (JSONSchemaTest, TestType)
	TEST (JSONSchemaTest, TestTypeArray)
	TEST (JSONSchemaTest, TestAllOf)
	TEST (JSONSchemaTest, TestAnyOf)
	TEST (JSONSchemaTest, TestOneOf)
	TEST (JSONSchemaTest, TestNot)
	TEST (JSONSchemaTest, TestMetaSchema)
	TEST (JSONSchemaTest, TestProductSchema)

Function Documentation

bool check	(	const dynamic &	schema,
		const dynamic &	value,
		bool	check = true
	)

Definition at line 27 of file JSONSchemaTest.cpp.

References folly::jsonschema::makeSchemaValidator(), and folly::jsonschema::makeValidator().

Referenced by fizz::server::test::ServerProtocolTest::acceptEarlyData(), folly::hazptr_domain< DeterministicAtomic >::cleanup(), folly::SingletonThreadLocal< T, Tag, Make, TLTag >::getWrapper(), folly::hazptr_domain_push_retired(), TEST(), fizz::server::test::TEST_F(), and TEST_P().

                                                                           {
  if (check) {
    auto schemavalidator = makeSchemaValidator();
    auto ew = schemavalidator->try_validate(schema);
    if (ew) {
      return false;
    }
  }

  auto validator = makeValidator(schema);
  auto ew = validator->try_validate(value);
  if (validator->try_validate(value)) {
    return false;
  }
  return true;
}

TEST	(	JSONSchemaTest	,
		TestMultipleOfInt
	)

Definition at line 44 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                        {
  dynamic schema = dynamic::object("multipleOf", 2);
  ASSERT_TRUE(check(schema, "invalid"));
  ASSERT_TRUE(check(schema, 30));
  ASSERT_TRUE(check(schema, 24.0));
  ASSERT_FALSE(check(schema, 5));
  ASSERT_FALSE(check(schema, 2.01));
}

TEST	(	JSONSchemaTest	,
		TestMultipleOfDouble
	)

Definition at line 53 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                           {
  dynamic schema = dynamic::object("multipleOf", 1.5);
  ASSERT_TRUE(check(schema, "invalid"));
  ASSERT_TRUE(check(schema, 30));
  ASSERT_TRUE(check(schema, 24.0));
  ASSERT_FALSE(check(schema, 5));
  ASSERT_FALSE(check(schema, 2.01));

  schema = dynamic::object("multipleOf", 0.0001);
  ASSERT_TRUE(check(schema, 0.0075));
}

TEST	(	JSONSchemaTest	,
		TestMinimumIntInclusive
	)

Definition at line 65 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                              {
  dynamic schema = dynamic::object("minimum", 2);
  ASSERT_TRUE(check(schema, "invalid"));
  ASSERT_TRUE(check(schema, 30));
  ASSERT_TRUE(check(schema, 24.0));
  ASSERT_TRUE(check(schema, 2));
  ASSERT_FALSE(check(schema, 1));
  ASSERT_FALSE(check(schema, 1.9999));
}

TEST	(	JSONSchemaTest	,
		TestMinimumIntExclusive
	)

Definition at line 75 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, check(), folly::dynamic::object(), and schema.

                                              {
  dynamic schema = dynamic::object("minimum", 2)("exclusiveMinimum", true);
  ASSERT_FALSE(check(schema, 2));
}

TEST	(	JSONSchemaTest	,
		TestMaximumIntInclusive
	)

Definition at line 80 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                              {
  dynamic schema = dynamic::object("maximum", 12);
  ASSERT_TRUE(check(schema, "invalid"));
  ASSERT_TRUE(check(schema, 3));
  ASSERT_TRUE(check(schema, 3.1));
  ASSERT_TRUE(check(schema, 12));
  ASSERT_FALSE(check(schema, 13));
  ASSERT_FALSE(check(schema, 12.0001));
}

TEST	(	JSONSchemaTest	,
		TestMaximumIntExclusive
	)

Definition at line 90 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, check(), folly::dynamic::object(), and schema.

                                              {
  dynamic schema = dynamic::object("maximum", 2)("exclusiveMaximum", true);
  ASSERT_FALSE(check(schema, 2));
}

TEST	(	JSONSchemaTest	,
		TestMinimumDoubleInclusive
	)

Definition at line 95 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                                 {
  dynamic schema = dynamic::object("minimum", 1.75);
  ASSERT_TRUE(check(schema, "invalid"));
  ASSERT_TRUE(check(schema, 30));
  ASSERT_TRUE(check(schema, 24.0));
  ASSERT_TRUE(check(schema, 1.75));
  ASSERT_FALSE(check(schema, 1));
  ASSERT_FALSE(check(schema, 1.74));
}

TEST	(	JSONSchemaTest	,
		TestMinimumDoubleExclusive
	)

Definition at line 105 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, check(), folly::dynamic::object(), and schema.

                                                 {
  dynamic schema = dynamic::object("minimum", 1.75)("exclusiveMinimum", true);
  ASSERT_FALSE(check(schema, 1.75));
}

TEST	(	JSONSchemaTest	,
		TestMaximumDoubleInclusive
	)

Definition at line 110 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                                 {
  dynamic schema = dynamic::object("maximum", 12.75);
  ASSERT_TRUE(check(schema, "invalid"));
  ASSERT_TRUE(check(schema, 3));
  ASSERT_TRUE(check(schema, 3.1));
  ASSERT_TRUE(check(schema, 12.75));
  ASSERT_FALSE(check(schema, 13));
  ASSERT_FALSE(check(schema, 12.76));
}

TEST	(	JSONSchemaTest	,
		TestMaximumDoubleExclusive
	)

Definition at line 120 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, check(), folly::dynamic::object(), and schema.

                                                 {
  dynamic schema = dynamic::object("maximum", 12.75)("exclusiveMaximum", true);
  ASSERT_FALSE(check(schema, 12.75));
}

TEST	(	JSONSchemaTest	,
		TestInvalidSchema
	)

Definition at line 125 of file JSONSchemaTest.cpp.

References ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                        {
  dynamic schema = dynamic::object("multipleOf", "invalid");
  // don't check the schema since it's meant to be invalid
  ASSERT_TRUE(check(schema, 30, false));

  schema = dynamic::object("minimum", "invalid")("maximum", "invalid");
  ASSERT_TRUE(check(schema, 2, false));

  schema = dynamic::object("minLength", "invalid")("maxLength", "invalid");
  ASSERT_TRUE(check(schema, 2, false));
  ASSERT_TRUE(check(schema, "foo", false));
}

TEST	(	JSONSchemaTest	,
		TestMinimumStringLength
	)

Definition at line 138 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                              {
  dynamic schema = dynamic::object("minLength", 3);
  ASSERT_TRUE(check(schema, "abcde"));
  ASSERT_TRUE(check(schema, "abc"));
  ASSERT_FALSE(check(schema, "a"));
}

TEST	(	JSONSchemaTest	,
		TestMaximumStringLength
	)

Definition at line 145 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                              {
  dynamic schema = dynamic::object("maxLength", 3);
  ASSERT_FALSE(check(schema, "abcde"));
  ASSERT_TRUE(check(schema, "abc"));
  ASSERT_TRUE(check(schema, "a"));
}

TEST	(	JSONSchemaTest	,
		TestStringPattern
	)

Definition at line 152 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                        {
  dynamic schema = dynamic::object("pattern", "[1-9]+");
  ASSERT_TRUE(check(schema, "123"));
  ASSERT_FALSE(check(schema, "abc"));
}

TEST	(	JSONSchemaTest	,
		TestMinimumArrayItems
	)

Definition at line 158 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                            {
  dynamic schema = dynamic::object("minItems", 3);
  ASSERT_TRUE(check(schema, dynamic::array(1, 2, 3, 4, 5)));
  ASSERT_TRUE(check(schema, dynamic::array(1, 2, 3)));
  ASSERT_FALSE(check(schema, dynamic::array(1)));
}

TEST	(	JSONSchemaTest	,
		TestMaximumArrayItems
	)

Definition at line 165 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                            {
  dynamic schema = dynamic::object("maxItems", 3);
  ASSERT_FALSE(check(schema, dynamic::array(1, 2, 3, 4, 5)));
  ASSERT_TRUE(check(schema, dynamic::array(1, 2, 3)));
  ASSERT_TRUE(check(schema, dynamic::array(1)));
  ASSERT_TRUE(check(schema, "foobar"));
}

TEST	(	JSONSchemaTest	,
		TestArrayUniqueItems
	)

Definition at line 173 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                           {
  dynamic schema = dynamic::object("uniqueItems", true);
  ASSERT_TRUE(check(schema, dynamic::array(1, 2, 3)));
  ASSERT_FALSE(check(schema, dynamic::array(1, 2, 3, 1)));
  ASSERT_FALSE(check(schema, dynamic::array("cat", "dog", 1, 2, "cat")));
  ASSERT_TRUE(check(
      schema,
      dynamic::array(
          dynamic::object("foo", "bar"), dynamic::object("foo", "baz"))));

  schema = dynamic::object("uniqueItems", false);
  ASSERT_TRUE(check(schema, dynamic::array(1, 2, 3, 1)));
}

TEST	(	JSONSchemaTest	,
		TestArrayItems
	)

Definition at line 187 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                     {
  dynamic schema = dynamic::object("items", dynamic::object("minimum", 2));
  ASSERT_TRUE(check(schema, dynamic::array(2, 3, 4)));
  ASSERT_FALSE(check(schema, dynamic::array(3, 4, 1)));
}

TEST	(	JSONSchemaTest	,
		TestArrayAdditionalItems
	)

Definition at line 193 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                               {
  dynamic schema = dynamic::object(
      "items",
      dynamic::array(
          dynamic::object("minimum", 2), dynamic::object("minimum", 1)))(
      "additionalItems", dynamic::object("minimum", 3));
  ASSERT_TRUE(check(schema, dynamic::array(2, 1, 3, 3, 3, 3, 4)));
  ASSERT_FALSE(check(schema, dynamic::array(2, 1, 3, 3, 3, 3, 1)));
}

TEST	(	JSONSchemaTest	,
		TestArrayNoAdditionalItems
	)

Definition at line 203 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, check(), folly::dynamic::object(), and schema.

                                                 {
  dynamic schema =
      dynamic::object("items", dynamic::array(dynamic::object("minimum", 2)))(
          "additionalItems", false);
  ASSERT_FALSE(check(schema, dynamic::array(3, 3, 3)));
}

TEST	(	JSONSchemaTest	,
		TestArrayItemsNotPresent
	)

Definition at line 210 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                               {
  dynamic schema = dynamic::object("additionalItems", false);
  ASSERT_TRUE(check(schema, dynamic::array(3, 3, 3)));
}

TEST	(	JSONSchemaTest	,
		TestRef
	)

Definition at line 215 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                              {
  dynamic schema = dynamic::object(
      "definitions",
      dynamic::object(
          "positiveInteger", dynamic::object("minimum", 1)("type", "integer")))(
      "items", dynamic::object("$ref", "#/definitions/positiveInteger"));
  ASSERT_TRUE(check(schema, dynamic::array(1, 2, 3, 4)));
  ASSERT_FALSE(check(schema, dynamic::array(4, -5)));
}

TEST	(	JSONSchemaTest	,
		TestRecursiveRef
	)

Definition at line 225 of file JSONSchemaTest.cpp.

References ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                       {
  dynamic schema = dynamic::object(
      "properties", dynamic::object("more", dynamic::object("$ref", "#")));
  dynamic d = dynamic::object;
  ASSERT_TRUE(check(schema, d));
  d["more"] = dynamic::object;
  ASSERT_TRUE(check(schema, d));
  d["more"]["more"] = dynamic::object;
  ASSERT_TRUE(check(schema, d));
  d["more"]["more"]["more"] = dynamic::object;
  ASSERT_TRUE(check(schema, d));
}

TEST	(	JSONSchemaTest	,
		TestDoubleRecursiveRef
	)

Definition at line 238 of file JSONSchemaTest.cpp.

References ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                             {
  dynamic schema = dynamic::object(
      "properties",
      dynamic::object("more", dynamic::object("$ref", "#"))(
          "less", dynamic::object("$ref", "#")));
  dynamic d = dynamic::object;
  ASSERT_TRUE(check(schema, d));
  d["more"] = dynamic::object;
  d["less"] = dynamic::object;
  ASSERT_TRUE(check(schema, d));
  d["more"]["less"] = dynamic::object;
  d["less"]["mode"] = dynamic::object;
  ASSERT_TRUE(check(schema, d));
}

TEST	(	JSONSchemaTest	,
		TestInfinitelyRecursiveRef
	)

Definition at line 253 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_THROW, folly::jsonschema::makeValidator(), folly::dynamic::object(), and schema.

                                                 {
  dynamic schema = dynamic::object("not", dynamic::object("$ref", "#"));
  auto validator = makeValidator(schema);
  ASSERT_THROW(validator->validate(dynamic::array(1, 2)), std::runtime_error);
}

TEST	(	JSONSchemaTest	,
		TestRequired
	)

Definition at line 259 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                   {
  dynamic schema = dynamic::object("required", dynamic::array("foo", "bar"));
  ASSERT_FALSE(check(schema, dynamic::object("foo", 123)));
  ASSERT_FALSE(check(schema, dynamic::object("bar", 123)));
  ASSERT_TRUE(check(schema, dynamic::object("bar", 123)("foo", 456)));
}

TEST	(	JSONSchemaTest	,
		TestMinMaxProperties
	)

Definition at line 266 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                           {
  dynamic schema = dynamic::object("minProperties", 1)("maxProperties", 3);
  dynamic d = dynamic::object;
  ASSERT_FALSE(check(schema, d));
  d["a"] = 1;
  ASSERT_TRUE(check(schema, d));
  d["b"] = 2;
  ASSERT_TRUE(check(schema, d));
  d["c"] = 3;
  ASSERT_TRUE(check(schema, d));
  d["d"] = 4;
  ASSERT_FALSE(check(schema, d));
}

TEST	(	JSONSchemaTest	,
		TestProperties
	)

Definition at line 280 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                     {
  dynamic schema = dynamic::object(
      "properties", dynamic::object("p1", dynamic::object("minimum", 1)))(
      "patternProperties", dynamic::object("[0-9]+", dynamic::object))(
      "additionalProperties", dynamic::object("maximum", 5));
  ASSERT_TRUE(check(schema, dynamic::object("p1", 1)));
  ASSERT_FALSE(check(schema, dynamic::object("p1", 0)));
  ASSERT_TRUE(check(schema, dynamic::object("123", "anything")));
  ASSERT_TRUE(check(schema, dynamic::object("123", 500)));
  ASSERT_TRUE(check(schema, dynamic::object("other_property", 4)));
  ASSERT_FALSE(check(schema, dynamic::object("other_property", 6)));
}

TEST	(	JSONSchemaTest	,
		TestPropertyAndPattern
	)

Definition at line 292 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                             {
  dynamic schema = dynamic::object(
      "properties", dynamic::object("p1", dynamic::object("minimum", 1)))(
      "patternProperties",
      dynamic::object("p.", dynamic::object("maximum", 5)));
  ASSERT_TRUE(check(schema, dynamic::object("p1", 3)));
  ASSERT_FALSE(check(schema, dynamic::object("p1", 0)));
  ASSERT_FALSE(check(schema, dynamic::object("p1", 6)));
}

TEST	(	JSONSchemaTest	,
		TestPropertyDependency
	)

Definition at line 302 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                             {
  dynamic schema = dynamic::object(
      "dependencies", dynamic::object("p1", dynamic::array("p2")));
  ASSERT_TRUE(check(schema, dynamic::object));
  ASSERT_TRUE(check(schema, dynamic::object("p1", 1)("p2", 1)));
  ASSERT_FALSE(check(schema, dynamic::object("p1", 1)));
}

TEST	(	JSONSchemaTest	,
		TestSchemaDependency
	)

Definition at line 310 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                           {
  dynamic schema = dynamic::object(
      "dependencies",
      dynamic::object("p1", dynamic::object("required", dynamic::array("p2"))));
  ASSERT_TRUE(check(schema, dynamic::object));
  ASSERT_TRUE(check(schema, dynamic::object("p1", 1)("p2", 1)));
  ASSERT_FALSE(check(schema, dynamic::object("p1", 1)));
}

TEST	(	JSONSchemaTest	,
		TestEnum
	)

Definition at line 319 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                               {
  dynamic schema = dynamic::object("enum", dynamic::array("a", 1));
  ASSERT_TRUE(check(schema, "a"));
  ASSERT_TRUE(check(schema, 1));
  ASSERT_FALSE(check(schema, "b"));
}

TEST	(	JSONSchemaTest	,
		TestType
	)

Definition at line 326 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                               {
  dynamic schema = dynamic::object("type", "object");
  ASSERT_TRUE(check(schema, dynamic::object));
  ASSERT_FALSE(check(schema, dynamic(5)));
}

TEST	(	JSONSchemaTest	,
		TestTypeArray
	)

Definition at line 332 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                    {
  dynamic schema = dynamic::object("type", dynamic::array("array", "number"));
  ASSERT_TRUE(check(schema, dynamic(5)));
  ASSERT_TRUE(check(schema, dynamic(1.1)));
  ASSERT_FALSE(check(schema, dynamic::object));
}

TEST	(	JSONSchemaTest	,
		TestAllOf
	)

Definition at line 339 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                {
  dynamic schema = dynamic::object(
      "allOf",
      dynamic::array(
          dynamic::object("minimum", 1), dynamic::object("type", "integer")));
  ASSERT_TRUE(check(schema, 2));
  ASSERT_FALSE(check(schema, 0));
  ASSERT_FALSE(check(schema, 1.1));
}

TEST	(	JSONSchemaTest	,
		TestAnyOf
	)

Definition at line 349 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                {
  dynamic schema = dynamic::object(
      "anyOf",
      dynamic::array(
          dynamic::object("minimum", 1), dynamic::object("type", "integer")));
  ASSERT_TRUE(check(schema, 2)); // matches both
  ASSERT_FALSE(check(schema, 0.1)); // matches neither
  ASSERT_TRUE(check(schema, 1.1)); // matches first one
  ASSERT_TRUE(check(schema, 0)); // matches second one
}

TEST	(	JSONSchemaTest	,
		TestOneOf
	)

Definition at line 360 of file JSONSchemaTest.cpp.

References folly::dynamic::array(), ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                                {
  dynamic schema = dynamic::object(
      "oneOf",
      dynamic::array(
          dynamic::object("minimum", 1), dynamic::object("type", "integer")));
  ASSERT_FALSE(check(schema, 2)); // matches both
  ASSERT_FALSE(check(schema, 0.1)); // matches neither
  ASSERT_TRUE(check(schema, 1.1)); // matches first one
  ASSERT_TRUE(check(schema, 0)); // matches second one
}

TEST	(	JSONSchemaTest	,
		TestNot
	)

Definition at line 371 of file JSONSchemaTest.cpp.

References ASSERT_FALSE, ASSERT_TRUE, check(), folly::dynamic::object(), and schema.

                              {
  dynamic schema =
      dynamic::object("not", dynamic::object("minimum", 5)("maximum", 10));
  ASSERT_TRUE(check(schema, 4));
  ASSERT_FALSE(check(schema, 7));
  ASSERT_TRUE(check(schema, 11));
}

TEST	(	JSONSchemaTest	,
		TestMetaSchema
	)

Definition at line 381 of file JSONSchemaTest.cpp.

References ASSERT_THROW, folly::jsonschema::makeSchemaValidator(), folly::parseJson(), and val.

                                     {
  const char* example1 =
      "\
    { \
      \"title\": \"Example Schema\", \
      \"type\": \"object\", \
      \"properties\": { \
        \"firstName\": { \
          \"type\": \"string\" \
        }, \
        \"lastName\": { \
          \"type\": \"string\" \
        }, \
        \"age\": { \
          \"description\": \"Age in years\", \
          \"type\": \"integer\", \
          \"minimum\": 0 \
        } \
      }, \
      \"required\": [\"firstName\", \"lastName\"] \
    }";

  auto val = makeSchemaValidator();
  val->validate(parseJson(example1)); // doesn't throw

  ASSERT_THROW(val->validate("123"), std::runtime_error);
}

TEST	(	JSONSchemaTest	,
		TestProductSchema
	)

Definition at line 409 of file JSONSchemaTest.cpp.

References ASSERT_TRUE, check(), folly::parseJson(), and product.

                                        {
  const char* productSchema =
      "\
  { \
    \"$schema\": \"http://json-schema.org/draft-04/schema#\", \
      \"title\": \"Product\", \
      \"description\": \"A product from Acme's catalog\", \
      \"type\": \"object\", \
      \"properties\": { \
        \"id\": { \
          \"description\": \"The unique identifier for a product\", \
          \"type\": \"integer\" \
        }, \
        \"name\": { \
          \"description\": \"Name of the product\", \
          \"type\": \"string\" \
        }, \
        \"price\": { \
          \"type\": \"number\", \
          \"minimum\": 0, \
          \"exclusiveMinimum\": true \
        }, \
        \"tags\": { \
          \"type\": \"array\", \
          \"items\": { \
            \"type\": \"string\" \
          }, \
          \"minItems\": 1, \
          \"uniqueItems\": true \
        } \
      }, \
      \"required\": [\"id\", \"name\", \"price\"] \
  }";
  const char* product =
      "\
  { \
    \"id\": 1, \
    \"name\": \"A green door\", \
    \"price\": 12.50, \
    \"tags\": [\"home\", \"green\"] \
  }";
  ASSERT_TRUE(check(parseJson(productSchema), parseJson(product)));
}