From b1db205d75824ebd32db173f31158430e7713bc7 Mon Sep 17 00:00:00 2001 From: karan-palan Date: Mon, 28 Jul 2025 04:42:56 +0530 Subject: [PATCH 01/13] create rule to remove other validation keywords when enum is present based on type Signed-off-by: karan-palan --- src/core/jsonschema/transformer.cc | 1 - src/extension/alterschema/CMakeLists.txt | 3 +- src/extension/alterschema/alterschema.cc | 2 + .../linter/enum_validation_keywords_default.h | 94 +++++++++++++++++++ .../alterschema_lint_2019_09_test.cc | 53 +++++++++++ .../alterschema_lint_2020_12_test.cc | 57 +++++++++++ .../alterschema_lint_draft0_test.cc | 53 +++++++++++ .../alterschema_lint_draft1_test.cc | 53 +++++++++++ .../alterschema_lint_draft2_test.cc | 53 +++++++++++ .../alterschema_lint_draft3_test.cc | 53 +++++++++++ .../alterschema_lint_draft4_test.cc | 53 +++++++++++ .../alterschema_lint_draft6_test.cc | 53 +++++++++++ .../alterschema_lint_draft7_test.cc | 53 +++++++++++ 13 files changed, 579 insertions(+), 2 deletions(-) create mode 100644 src/extension/alterschema/linter/enum_validation_keywords_default.h diff --git a/src/core/jsonschema/transformer.cc b/src/core/jsonschema/transformer.cc index e79cc7be9..20e98aab8 100644 --- a/src/core/jsonschema/transformer.cc +++ b/src/core/jsonschema/transformer.cc @@ -26,7 +26,6 @@ auto calculate_health_percentage(const std::size_t subschemas, -> std::uint8_t { assert(failed_subschemas <= subschemas); const auto result{100 - (failed_subschemas * 100 / subschemas)}; - assert(result >= 0); assert(result <= 100); return static_cast(result); } diff --git a/src/extension/alterschema/CMakeLists.txt b/src/extension/alterschema/CMakeLists.txt index 9bb24d580..df44e3c11 100644 --- a/src/extension/alterschema/CMakeLists.txt +++ b/src/extension/alterschema/CMakeLists.txt @@ -64,7 +64,8 @@ sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME alterschema linter/else_empty.h linter/then_without_if.h linter/property_names_type_default.h - linter/property_names_default.h) + linter/property_names_default.h + linter/enum_validation_keywords_default.h) if(SOURCEMETA_CORE_INSTALL) sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME alterschema) diff --git a/src/extension/alterschema/alterschema.cc b/src/extension/alterschema/alterschema.cc index 3312b4825..5e99d4291 100644 --- a/src/extension/alterschema/alterschema.cc +++ b/src/extension/alterschema/alterschema.cc @@ -53,6 +53,7 @@ contains_any(const Vocabularies &container, #include "linter/else_empty.h" #include "linter/else_without_if.h" #include "linter/enum_to_const.h" +#include "linter/enum_validation_keywords_default.h" #include "linter/enum_with_type.h" #include "linter/equal_numeric_bounds_to_enum.h" #include "linter/exclusive_maximum_number_and_maximum.h" @@ -112,6 +113,7 @@ auto add(SchemaTransformer &bundle, const AlterSchemaMode mode) bundle.add(); bundle.add(); bundle.add(); + bundle.add(); bundle.add(); bundle.add(); bundle.add(); diff --git a/src/extension/alterschema/linter/enum_validation_keywords_default.h b/src/extension/alterschema/linter/enum_validation_keywords_default.h new file mode 100644 index 000000000..4ba3dacde --- /dev/null +++ b/src/extension/alterschema/linter/enum_validation_keywords_default.h @@ -0,0 +1,94 @@ +class EnumValidationKeywordsDefault final : public SchemaTransformRule { +public: + EnumValidationKeywordsDefault() + : SchemaTransformRule{ + "enum_validation_keywords_default", + "Setting validation keywords alongside `enum` is considered an " + "anti-pattern, as the enumeration choices already imply their " + "respective constraints"} {}; + + [[nodiscard]] auto + condition(const sourcemeta::core::JSON &schema, + const sourcemeta::core::JSON &, + const sourcemeta::core::Vocabularies &vocabularies, + const sourcemeta::core::SchemaFrame &, + const sourcemeta::core::SchemaFrame::Location &, + const sourcemeta::core::SchemaWalker &walker, + const sourcemeta::core::SchemaResolver &) const + -> sourcemeta::core::SchemaTransformRule::Result override { + if (!contains_any(vocabularies, + {"https://json-schema.org/draft/2020-12/vocab/validation", + "https://json-schema.org/draft/2019-09/vocab/validation", + "http://json-schema.org/draft-07/schema#", + "http://json-schema.org/draft-06/schema#", + "http://json-schema.org/draft-04/schema#", + "http://json-schema.org/draft-03/schema#", + "http://json-schema.org/draft-02/schema#", + "http://json-schema.org/draft-02/hyper-schema#", + "http://json-schema.org/draft-01/schema#", + "http://json-schema.org/draft-01/hyper-schema#", + "http://json-schema.org/draft-00/schema#", + "http://json-schema.org/draft-00/hyper-schema#"}) || + !schema.is_object() || !schema.defines("enum") || + !schema.at("enum").is_array() || schema.defines("$ref")) { + return false; + } + + std::set enum_types; + for (const auto &value : schema.at("enum").as_array()) { + if (value.is_null()) { + enum_types.emplace(sourcemeta::core::JSON::Type::Null); + } else if (value.is_boolean()) { + enum_types.emplace(sourcemeta::core::JSON::Type::Boolean); + } else if (value.is_integer()) { + enum_types.emplace(sourcemeta::core::JSON::Type::Integer); + } else if (value.is_real()) { + enum_types.emplace(sourcemeta::core::JSON::Type::Real); + } else if (value.is_string()) { + enum_types.emplace(sourcemeta::core::JSON::Type::String); + } else if (value.is_array()) { + enum_types.emplace(sourcemeta::core::JSON::Type::Array); + } else if (value.is_object()) { + enum_types.emplace(sourcemeta::core::JSON::Type::Object); + } + } + + if (enum_types.empty()) { + return false; + } + + // Build blacklist of keywords that don't apply to any enum value types + this->blacklist.clear(); + for (const auto &entry : schema.as_object()) { + if (entry.first == "enum" || entry.first == "$schema" || + entry.first == "$id" || entry.first == "$ref") { + continue; + } + + const auto metadata = walker(entry.first, vocabularies); + + // If keyword applies to any type, we can't determine type applicability + if (metadata.instances.empty()) { + continue; + } + + // If none of the types that the keyword applies to match the enum types, + // then this keyword is redundant and can be removed + if (std::ranges::none_of(metadata.instances, + [&enum_types](const auto keyword_type) { + return enum_types.contains(keyword_type); + })) { + this->blacklist.emplace_back(entry.first); + } + } + + return !this->blacklist.empty(); + } + + auto transform(sourcemeta::core::JSON &schema) const -> void override { + schema.erase_keys(this->blacklist.cbegin(), this->blacklist.cend()); + } + +private: + mutable std::vector blacklist; +}; diff --git a/test/alterschema/alterschema_lint_2019_09_test.cc b/test/alterschema/alterschema_lint_2019_09_test.cc index 171d82775..51da3bbdd 100644 --- a/test/alterschema/alterschema_lint_2019_09_test.cc +++ b/test/alterschema/alterschema_lint_2019_09_test.cc @@ -54,6 +54,59 @@ TEST(AlterSchema_lint_2019_09, enum_with_type_1) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_1) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ "foo", "bar" ], + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ "foo", "bar" ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_2) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ 1, 2, 3 ], + "minLength": 0, + "maxLength": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ 1, 2, 3 ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_3) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ {"a": 1}, {"b": 2} ], + "minLength": 3, + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ {"a": 1}, {"b": 2} ] + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_2019_09, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", diff --git a/test/alterschema/alterschema_lint_2020_12_test.cc b/test/alterschema/alterschema_lint_2020_12_test.cc index bbad7d002..15d88f81d 100644 --- a/test/alterschema/alterschema_lint_2020_12_test.cc +++ b/test/alterschema/alterschema_lint_2020_12_test.cc @@ -2528,3 +2528,60 @@ TEST(AlterSchema_lint_2020_12, property_names_default_1) { EXPECT_EQ(document, expected); } + +TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_1) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ 1, 2, 3 ], + "minLength": 3, + "pattern": "^[a-z]+$" + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ 1, 2, 3 ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_2) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ "one", "two" ], + "minimum": 0, + "maximum": 100, + "multipleOf": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ "one", "two" ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_3) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ true, false ], + "minLength": 1, + "minimum": 0, + "minItems": 1, + "minProperties": 1 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ true, false ] + })JSON"); + + EXPECT_EQ(document, expected); +} diff --git a/test/alterschema/alterschema_lint_draft0_test.cc b/test/alterschema/alterschema_lint_draft0_test.cc index 956eac3db..a1da13c46 100644 --- a/test/alterschema/alterschema_lint_draft0_test.cc +++ b/test/alterschema/alterschema_lint_draft0_test.cc @@ -20,6 +20,59 @@ TEST(AlterSchema_lint_draft0, single_type_array_1) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_1) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ "foo", "bar" ], + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ "foo", "bar" ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_2) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ 1, 2, 3 ], + "minLength": 0, + "maxLength": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ 1, 2, 3 ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_3) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ {"a": 1}, {"b": 2} ], + "minLength": 3, + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ {"a": 1}, {"b": 2} ] + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft0, drop_non_array_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", diff --git a/test/alterschema/alterschema_lint_draft1_test.cc b/test/alterschema/alterschema_lint_draft1_test.cc index 350207549..ac60cd7d8 100644 --- a/test/alterschema/alterschema_lint_draft1_test.cc +++ b/test/alterschema/alterschema_lint_draft1_test.cc @@ -21,6 +21,59 @@ TEST(AlterSchema_lint_draft1, enum_with_type_1) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_1) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ "foo", "bar" ], + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ "foo", "bar" ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_2) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ 1, 2, 3 ], + "minLength": 0, + "maxLength": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ 1, 2, 3 ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_3) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ {"a": 1}, {"b": 2} ], + "minLength": 3, + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ {"a": 1}, {"b": 2} ] + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft1, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", diff --git a/test/alterschema/alterschema_lint_draft2_test.cc b/test/alterschema/alterschema_lint_draft2_test.cc index 955815d09..1ae2b8f35 100644 --- a/test/alterschema/alterschema_lint_draft2_test.cc +++ b/test/alterschema/alterschema_lint_draft2_test.cc @@ -21,6 +21,59 @@ TEST(AlterSchema_lint_draft2, enum_with_type_1) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_1) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ "foo", "bar" ], + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ "foo", "bar" ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_2) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ 1, 2, 3 ], + "minLength": 0, + "maxLength": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ 1, 2, 3 ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_3) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ {"a": 1}, {"b": 2} ], + "minLength": 3, + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ {"a": 1}, {"b": 2} ] + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft2, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", diff --git a/test/alterschema/alterschema_lint_draft3_test.cc b/test/alterschema/alterschema_lint_draft3_test.cc index 28c3ee3b9..51641a617 100644 --- a/test/alterschema/alterschema_lint_draft3_test.cc +++ b/test/alterschema/alterschema_lint_draft3_test.cc @@ -21,6 +21,59 @@ TEST(AlterSchema_lint_draft3, enum_with_type_1) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_1) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ "foo", "bar" ], + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ "foo", "bar" ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_2) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ 1, 2, 3 ], + "minLength": 0, + "maxLength": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ 1, 2, 3 ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_3) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ {"a": 1}, {"b": 2} ], + "minLength": 3, + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ {"a": 1}, {"b": 2} ] + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft3, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", diff --git a/test/alterschema/alterschema_lint_draft4_test.cc b/test/alterschema/alterschema_lint_draft4_test.cc index 2321c065b..63c0f4319 100644 --- a/test/alterschema/alterschema_lint_draft4_test.cc +++ b/test/alterschema/alterschema_lint_draft4_test.cc @@ -21,6 +21,59 @@ TEST(AlterSchema_lint_draft4, enum_with_type_1) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_1) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ "foo", "bar" ], + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ "foo", "bar" ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_2) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ 1, 2, 3 ], + "minLength": 0, + "maxLength": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ 1, 2, 3 ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_3) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ {"a": 1}, {"b": 2} ], + "minLength": 3, + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ {"a": 1}, {"b": 2} ] + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft4, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", diff --git a/test/alterschema/alterschema_lint_draft6_test.cc b/test/alterschema/alterschema_lint_draft6_test.cc index 71a90b24b..819697c8b 100644 --- a/test/alterschema/alterschema_lint_draft6_test.cc +++ b/test/alterschema/alterschema_lint_draft6_test.cc @@ -54,6 +54,59 @@ TEST(AlterSchema_lint_draft6, enum_with_type_1) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_1) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ "foo", "bar" ], + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ "foo", "bar" ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_2) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ 1, 2, 3 ], + "minLength": 0, + "maxLength": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ 1, 2, 3 ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_3) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ {"a": 1}, {"b": 2} ], + "minLength": 3, + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ {"a": 1}, {"b": 2} ] + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft6, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", diff --git a/test/alterschema/alterschema_lint_draft7_test.cc b/test/alterschema/alterschema_lint_draft7_test.cc index 3a4268637..e513b4b9c 100644 --- a/test/alterschema/alterschema_lint_draft7_test.cc +++ b/test/alterschema/alterschema_lint_draft7_test.cc @@ -54,6 +54,59 @@ TEST(AlterSchema_lint_draft7, enum_with_type_1) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_1) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ "foo", "bar" ], + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ "foo", "bar" ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_2) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ 1, 2, 3 ], + "minLength": 0, + "maxLength": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ 1, 2, 3 ] + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_3) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ {"a": 1}, {"b": 2} ], + "minLength": 3, + "minimum": 0 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ {"a": 1}, {"b": 2} ] + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft7, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", From acd725484f673d534becec54446fe1582bedd572 Mon Sep 17 00:00:00 2001 From: karan-palan Date: Mon, 28 Jul 2025 19:07:51 +0530 Subject: [PATCH 02/13] use type to remove keyword chekcs, use walker types instead of manual string Signed-off-by: karan-palan --- .../linter/enum_validation_keywords_default.h | 32 +++++-------------- 1 file changed, 8 insertions(+), 24 deletions(-) diff --git a/src/extension/alterschema/linter/enum_validation_keywords_default.h b/src/extension/alterschema/linter/enum_validation_keywords_default.h index 4ba3dacde..12b4b9adf 100644 --- a/src/extension/alterschema/linter/enum_validation_keywords_default.h +++ b/src/extension/alterschema/linter/enum_validation_keywords_default.h @@ -36,37 +36,21 @@ class EnumValidationKeywordsDefault final : public SchemaTransformRule { std::set enum_types; for (const auto &value : schema.at("enum").as_array()) { - if (value.is_null()) { - enum_types.emplace(sourcemeta::core::JSON::Type::Null); - } else if (value.is_boolean()) { - enum_types.emplace(sourcemeta::core::JSON::Type::Boolean); - } else if (value.is_integer()) { - enum_types.emplace(sourcemeta::core::JSON::Type::Integer); - } else if (value.is_real()) { - enum_types.emplace(sourcemeta::core::JSON::Type::Real); - } else if (value.is_string()) { - enum_types.emplace(sourcemeta::core::JSON::Type::String); - } else if (value.is_array()) { - enum_types.emplace(sourcemeta::core::JSON::Type::Array); - } else if (value.is_object()) { - enum_types.emplace(sourcemeta::core::JSON::Type::Object); - } + enum_types.emplace(value.type()); } if (enum_types.empty()) { return false; } - // Build blacklist of keywords that don't apply to any enum value types this->blacklist.clear(); for (const auto &entry : schema.as_object()) { - if (entry.first == "enum" || entry.first == "$schema" || - entry.first == "$id" || entry.first == "$ref") { + const auto metadata = walker(entry.first, vocabularies); + if (metadata.type == sourcemeta::core::SchemaKeywordType::Other || + metadata.type == sourcemeta::core::SchemaKeywordType::Reference) { continue; } - const auto metadata = walker(entry.first, vocabularies); - // If keyword applies to any type, we can't determine type applicability if (metadata.instances.empty()) { continue; @@ -74,10 +58,10 @@ class EnumValidationKeywordsDefault final : public SchemaTransformRule { // If none of the types that the keyword applies to match the enum types, // then this keyword is redundant and can be removed - if (std::ranges::none_of(metadata.instances, - [&enum_types](const auto keyword_type) { - return enum_types.contains(keyword_type); - })) { + if (std::none_of(metadata.instances.cbegin(), metadata.instances.cend(), + [&enum_types](const auto keyword_type) { + return enum_types.contains(keyword_type); + })) { this->blacklist.emplace_back(entry.first); } } From 4e0891ee3cc51964c8e3141ef8a6130f4610ffec Mon Sep 17 00:00:00 2001 From: karan-palan Date: Thu, 31 Jul 2025 00:53:26 +0530 Subject: [PATCH 03/13] attempt to fix macos ci Signed-off-by: karan-palan --- .../linter/enum_validation_keywords_default.h | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/extension/alterschema/linter/enum_validation_keywords_default.h b/src/extension/alterschema/linter/enum_validation_keywords_default.h index 12b4b9adf..1de9fd2c8 100644 --- a/src/extension/alterschema/linter/enum_validation_keywords_default.h +++ b/src/extension/alterschema/linter/enum_validation_keywords_default.h @@ -58,10 +58,11 @@ class EnumValidationKeywordsDefault final : public SchemaTransformRule { // If none of the types that the keyword applies to match the enum types, // then this keyword is redundant and can be removed - if (std::none_of(metadata.instances.cbegin(), metadata.instances.cend(), - [&enum_types](const auto keyword_type) { - return enum_types.contains(keyword_type); - })) { + if (std::ranges::none_of(metadata.instances.cbegin(), + metadata.instances.cend(), + [&enum_types](const auto keyword_type) { + return enum_types.contains(keyword_type); + })) { this->blacklist.emplace_back(entry.first); } } From c1066521276db9467cb4cdfddf7eb6973755e9d9 Mon Sep 17 00:00:00 2001 From: karan-palan Date: Mon, 4 Aug 2025 18:45:33 +0530 Subject: [PATCH 04/13] add whitepsace for consistency Signed-off-by: karan-palan --- test/alterschema/alterschema_lint_2019_09_test.cc | 4 ++-- test/alterschema/alterschema_lint_draft0_test.cc | 4 ++-- test/alterschema/alterschema_lint_draft1_test.cc | 4 ++-- test/alterschema/alterschema_lint_draft2_test.cc | 4 ++-- test/alterschema/alterschema_lint_draft3_test.cc | 4 ++-- test/alterschema/alterschema_lint_draft4_test.cc | 4 ++-- test/alterschema/alterschema_lint_draft6_test.cc | 4 ++-- test/alterschema/alterschema_lint_draft7_test.cc | 4 ++-- 8 files changed, 16 insertions(+), 16 deletions(-) diff --git a/test/alterschema/alterschema_lint_2019_09_test.cc b/test/alterschema/alterschema_lint_2019_09_test.cc index a367bca2d..6d57fafef 100644 --- a/test/alterschema/alterschema_lint_2019_09_test.cc +++ b/test/alterschema/alterschema_lint_2019_09_test.cc @@ -92,7 +92,7 @@ TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_2) { TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", - "enum": [ {"a": 1}, {"b": 2} ], + "enum": [ { "a": 1 }, { "b": 2 } ], "minLength": 3, "minimum": 0 })JSON"); @@ -101,7 +101,7 @@ TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_3) { const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", - "enum": [ {"a": 1}, {"b": 2} ] + "enum": [ { "a": 1 }, { "b": 2 } ] })JSON"); EXPECT_EQ(document, expected); diff --git a/test/alterschema/alterschema_lint_draft0_test.cc b/test/alterschema/alterschema_lint_draft0_test.cc index 020fef576..27a69fd83 100644 --- a/test/alterschema/alterschema_lint_draft0_test.cc +++ b/test/alterschema/alterschema_lint_draft0_test.cc @@ -58,7 +58,7 @@ TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_2) { TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ {"a": 1}, {"b": 2} ], + "enum": [ { "a": 1 }, { "b": 2 } ], "minLength": 3, "minimum": 0 })JSON"); @@ -67,7 +67,7 @@ TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_3) { const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ {"a": 1}, {"b": 2} ] + "enum": [ { "a": 1 }, { "b": 2 } ] })JSON"); EXPECT_EQ(document, expected); diff --git a/test/alterschema/alterschema_lint_draft1_test.cc b/test/alterschema/alterschema_lint_draft1_test.cc index f453ba065..1b833ba07 100644 --- a/test/alterschema/alterschema_lint_draft1_test.cc +++ b/test/alterschema/alterschema_lint_draft1_test.cc @@ -59,7 +59,7 @@ TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_2) { TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", - "enum": [ {"a": 1}, {"b": 2} ], + "enum": [ { "a": 1 }, { "b": 2 } ], "minLength": 3, "minimum": 0 })JSON"); @@ -68,7 +68,7 @@ TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_3) { const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", - "enum": [ {"a": 1}, {"b": 2} ] + "enum": [ { "a": 1 }, { "b": 2 } ] })JSON"); EXPECT_EQ(document, expected); diff --git a/test/alterschema/alterschema_lint_draft2_test.cc b/test/alterschema/alterschema_lint_draft2_test.cc index c9ad6ded9..0e16ae3b3 100644 --- a/test/alterschema/alterschema_lint_draft2_test.cc +++ b/test/alterschema/alterschema_lint_draft2_test.cc @@ -59,7 +59,7 @@ TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_2) { TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", - "enum": [ {"a": 1}, {"b": 2} ], + "enum": [ { "a": 1 }, { "b": 2 } ], "minLength": 3, "minimum": 0 })JSON"); @@ -68,7 +68,7 @@ TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_3) { const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", - "enum": [ {"a": 1}, {"b": 2} ] + "enum": [ { "a": 1 }, { "b": 2 } ] })JSON"); EXPECT_EQ(document, expected); diff --git a/test/alterschema/alterschema_lint_draft3_test.cc b/test/alterschema/alterschema_lint_draft3_test.cc index 39d047905..71b78f61f 100644 --- a/test/alterschema/alterschema_lint_draft3_test.cc +++ b/test/alterschema/alterschema_lint_draft3_test.cc @@ -59,7 +59,7 @@ TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_2) { TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", - "enum": [ {"a": 1}, {"b": 2} ], + "enum": [ { "a": 1 }, { "b": 2 } ], "minLength": 3, "minimum": 0 })JSON"); @@ -68,7 +68,7 @@ TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_3) { const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", - "enum": [ {"a": 1}, {"b": 2} ] + "enum": [ { "a": 1 }, { "b": 2 } ] })JSON"); EXPECT_EQ(document, expected); diff --git a/test/alterschema/alterschema_lint_draft4_test.cc b/test/alterschema/alterschema_lint_draft4_test.cc index b9f13741b..3b1f63652 100644 --- a/test/alterschema/alterschema_lint_draft4_test.cc +++ b/test/alterschema/alterschema_lint_draft4_test.cc @@ -59,7 +59,7 @@ TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_2) { TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", - "enum": [ {"a": 1}, {"b": 2} ], + "enum": [ { "a": 1 }, { "b": 2 } ], "minLength": 3, "minimum": 0 })JSON"); @@ -68,7 +68,7 @@ TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_3) { const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", - "enum": [ {"a": 1}, {"b": 2} ] + "enum": [ { "a": 1 }, { "b": 2 } ] })JSON"); EXPECT_EQ(document, expected); diff --git a/test/alterschema/alterschema_lint_draft6_test.cc b/test/alterschema/alterschema_lint_draft6_test.cc index 0c2c832be..a93887411 100644 --- a/test/alterschema/alterschema_lint_draft6_test.cc +++ b/test/alterschema/alterschema_lint_draft6_test.cc @@ -92,7 +92,7 @@ TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_2) { TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", - "enum": [ {"a": 1}, {"b": 2} ], + "enum": [ { "a": 1 }, { "b": 2 } ], "minLength": 3, "minimum": 0 })JSON"); @@ -101,7 +101,7 @@ TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_3) { const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", - "enum": [ {"a": 1}, {"b": 2} ] + "enum": [ { "a": 1 }, { "b": 2 } ] })JSON"); EXPECT_EQ(document, expected); diff --git a/test/alterschema/alterschema_lint_draft7_test.cc b/test/alterschema/alterschema_lint_draft7_test.cc index c767f228d..a06db8d51 100644 --- a/test/alterschema/alterschema_lint_draft7_test.cc +++ b/test/alterschema/alterschema_lint_draft7_test.cc @@ -92,7 +92,7 @@ TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_2) { TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", - "enum": [ {"a": 1}, {"b": 2} ], + "enum": [ { "a": 1 }, { "b": 2 } ], "minLength": 3, "minimum": 0 })JSON"); @@ -101,7 +101,7 @@ TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_3) { const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", - "enum": [ {"a": 1}, {"b": 2} ] + "enum": [ { "a": 1 }, { "b": 2 } ] })JSON"); EXPECT_EQ(document, expected); From c443b4c43d336bd6e7840aa6eaae38bb6778b3ba Mon Sep 17 00:00:00 2001 From: karan-palan Date: Fri, 15 Aug 2025 05:56:42 +0530 Subject: [PATCH 05/13] add more tests Signed-off-by: karan-palan --- .../alterschema_lint_2019_09_test.cc | 116 +++++++++++++++ .../alterschema_lint_2020_12_test.cc | 135 ++++++++++++++++++ .../alterschema_lint_draft0_test.cc | 116 +++++++++++++++ .../alterschema_lint_draft1_test.cc | 116 +++++++++++++++ .../alterschema_lint_draft2_test.cc | 116 +++++++++++++++ .../alterschema_lint_draft3_test.cc | 116 +++++++++++++++ .../alterschema_lint_draft4_test.cc | 116 +++++++++++++++ .../alterschema_lint_draft6_test.cc | 116 +++++++++++++++ .../alterschema_lint_draft7_test.cc | 116 +++++++++++++++ 9 files changed, 1063 insertions(+) diff --git a/test/alterschema/alterschema_lint_2019_09_test.cc b/test/alterschema/alterschema_lint_2019_09_test.cc index 90f4a2975..07557f86a 100644 --- a/test/alterschema/alterschema_lint_2019_09_test.cc +++ b/test/alterschema/alterschema_lint_2019_09_test.cc @@ -212,6 +212,122 @@ TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_4) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0, + "minItems": 1 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + }, + "minLength": 5, + "minimum": 10 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_8) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_2019_09, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", diff --git a/test/alterschema/alterschema_lint_2020_12_test.cc b/test/alterschema/alterschema_lint_2020_12_test.cc index 953fb3385..d3e43cf58 100644 --- a/test/alterschema/alterschema_lint_2020_12_test.cc +++ b/test/alterschema/alterschema_lint_2020_12_test.cc @@ -2871,3 +2871,138 @@ TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } + +TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_4) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0, + "minItems": 1 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + }, + "minLength": 5, + "minimum": 10 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_8) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_9) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ 1, 2, 3 ], + "minLength": 2, + "maxLength": 10, + "pattern": "^[a-z]+$" + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ 1, 2, 3 ] + })JSON"); + + EXPECT_EQ(document, expected); +} diff --git a/test/alterschema/alterschema_lint_draft0_test.cc b/test/alterschema/alterschema_lint_draft0_test.cc index 27a69fd83..315628e5d 100644 --- a/test/alterschema/alterschema_lint_draft0_test.cc +++ b/test/alterschema/alterschema_lint_draft0_test.cc @@ -73,6 +73,122 @@ TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_4) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0, + "minItems": 1 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + }, + "minLength": 5, + "minimum": 10 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_8) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-00/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft0, drop_non_array_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", diff --git a/test/alterschema/alterschema_lint_draft1_test.cc b/test/alterschema/alterschema_lint_draft1_test.cc index f06da9c66..6beb1c696 100644 --- a/test/alterschema/alterschema_lint_draft1_test.cc +++ b/test/alterschema/alterschema_lint_draft1_test.cc @@ -126,6 +126,122 @@ TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_4) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0, + "minItems": 1 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + }, + "minLength": 5, + "minimum": 10 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_8) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft1, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", diff --git a/test/alterschema/alterschema_lint_draft2_test.cc b/test/alterschema/alterschema_lint_draft2_test.cc index 008da0c3c..c31f2dd73 100644 --- a/test/alterschema/alterschema_lint_draft2_test.cc +++ b/test/alterschema/alterschema_lint_draft2_test.cc @@ -126,6 +126,122 @@ TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_4) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0, + "minItems": 1 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + }, + "minLength": 5, + "minimum": 10 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_8) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft2, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", diff --git a/test/alterschema/alterschema_lint_draft3_test.cc b/test/alterschema/alterschema_lint_draft3_test.cc index bd4d60e44..712f5d6cd 100644 --- a/test/alterschema/alterschema_lint_draft3_test.cc +++ b/test/alterschema/alterschema_lint_draft3_test.cc @@ -126,6 +126,122 @@ TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_4) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0, + "minItems": 1 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + }, + "minLength": 5, + "minimum": 10 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_8) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft3, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", diff --git a/test/alterschema/alterschema_lint_draft4_test.cc b/test/alterschema/alterschema_lint_draft4_test.cc index 5bde19d24..e233dd3d0 100644 --- a/test/alterschema/alterschema_lint_draft4_test.cc +++ b/test/alterschema/alterschema_lint_draft4_test.cc @@ -126,6 +126,122 @@ TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_4) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0, + "minItems": 1 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + }, + "minLength": 5, + "minimum": 10 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_8) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft4, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", diff --git a/test/alterschema/alterschema_lint_draft6_test.cc b/test/alterschema/alterschema_lint_draft6_test.cc index e908b1074..a0bd4d23f 100644 --- a/test/alterschema/alterschema_lint_draft6_test.cc +++ b/test/alterschema/alterschema_lint_draft6_test.cc @@ -212,6 +212,122 @@ TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_4) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0, + "minItems": 1 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + }, + "minLength": 5, + "minimum": 10 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_8) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft6, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", diff --git a/test/alterschema/alterschema_lint_draft7_test.cc b/test/alterschema/alterschema_lint_draft7_test.cc index 985ab3804..58a60c5a0 100644 --- a/test/alterschema/alterschema_lint_draft7_test.cc +++ b/test/alterschema/alterschema_lint_draft7_test.cc @@ -212,6 +212,122 @@ TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_4) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ 1, "foo" ], + "minLength": 2 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0, + "minItems": 1 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ 1, "foo" ], + "minLength": 2, + "minimum": 0 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + }, + "minLength": 5, + "minimum": 10 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ { "name": "alice" }, { "age": 25 } ], + "properties": { + "name": { "type": "string" }, + "age": { "type": "number" } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ "small", "medium", "large" ], + "title": "Size Options", + "minLength": 3 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_8) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], + "minimum": 10, + "minLength": 2, + "minItems": 1, + "minProperties": 1, + "maxLength": 100, + "maxItems": 10, + "maxProperties": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft7, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", From 7b39defa0af8a14e41f258b5033559470f5ea934 Mon Sep 17 00:00:00 2001 From: karan-palan Date: Mon, 18 Aug 2025 09:35:33 +0530 Subject: [PATCH 06/13] chore: rename rule Signed-off-by: karan-palan --- src/extension/alterschema/CMakeLists.txt | 2 +- src/extension/alterschema/alterschema.cc | 2 +- ... non_applicable_enum_validation_keywords.h} | 3 --- .../alterschema_lint_2019_09_test.cc | 16 ++++++++-------- .../alterschema_lint_2020_12_test.cc | 18 +++++++++--------- .../alterschema_lint_draft0_test.cc | 16 ++++++++-------- .../alterschema_lint_draft1_test.cc | 16 ++++++++-------- .../alterschema_lint_draft2_test.cc | 16 ++++++++-------- .../alterschema_lint_draft3_test.cc | 16 ++++++++-------- .../alterschema_lint_draft4_test.cc | 16 ++++++++-------- .../alterschema_lint_draft6_test.cc | 16 ++++++++-------- .../alterschema_lint_draft7_test.cc | 16 ++++++++-------- 12 files changed, 75 insertions(+), 78 deletions(-) rename src/extension/alterschema/linter/{enum_validation_keywords_default.h => non_applicable_enum_validation_keywords.h} (93%) diff --git a/src/extension/alterschema/CMakeLists.txt b/src/extension/alterschema/CMakeLists.txt index 183909eac..142639954 100644 --- a/src/extension/alterschema/CMakeLists.txt +++ b/src/extension/alterschema/CMakeLists.txt @@ -67,7 +67,7 @@ sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME alterschema linter/property_names_default.h linter/draft_ref_siblings.h linter/definitions_to_defs.h - linter/enum_validation_keywords_default.h) + linter/non_applicable_enum_validation_keywords.h) if(SOURCEMETA_CORE_INSTALL) sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME alterschema) diff --git a/src/extension/alterschema/alterschema.cc b/src/extension/alterschema/alterschema.cc index 170d5c80b..5d398834a 100644 --- a/src/extension/alterschema/alterschema.cc +++ b/src/extension/alterschema/alterschema.cc @@ -55,7 +55,6 @@ contains_any(const Vocabularies &container, #include "linter/else_empty.h" #include "linter/else_without_if.h" #include "linter/enum_to_const.h" -#include "linter/enum_validation_keywords_default.h" #include "linter/enum_with_type.h" #include "linter/equal_numeric_bounds_to_const.h" #include "linter/equal_numeric_bounds_to_enum.h" @@ -70,6 +69,7 @@ contains_any(const Vocabularies &container, #include "linter/minimum_real_for_integer.h" #include "linter/modern_official_dialect_with_empty_fragment.h" #include "linter/multiple_of_default.h" +#include "linter/non_applicable_enum_validation_keywords.h" #include "linter/non_applicable_type_specific_keywords.h" #include "linter/pattern_properties_default.h" #include "linter/properties_default.h" diff --git a/src/extension/alterschema/linter/enum_validation_keywords_default.h b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h similarity index 93% rename from src/extension/alterschema/linter/enum_validation_keywords_default.h rename to src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h index 1de9fd2c8..57c29b20b 100644 --- a/src/extension/alterschema/linter/enum_validation_keywords_default.h +++ b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h @@ -51,13 +51,10 @@ class EnumValidationKeywordsDefault final : public SchemaTransformRule { continue; } - // If keyword applies to any type, we can't determine type applicability if (metadata.instances.empty()) { continue; } - // If none of the types that the keyword applies to match the enum types, - // then this keyword is redundant and can be removed if (std::ranges::none_of(metadata.instances.cbegin(), metadata.instances.cend(), [&enum_types](const auto keyword_type) { diff --git a/test/alterschema/alterschema_lint_2019_09_test.cc b/test/alterschema/alterschema_lint_2019_09_test.cc index 07557f86a..74923e928 100644 --- a/test/alterschema/alterschema_lint_2019_09_test.cc +++ b/test/alterschema/alterschema_lint_2019_09_test.cc @@ -159,7 +159,7 @@ TEST(AlterSchema_lint_2019_09, enum_with_type_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_1) { +TEST(AlterSchema_lint_2019_09, non_applicable_enum_validation_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "enum": [ "foo", "bar" ], @@ -176,7 +176,7 @@ TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_2) { +TEST(AlterSchema_lint_2019_09, non_applicable_enum_validation_keywords_2) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "enum": [ 1, 2, 3 ], @@ -194,7 +194,7 @@ TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_2) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_3) { +TEST(AlterSchema_lint_2019_09, non_applicable_enum_validation_keywords_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "enum": [ { "a": 1 }, { "b": 2 } ], @@ -212,7 +212,7 @@ TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_4) { +TEST(AlterSchema_lint_2019_09, non_applicable_enum_validation_keywords_4) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "enum": [ 1, "foo" ], @@ -230,7 +230,7 @@ TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_5) { +TEST(AlterSchema_lint_2019_09, non_applicable_enum_validation_keywords_5) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "enum": [ 1, "foo" ], @@ -251,7 +251,7 @@ TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_5) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_6) { +TEST(AlterSchema_lint_2019_09, non_applicable_enum_validation_keywords_6) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "enum": [ { "name": "alice" }, { "age": 25 } ], @@ -277,7 +277,7 @@ TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_6) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_7) { +TEST(AlterSchema_lint_2019_09, non_applicable_enum_validation_keywords_7) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "enum": [ "small", "medium", "large" ], @@ -298,7 +298,7 @@ TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_7) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2019_09, enum_validation_keywords_default_8) { +TEST(AlterSchema_lint_2019_09, non_applicable_enum_validation_keywords_8) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], diff --git a/test/alterschema/alterschema_lint_2020_12_test.cc b/test/alterschema/alterschema_lint_2020_12_test.cc index d3e43cf58..ee1007384 100644 --- a/test/alterschema/alterschema_lint_2020_12_test.cc +++ b/test/alterschema/alterschema_lint_2020_12_test.cc @@ -2815,7 +2815,7 @@ TEST(AlterSchema_lint_2020_12, non_applicable_type_specific_keywords_3) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_1) { +TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "enum": [ 1, 2, 3 ], @@ -2833,7 +2833,7 @@ TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_2) { +TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_2) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "enum": [ "one", "two" ], @@ -2852,7 +2852,7 @@ TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_2) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_3) { +TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "enum": [ true, false ], @@ -2872,7 +2872,7 @@ TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_4) { +TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_4) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "enum": [ 1, "foo" ], @@ -2890,7 +2890,7 @@ TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_5) { +TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_5) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "enum": [ 1, "foo" ], @@ -2911,7 +2911,7 @@ TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_5) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_6) { +TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_6) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "enum": [ { "name": "alice" }, { "age": 25 } ], @@ -2937,7 +2937,7 @@ TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_6) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_7) { +TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_7) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "enum": [ "small", "medium", "large" ], @@ -2958,7 +2958,7 @@ TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_7) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_8) { +TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_8) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], @@ -2988,7 +2988,7 @@ TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_8) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_2020_12, enum_validation_keywords_default_9) { +TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_9) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "enum": [ 1, 2, 3 ], diff --git a/test/alterschema/alterschema_lint_draft0_test.cc b/test/alterschema/alterschema_lint_draft0_test.cc index 315628e5d..2d0282a60 100644 --- a/test/alterschema/alterschema_lint_draft0_test.cc +++ b/test/alterschema/alterschema_lint_draft0_test.cc @@ -20,7 +20,7 @@ TEST(AlterSchema_lint_draft0, single_type_array_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_1) { +TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", "enum": [ "foo", "bar" ], @@ -37,7 +37,7 @@ TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_2) { +TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_2) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", "enum": [ 1, 2, 3 ], @@ -55,7 +55,7 @@ TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_2) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_3) { +TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", "enum": [ { "a": 1 }, { "b": 2 } ], @@ -73,7 +73,7 @@ TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_4) { +TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_4) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", "enum": [ 1, "foo" ], @@ -91,7 +91,7 @@ TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_5) { +TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_5) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", "enum": [ 1, "foo" ], @@ -112,7 +112,7 @@ TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_5) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_6) { +TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_6) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", "enum": [ { "name": "alice" }, { "age": 25 } ], @@ -138,7 +138,7 @@ TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_6) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_7) { +TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_7) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", "enum": [ "small", "medium", "large" ], @@ -159,7 +159,7 @@ TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_7) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft0, enum_validation_keywords_default_8) { +TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_8) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], diff --git a/test/alterschema/alterschema_lint_draft1_test.cc b/test/alterschema/alterschema_lint_draft1_test.cc index 6beb1c696..29168d8d1 100644 --- a/test/alterschema/alterschema_lint_draft1_test.cc +++ b/test/alterschema/alterschema_lint_draft1_test.cc @@ -73,7 +73,7 @@ TEST(AlterSchema_lint_draft1, enum_with_type_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_1) { +TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", "enum": [ "foo", "bar" ], @@ -90,7 +90,7 @@ TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_2) { +TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_2) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", "enum": [ 1, 2, 3 ], @@ -108,7 +108,7 @@ TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_2) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_3) { +TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", "enum": [ { "a": 1 }, { "b": 2 } ], @@ -126,7 +126,7 @@ TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_4) { +TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_4) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", "enum": [ 1, "foo" ], @@ -144,7 +144,7 @@ TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_5) { +TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_5) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", "enum": [ 1, "foo" ], @@ -165,7 +165,7 @@ TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_5) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_6) { +TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_6) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", "enum": [ { "name": "alice" }, { "age": 25 } ], @@ -191,7 +191,7 @@ TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_6) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_7) { +TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_7) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", "enum": [ "small", "medium", "large" ], @@ -212,7 +212,7 @@ TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_7) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft1, enum_validation_keywords_default_8) { +TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_8) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], diff --git a/test/alterschema/alterschema_lint_draft2_test.cc b/test/alterschema/alterschema_lint_draft2_test.cc index c31f2dd73..ba0a18cd1 100644 --- a/test/alterschema/alterschema_lint_draft2_test.cc +++ b/test/alterschema/alterschema_lint_draft2_test.cc @@ -73,7 +73,7 @@ TEST(AlterSchema_lint_draft2, enum_with_type_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_1) { +TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", "enum": [ "foo", "bar" ], @@ -90,7 +90,7 @@ TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_2) { +TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_2) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", "enum": [ 1, 2, 3 ], @@ -108,7 +108,7 @@ TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_2) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_3) { +TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", "enum": [ { "a": 1 }, { "b": 2 } ], @@ -126,7 +126,7 @@ TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_4) { +TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_4) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", "enum": [ 1, "foo" ], @@ -144,7 +144,7 @@ TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_5) { +TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_5) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", "enum": [ 1, "foo" ], @@ -165,7 +165,7 @@ TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_5) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_6) { +TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_6) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", "enum": [ { "name": "alice" }, { "age": 25 } ], @@ -191,7 +191,7 @@ TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_6) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_7) { +TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_7) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", "enum": [ "small", "medium", "large" ], @@ -212,7 +212,7 @@ TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_7) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft2, enum_validation_keywords_default_8) { +TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_8) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], diff --git a/test/alterschema/alterschema_lint_draft3_test.cc b/test/alterschema/alterschema_lint_draft3_test.cc index 712f5d6cd..c8263daae 100644 --- a/test/alterschema/alterschema_lint_draft3_test.cc +++ b/test/alterschema/alterschema_lint_draft3_test.cc @@ -73,7 +73,7 @@ TEST(AlterSchema_lint_draft3, enum_with_type_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_1) { +TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", "enum": [ "foo", "bar" ], @@ -90,7 +90,7 @@ TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_2) { +TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_2) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", "enum": [ 1, 2, 3 ], @@ -108,7 +108,7 @@ TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_2) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_3) { +TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", "enum": [ { "a": 1 }, { "b": 2 } ], @@ -126,7 +126,7 @@ TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_4) { +TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_4) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", "enum": [ 1, "foo" ], @@ -144,7 +144,7 @@ TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_5) { +TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_5) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", "enum": [ 1, "foo" ], @@ -165,7 +165,7 @@ TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_5) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_6) { +TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_6) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", "enum": [ { "name": "alice" }, { "age": 25 } ], @@ -191,7 +191,7 @@ TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_6) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_7) { +TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_7) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", "enum": [ "small", "medium", "large" ], @@ -212,7 +212,7 @@ TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_7) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft3, enum_validation_keywords_default_8) { +TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_8) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], diff --git a/test/alterschema/alterschema_lint_draft4_test.cc b/test/alterschema/alterschema_lint_draft4_test.cc index e233dd3d0..3be6261c4 100644 --- a/test/alterschema/alterschema_lint_draft4_test.cc +++ b/test/alterschema/alterschema_lint_draft4_test.cc @@ -73,7 +73,7 @@ TEST(AlterSchema_lint_draft4, enum_with_type_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_1) { +TEST(AlterSchema_lint_draft4, non_applicable_enum_validation_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "enum": [ "foo", "bar" ], @@ -90,7 +90,7 @@ TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_2) { +TEST(AlterSchema_lint_draft4, non_applicable_enum_validation_keywords_2) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "enum": [ 1, 2, 3 ], @@ -108,7 +108,7 @@ TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_2) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_3) { +TEST(AlterSchema_lint_draft4, non_applicable_enum_validation_keywords_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "enum": [ { "a": 1 }, { "b": 2 } ], @@ -126,7 +126,7 @@ TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_4) { +TEST(AlterSchema_lint_draft4, non_applicable_enum_validation_keywords_4) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "enum": [ 1, "foo" ], @@ -144,7 +144,7 @@ TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_5) { +TEST(AlterSchema_lint_draft4, non_applicable_enum_validation_keywords_5) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "enum": [ 1, "foo" ], @@ -165,7 +165,7 @@ TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_5) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_6) { +TEST(AlterSchema_lint_draft4, non_applicable_enum_validation_keywords_6) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "enum": [ { "name": "alice" }, { "age": 25 } ], @@ -191,7 +191,7 @@ TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_6) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_7) { +TEST(AlterSchema_lint_draft4, non_applicable_enum_validation_keywords_7) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "enum": [ "small", "medium", "large" ], @@ -212,7 +212,7 @@ TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_7) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft4, enum_validation_keywords_default_8) { +TEST(AlterSchema_lint_draft4, non_applicable_enum_validation_keywords_8) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], diff --git a/test/alterschema/alterschema_lint_draft6_test.cc b/test/alterschema/alterschema_lint_draft6_test.cc index a0bd4d23f..8f23f82a5 100644 --- a/test/alterschema/alterschema_lint_draft6_test.cc +++ b/test/alterschema/alterschema_lint_draft6_test.cc @@ -159,7 +159,7 @@ TEST(AlterSchema_lint_draft6, enum_with_type_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_1) { +TEST(AlterSchema_lint_draft6, non_applicable_enum_validation_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "enum": [ "foo", "bar" ], @@ -176,7 +176,7 @@ TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_2) { +TEST(AlterSchema_lint_draft6, non_applicable_enum_validation_keywords_2) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "enum": [ 1, 2, 3 ], @@ -194,7 +194,7 @@ TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_2) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_3) { +TEST(AlterSchema_lint_draft6, non_applicable_enum_validation_keywords_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "enum": [ { "a": 1 }, { "b": 2 } ], @@ -212,7 +212,7 @@ TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_4) { +TEST(AlterSchema_lint_draft6, non_applicable_enum_validation_keywords_4) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "enum": [ 1, "foo" ], @@ -230,7 +230,7 @@ TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_5) { +TEST(AlterSchema_lint_draft6, non_applicable_enum_validation_keywords_5) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "enum": [ 1, "foo" ], @@ -251,7 +251,7 @@ TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_5) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_6) { +TEST(AlterSchema_lint_draft6, non_applicable_enum_validation_keywords_6) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "enum": [ { "name": "alice" }, { "age": 25 } ], @@ -277,7 +277,7 @@ TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_6) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_7) { +TEST(AlterSchema_lint_draft6, non_applicable_enum_validation_keywords_7) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "enum": [ "small", "medium", "large" ], @@ -298,7 +298,7 @@ TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_7) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft6, enum_validation_keywords_default_8) { +TEST(AlterSchema_lint_draft6, non_applicable_enum_validation_keywords_8) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], diff --git a/test/alterschema/alterschema_lint_draft7_test.cc b/test/alterschema/alterschema_lint_draft7_test.cc index 58a60c5a0..b5fa13541 100644 --- a/test/alterschema/alterschema_lint_draft7_test.cc +++ b/test/alterschema/alterschema_lint_draft7_test.cc @@ -159,7 +159,7 @@ TEST(AlterSchema_lint_draft7, enum_with_type_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_1) { +TEST(AlterSchema_lint_draft7, non_applicable_enum_validation_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "enum": [ "foo", "bar" ], @@ -176,7 +176,7 @@ TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_2) { +TEST(AlterSchema_lint_draft7, non_applicable_enum_validation_keywords_2) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "enum": [ 1, 2, 3 ], @@ -194,7 +194,7 @@ TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_2) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_3) { +TEST(AlterSchema_lint_draft7, non_applicable_enum_validation_keywords_3) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "enum": [ { "a": 1 }, { "b": 2 } ], @@ -212,7 +212,7 @@ TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_3) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_4) { +TEST(AlterSchema_lint_draft7, non_applicable_enum_validation_keywords_4) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "enum": [ 1, "foo" ], @@ -230,7 +230,7 @@ TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_4) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_5) { +TEST(AlterSchema_lint_draft7, non_applicable_enum_validation_keywords_5) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "enum": [ 1, "foo" ], @@ -251,7 +251,7 @@ TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_5) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_6) { +TEST(AlterSchema_lint_draft7, non_applicable_enum_validation_keywords_6) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "enum": [ { "name": "alice" }, { "age": 25 } ], @@ -277,7 +277,7 @@ TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_6) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_7) { +TEST(AlterSchema_lint_draft7, non_applicable_enum_validation_keywords_7) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "enum": [ "small", "medium", "large" ], @@ -298,7 +298,7 @@ TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_7) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft7, enum_validation_keywords_default_8) { +TEST(AlterSchema_lint_draft7, non_applicable_enum_validation_keywords_8) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], From 98c44c13ae2d524b9cf5d3808ef1dd9bcd6600ff Mon Sep 17 00:00:00 2001 From: karan-palan Date: Mon, 18 Aug 2025 10:00:24 +0530 Subject: [PATCH 07/13] chore: remove draft0 and update tests with relevant keywords Signed-off-by: karan-palan --- .../non_applicable_enum_validation_keywords.h | 9 +- .../alterschema_lint_draft0_test.cc | 169 ------------------ .../alterschema_lint_draft1_test.cc | 29 ++- .../alterschema_lint_draft2_test.cc | 29 ++- .../alterschema_lint_draft3_test.cc | 29 ++- 5 files changed, 79 insertions(+), 186 deletions(-) diff --git a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h index 57c29b20b..a29284f5e 100644 --- a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h +++ b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h @@ -3,9 +3,10 @@ class EnumValidationKeywordsDefault final : public SchemaTransformRule { EnumValidationKeywordsDefault() : SchemaTransformRule{ "enum_validation_keywords_default", - "Setting validation keywords alongside `enum` is considered an " + "Setting validation keywords that do not apply to any item in " + "`enum` is considered an " "anti-pattern, as the enumeration choices already imply their " - "respective constraints"} {}; + "respective types"} {}; [[nodiscard]] auto condition(const sourcemeta::core::JSON &schema, @@ -26,9 +27,7 @@ class EnumValidationKeywordsDefault final : public SchemaTransformRule { "http://json-schema.org/draft-02/schema#", "http://json-schema.org/draft-02/hyper-schema#", "http://json-schema.org/draft-01/schema#", - "http://json-schema.org/draft-01/hyper-schema#", - "http://json-schema.org/draft-00/schema#", - "http://json-schema.org/draft-00/hyper-schema#"}) || + "http://json-schema.org/draft-01/hyper-schema#"}) || !schema.is_object() || !schema.defines("enum") || !schema.at("enum").is_array() || schema.defines("$ref")) { return false; diff --git a/test/alterschema/alterschema_lint_draft0_test.cc b/test/alterschema/alterschema_lint_draft0_test.cc index 2d0282a60..edd6d6bf6 100644 --- a/test/alterschema/alterschema_lint_draft0_test.cc +++ b/test/alterschema/alterschema_lint_draft0_test.cc @@ -20,175 +20,6 @@ TEST(AlterSchema_lint_draft0, single_type_array_1) { EXPECT_EQ(document, expected); } -TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_1) { - sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ "foo", "bar" ], - "minimum": 0 - })JSON"); - - LINT_AND_FIX_FOR_READABILITY(document); - - const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ "foo", "bar" ] - })JSON"); - - EXPECT_EQ(document, expected); -} - -TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_2) { - sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ 1, 2, 3 ], - "minLength": 0, - "maxLength": 5 - })JSON"); - - LINT_AND_FIX_FOR_READABILITY(document); - - const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ 1, 2, 3 ] - })JSON"); - - EXPECT_EQ(document, expected); -} - -TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_3) { - sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ { "a": 1 }, { "b": 2 } ], - "minLength": 3, - "minimum": 0 - })JSON"); - - LINT_AND_FIX_FOR_READABILITY(document); - - const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ { "a": 1 }, { "b": 2 } ] - })JSON"); - - EXPECT_EQ(document, expected); -} - -TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_4) { - sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ 1, "foo" ], - "minLength": 2 - })JSON"); - - LINT_AND_FIX_FOR_READABILITY(document); - - const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ 1, "foo" ], - "minLength": 2 - })JSON"); - - EXPECT_EQ(document, expected); -} - -TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_5) { - sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ 1, "foo" ], - "minLength": 2, - "minimum": 0, - "minItems": 1 - })JSON"); - - LINT_AND_FIX_FOR_READABILITY(document); - - const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ 1, "foo" ], - "minLength": 2, - "minimum": 0 - })JSON"); - - EXPECT_EQ(document, expected); -} - -TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_6) { - sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ { "name": "alice" }, { "age": 25 } ], - "properties": { - "name": { "type": "string" }, - "age": { "type": "number" } - }, - "minLength": 5, - "minimum": 10 - })JSON"); - - LINT_AND_FIX_FOR_READABILITY(document); - - const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ { "name": "alice" }, { "age": 25 } ], - "properties": { - "name": { "type": "string" }, - "age": { "type": "number" } - } - })JSON"); - - EXPECT_EQ(document, expected); -} - -TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_7) { - sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ "small", "medium", "large" ], - "title": "Size Options", - "minLength": 3, - "minItems": 2 - })JSON"); - - LINT_AND_FIX_FOR_READABILITY(document); - - const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ "small", "medium", "large" ], - "title": "Size Options", - "minLength": 3 - })JSON"); - - EXPECT_EQ(document, expected); -} - -TEST(AlterSchema_lint_draft0, non_applicable_enum_validation_keywords_8) { - sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], - "minimum": 10, - "minLength": 2, - "minItems": 1, - "minProperties": 1, - "maxLength": 100, - "maxItems": 10, - "maxProperties": 5 - })JSON"); - - LINT_AND_FIX_FOR_READABILITY(document); - - const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ - "$schema": "http://json-schema.org/draft-00/schema#", - "enum": [ 42, "hello", true, null, { "key": "value" }, [1, 2, 3] ], - "minimum": 10, - "minLength": 2, - "minItems": 1, - "minProperties": 1, - "maxLength": 100, - "maxItems": 10, - "maxProperties": 5 - })JSON"); - - EXPECT_EQ(document, expected); -} - TEST(AlterSchema_lint_draft0, drop_non_array_keywords_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-00/schema#", diff --git a/test/alterschema/alterschema_lint_draft1_test.cc b/test/alterschema/alterschema_lint_draft1_test.cc index 29168d8d1..f0c18e4f6 100644 --- a/test/alterschema/alterschema_lint_draft1_test.cc +++ b/test/alterschema/alterschema_lint_draft1_test.cc @@ -219,10 +219,10 @@ TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_8) { "minimum": 10, "minLength": 2, "minItems": 1, - "minProperties": 1, + "x-foo-bar": 1, "maxLength": 100, "maxItems": 10, - "maxProperties": 5 + "x-baz-qux": 5 })JSON"); LINT_AND_FIX_FOR_READABILITY(document); @@ -233,10 +233,31 @@ TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_8) { "minimum": 10, "minLength": 2, "minItems": 1, - "minProperties": 1, + "x-foo-bar": 1, "maxLength": 100, "maxItems": 10, - "maxProperties": 5 + "x-baz-qux": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft1, + non_applicable_enum_validation_keywords_unknown_keyword) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ "foo", "bar" ], + "x-unknown-keyword": "value", + "x-custom-prop": 42 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "enum": [ "foo", "bar" ], + "x-unknown-keyword": "value", + "x-custom-prop": 42 })JSON"); EXPECT_EQ(document, expected); diff --git a/test/alterschema/alterschema_lint_draft2_test.cc b/test/alterschema/alterschema_lint_draft2_test.cc index ba0a18cd1..f4e07399e 100644 --- a/test/alterschema/alterschema_lint_draft2_test.cc +++ b/test/alterschema/alterschema_lint_draft2_test.cc @@ -219,10 +219,10 @@ TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_8) { "minimum": 10, "minLength": 2, "minItems": 1, - "minProperties": 1, + "x-foo-bar": 1, "maxLength": 100, "maxItems": 10, - "maxProperties": 5 + "x-baz-qux": 5 })JSON"); LINT_AND_FIX_FOR_READABILITY(document); @@ -233,10 +233,31 @@ TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_8) { "minimum": 10, "minLength": 2, "minItems": 1, - "minProperties": 1, + "x-foo-bar": 1, "maxLength": 100, "maxItems": 10, - "maxProperties": 5 + "x-baz-qux": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft2, + non_applicable_enum_validation_keywords_unknown_keyword) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ "foo", "bar" ], + "x-unknown-keyword": "value", + "x-custom-prop": 42 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "enum": [ "foo", "bar" ], + "x-unknown-keyword": "value", + "x-custom-prop": 42 })JSON"); EXPECT_EQ(document, expected); diff --git a/test/alterschema/alterschema_lint_draft3_test.cc b/test/alterschema/alterschema_lint_draft3_test.cc index c8263daae..cdd96bb79 100644 --- a/test/alterschema/alterschema_lint_draft3_test.cc +++ b/test/alterschema/alterschema_lint_draft3_test.cc @@ -219,10 +219,10 @@ TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_8) { "minimum": 10, "minLength": 2, "minItems": 1, - "minProperties": 1, + "x-foo-bar": 1, "maxLength": 100, "maxItems": 10, - "maxProperties": 5 + "x-baz-qux": 5 })JSON"); LINT_AND_FIX_FOR_READABILITY(document); @@ -233,10 +233,31 @@ TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_8) { "minimum": 10, "minLength": 2, "minItems": 1, - "minProperties": 1, + "x-foo-bar": 1, "maxLength": 100, "maxItems": 10, - "maxProperties": 5 + "x-baz-qux": 5 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_draft3, + non_applicable_enum_validation_keywords_unknown_keyword) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ "foo", "bar" ], + "x-unknown-keyword": "value", + "x-custom-prop": 42 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "enum": [ "foo", "bar" ], + "x-unknown-keyword": "value", + "x-custom-prop": 42 })JSON"); EXPECT_EQ(document, expected); From 85b1205d700c0f94a65eeb9489bd6c6a81e281f6 Mon Sep 17 00:00:00 2001 From: karan-palan Date: Mon, 18 Aug 2025 10:45:02 +0530 Subject: [PATCH 08/13] fix: remove ref and add tests for that Signed-off-by: karan-palan --- .../non_applicable_enum_validation_keywords.h | 2 +- .../alterschema_lint_2020_12_test.cc | 58 +++++++++++++++++++ 2 files changed, 59 insertions(+), 1 deletion(-) diff --git a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h index a29284f5e..bd62482c7 100644 --- a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h +++ b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h @@ -29,7 +29,7 @@ class EnumValidationKeywordsDefault final : public SchemaTransformRule { "http://json-schema.org/draft-01/schema#", "http://json-schema.org/draft-01/hyper-schema#"}) || !schema.is_object() || !schema.defines("enum") || - !schema.at("enum").is_array() || schema.defines("$ref")) { + !schema.at("enum").is_array()) { return false; } diff --git a/test/alterschema/alterschema_lint_2020_12_test.cc b/test/alterschema/alterschema_lint_2020_12_test.cc index ee1007384..dab5cd2f6 100644 --- a/test/alterschema/alterschema_lint_2020_12_test.cc +++ b/test/alterschema/alterschema_lint_2020_12_test.cc @@ -3006,3 +3006,61 @@ TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_9) { EXPECT_EQ(document, expected); } + +TEST(AlterSchema_lint_2020_12, + non_applicable_enum_validation_keywords_with_ref) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$ref": "#/$defs/myType", + "enum": [ "foo", "bar" ], + "minimum": 10, + "maxItems": 5, + "$defs": { + "myType": { + "type": "string" + } + } + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$ref": "#/$defs/myType", + "enum": [ "foo", "bar" ], + "$defs": { + "myType": { + "type": "string" + } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, + non_applicable_enum_validation_keywords_universal_keywords) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ "foo", "bar" ], + "title": "My enum", + "description": "A test enum", + "default": "foo", + "examples": [ "foo" ], + "minimum": 10, + "maxItems": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "enum": [ "foo", "bar" ], + "title": "My enum", + "description": "A test enum", + "default": "foo", + "examples": [ "foo" ] + })JSON"); + + EXPECT_EQ(document, expected); +} From fc8d8c9e35e387023b96690bec861d213b8f5e9d Mon Sep 17 00:00:00 2001 From: karan-palan Date: Fri, 22 Aug 2025 11:19:57 +0530 Subject: [PATCH 09/13] chore: update classname to match filename Signed-off-by: karan-palan --- src/extension/alterschema/alterschema.cc | 2 +- .../linter/non_applicable_enum_validation_keywords.h | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/extension/alterschema/alterschema.cc b/src/extension/alterschema/alterschema.cc index 5d398834a..023c26f23 100644 --- a/src/extension/alterschema/alterschema.cc +++ b/src/extension/alterschema/alterschema.cc @@ -116,7 +116,7 @@ auto add(SchemaTransformer &bundle, const AlterSchemaMode mode) bundle.add(); bundle.add(); bundle.add(); - bundle.add(); + bundle.add(); bundle.add(); bundle.add(); bundle.add(); diff --git a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h index bd62482c7..bd4b6eb5e 100644 --- a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h +++ b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h @@ -1,6 +1,6 @@ -class EnumValidationKeywordsDefault final : public SchemaTransformRule { +class NonApplicableEnumValidationKeywords final : public SchemaTransformRule { public: - EnumValidationKeywordsDefault() + NonApplicableEnumValidationKeywords() : SchemaTransformRule{ "enum_validation_keywords_default", "Setting validation keywords that do not apply to any item in " From 82315c2aad9a34f743b43b59cf6183ff7f61c3d2 Mon Sep 17 00:00:00 2001 From: karan-palan Date: Fri, 22 Aug 2025 16:49:09 +0530 Subject: [PATCH 10/13] feat:print offending keywords Signed-off-by: karan-palan --- .../linter/non_applicable_enum_validation_keywords.h | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h index bd4b6eb5e..51b87f4ae 100644 --- a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h +++ b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h @@ -63,7 +63,15 @@ class NonApplicableEnumValidationKeywords final : public SchemaTransformRule { } } - return !this->blacklist.empty(); + if (this->blacklist.empty()) { + return false; + } + std::ostringstream message; + for (const auto &entry : this->blacklist) { + message << "- " << entry << "\n"; + } + + return message.str(); } auto transform(sourcemeta::core::JSON &schema) const -> void override { From 0ef2c8344382837e059f66a35d666c8cb72558cf Mon Sep 17 00:00:00 2001 From: karan-palan Date: Fri, 22 Aug 2025 17:38:22 +0530 Subject: [PATCH 11/13] feeat: add test with anchor Signed-off-by: karan-palan --- .../alterschema_lint_2019_09_test.cc | 32 +++++++++++++++++ .../alterschema_lint_2020_12_test.cc | 34 +++++++++++++++++++ .../alterschema_lint_draft1_test.cc | 26 ++++++++++++++ .../alterschema_lint_draft2_test.cc | 26 ++++++++++++++ .../alterschema_lint_draft3_test.cc | 26 ++++++++++++++ .../alterschema_lint_draft4_test.cc | 28 +++++++++++++++ .../alterschema_lint_draft6_test.cc | 28 +++++++++++++++ .../alterschema_lint_draft7_test.cc | 30 ++++++++++++++++ 8 files changed, 230 insertions(+) diff --git a/test/alterschema/alterschema_lint_2019_09_test.cc b/test/alterschema/alterschema_lint_2019_09_test.cc index 2dd0f9a01..06b52aadb 100644 --- a/test/alterschema/alterschema_lint_2019_09_test.cc +++ b/test/alterschema/alterschema_lint_2019_09_test.cc @@ -328,6 +328,38 @@ TEST(AlterSchema_lint_2019_09, non_applicable_enum_validation_keywords_8) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_2019_09, non_applicable_enum_validation_keywords_9) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "$id": "https://example.com/schema", + "$anchor": "color-enum", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "$comment": "This schema uses enum with various annotation keywords", + "enum": [ "red", "green", "blue" ], + "minimum": 5, + "minLength": 10, + "minItems": 2, + "minProperties": 1, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "$id": "https://example.com/schema", + "$anchor": "color-enum", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "$comment": "This schema uses enum with various annotation keywords", + "enum": [ "red", "green", "blue" ], + "minLength": 10 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_2019_09, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", diff --git a/test/alterschema/alterschema_lint_2020_12_test.cc b/test/alterschema/alterschema_lint_2020_12_test.cc index f5a261cab..0e0589af6 100644 --- a/test/alterschema/alterschema_lint_2020_12_test.cc +++ b/test/alterschema/alterschema_lint_2020_12_test.cc @@ -3184,6 +3184,40 @@ TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_8) { } TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_9) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://example.com/schema", + "$anchor": "color-enum", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "$comment": "This schema uses enum with various annotation keywords", + "examples": [ "red", "blue" ], + "enum": [ "red", "green", "blue" ], + "minimum": 5, + "minLength": 10, + "minItems": 2, + "minProperties": 1, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$id": "https://example.com/schema", + "$anchor": "color-enum", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "$comment": "This schema uses enum with various annotation keywords", + "examples": [ "red", "blue" ], + "enum": [ "red", "green", "blue" ], + "minLength": 10 + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, non_applicable_enum_validation_keywords_10) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "enum": [ 1, 2, 3 ], diff --git a/test/alterschema/alterschema_lint_draft1_test.cc b/test/alterschema/alterschema_lint_draft1_test.cc index f0c18e4f6..3edf0a975 100644 --- a/test/alterschema/alterschema_lint_draft1_test.cc +++ b/test/alterschema/alterschema_lint_draft1_test.cc @@ -263,6 +263,32 @@ TEST(AlterSchema_lint_draft1, EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft1, non_applicable_enum_validation_keywords_9) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "enum": [ "red", "green", "blue" ], + "minimum": 5, + "minLength": 10, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-01/schema#", + "id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "enum": [ "red", "green", "blue" ], + "minLength": 10 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft1, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-01/schema#", diff --git a/test/alterschema/alterschema_lint_draft2_test.cc b/test/alterschema/alterschema_lint_draft2_test.cc index f4e07399e..86ba8ce4e 100644 --- a/test/alterschema/alterschema_lint_draft2_test.cc +++ b/test/alterschema/alterschema_lint_draft2_test.cc @@ -263,6 +263,32 @@ TEST(AlterSchema_lint_draft2, EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft2, non_applicable_enum_validation_keywords_9) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "enum": [ "red", "green", "blue" ], + "minimum": 5, + "minLength": 10, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-02/schema#", + "id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "enum": [ "red", "green", "blue" ], + "minLength": 10 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft2, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-02/schema#", diff --git a/test/alterschema/alterschema_lint_draft3_test.cc b/test/alterschema/alterschema_lint_draft3_test.cc index cdd96bb79..68aafa667 100644 --- a/test/alterschema/alterschema_lint_draft3_test.cc +++ b/test/alterschema/alterschema_lint_draft3_test.cc @@ -263,6 +263,32 @@ TEST(AlterSchema_lint_draft3, EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft3, non_applicable_enum_validation_keywords_9) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "enum": [ "red", "green", "blue" ], + "minimum": 5, + "minLength": 10, + "minItems": 2 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "enum": [ "red", "green", "blue" ], + "minLength": 10 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft3, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-03/schema#", diff --git a/test/alterschema/alterschema_lint_draft4_test.cc b/test/alterschema/alterschema_lint_draft4_test.cc index 605980cc2..906352c63 100644 --- a/test/alterschema/alterschema_lint_draft4_test.cc +++ b/test/alterschema/alterschema_lint_draft4_test.cc @@ -258,6 +258,34 @@ TEST(AlterSchema_lint_draft4, single_type_array_1) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft4, non_applicable_enum_validation_keywords_9) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "enum": [ "red", "green", "blue" ], + "minimum": 5, + "minLength": 10, + "minItems": 2, + "minProperties": 1, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "enum": [ "red", "green", "blue" ], + "minLength": 10 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft4, additional_properties_default_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", diff --git a/test/alterschema/alterschema_lint_draft6_test.cc b/test/alterschema/alterschema_lint_draft6_test.cc index eef1a0513..5391a56a8 100644 --- a/test/alterschema/alterschema_lint_draft6_test.cc +++ b/test/alterschema/alterschema_lint_draft6_test.cc @@ -328,6 +328,34 @@ TEST(AlterSchema_lint_draft6, non_applicable_enum_validation_keywords_8) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft6, non_applicable_enum_validation_keywords_9) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "enum": [ "red", "green", "blue" ], + "minimum": 5, + "minLength": 10, + "minItems": 2, + "minProperties": 1, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "$id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "enum": [ "red", "green", "blue" ], + "minLength": 10 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft6, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", diff --git a/test/alterschema/alterschema_lint_draft7_test.cc b/test/alterschema/alterschema_lint_draft7_test.cc index 496717fe6..d5f7ae623 100644 --- a/test/alterschema/alterschema_lint_draft7_test.cc +++ b/test/alterschema/alterschema_lint_draft7_test.cc @@ -328,6 +328,36 @@ TEST(AlterSchema_lint_draft7, non_applicable_enum_validation_keywords_8) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft7, non_applicable_enum_validation_keywords_9) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "$comment": "This schema uses enum with various annotation keywords", + "enum": [ "red", "green", "blue" ], + "minimum": 5, + "minLength": 10, + "minItems": 2, + "minProperties": 1, + "maxProperties": 5 + })JSON"); + + LINT_AND_FIX_FOR_READABILITY(document); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "$id": "https://example.com/schema", + "title": "My Enum Schema", + "description": "A schema with enum and annotations", + "$comment": "This schema uses enum with various annotation keywords", + "enum": [ "red", "green", "blue" ], + "minLength": 10 + })JSON"); + + EXPECT_EQ(document, expected); +} + TEST(AlterSchema_lint_draft7, single_type_array_1) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", From c67df4c03e77cb73589fac99abe42a4d5edc0655 Mon Sep 17 00:00:00 2001 From: karan-palan Date: Fri, 22 Aug 2025 22:31:39 +0530 Subject: [PATCH 12/13] chore: fix consistency Signed-off-by: karan-palan --- src/extension/alterschema/CMakeLists.txt | 4 ++-- .../linter/non_applicable_enum_validation_keywords.h | 5 ++--- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/extension/alterschema/CMakeLists.txt b/src/extension/alterschema/CMakeLists.txt index 8543203bb..528bcbe2c 100644 --- a/src/extension/alterschema/CMakeLists.txt +++ b/src/extension/alterschema/CMakeLists.txt @@ -67,10 +67,10 @@ sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME alterschema linter/property_names_default.h linter/draft_ref_siblings.h linter/definitions_to_defs.h + linter/non_applicable_enum_validation_keywords.h # Strict - strict/required_properties_in_properties.h - linter/non_applicable_enum_validation_keywords.h) + strict/required_properties_in_properties.h) if(SOURCEMETA_CORE_INSTALL) sourcemeta_library_install(NAMESPACE sourcemeta PROJECT core NAME alterschema) diff --git a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h index 51b87f4ae..0c4ad51d7 100644 --- a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h +++ b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h @@ -4,9 +4,7 @@ class NonApplicableEnumValidationKeywords final : public SchemaTransformRule { : SchemaTransformRule{ "enum_validation_keywords_default", "Setting validation keywords that do not apply to any item in " - "`enum` is considered an " - "anti-pattern, as the enumeration choices already imply their " - "respective types"} {}; + "`enum` is considered an anti-pattern"} {}; [[nodiscard]] auto condition(const sourcemeta::core::JSON &schema, @@ -66,6 +64,7 @@ class NonApplicableEnumValidationKeywords final : public SchemaTransformRule { if (this->blacklist.empty()) { return false; } + std::ostringstream message; for (const auto &entry : this->blacklist) { message << "- " << entry << "\n"; From 0fbe0ad5d3497595ad7722b910b8e126ae1ae0c3 Mon Sep 17 00:00:00 2001 From: karan-palan Date: Fri, 22 Aug 2025 22:42:46 +0530 Subject: [PATCH 13/13] chore: remove checks that aren't required Signed-off-by: karan-palan --- .../linter/non_applicable_enum_validation_keywords.h | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h index 0c4ad51d7..2ef36b023 100644 --- a/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h +++ b/src/extension/alterschema/linter/non_applicable_enum_validation_keywords.h @@ -43,17 +43,12 @@ class NonApplicableEnumValidationKeywords final : public SchemaTransformRule { this->blacklist.clear(); for (const auto &entry : schema.as_object()) { const auto metadata = walker(entry.first, vocabularies); - if (metadata.type == sourcemeta::core::SchemaKeywordType::Other || - metadata.type == sourcemeta::core::SchemaKeywordType::Reference) { - continue; - } if (metadata.instances.empty()) { continue; } - if (std::ranges::none_of(metadata.instances.cbegin(), - metadata.instances.cend(), + if (std::ranges::none_of(metadata.instances, [&enum_types](const auto keyword_type) { return enum_types.contains(keyword_type); })) {