From 040c9edeb656758716a41b13ac477d6cdccd8334 Mon Sep 17 00:00:00 2001 From: Vaibhav mittal Date: Fri, 13 Mar 2026 11:35:53 +0000 Subject: [PATCH 1/6] feat(linter): make forbid_empty_enum auto-fixable by rewriting to false Signed-off-by: Vaibhav mittal --- src/extension/alterschema/CMakeLists.txt | 1 + src/extension/alterschema/alterschema.cc | 2 + .../alterschema/linter/forbid_empty_enum.h | 36 ++++++++++ .../alterschema_lint_2019_09_test.cc | 68 +++++++++++++++++++ .../alterschema_lint_2020_12_test.cc | 68 +++++++++++++++++++ .../alterschema_lint_draft4_test.cc | 64 +++++++++++++++++ .../alterschema_lint_draft6_test.cc | 68 +++++++++++++++++++ .../alterschema_lint_draft7_test.cc | 68 +++++++++++++++++++ 8 files changed, 375 insertions(+) create mode 100644 src/extension/alterschema/linter/forbid_empty_enum.h diff --git a/src/extension/alterschema/CMakeLists.txt b/src/extension/alterschema/CMakeLists.txt index ee43cbbab..1e7632925 100644 --- a/src/extension/alterschema/CMakeLists.txt +++ b/src/extension/alterschema/CMakeLists.txt @@ -80,6 +80,7 @@ sourcemeta_library(NAMESPACE sourcemeta PROJECT core NAME alterschema linter/duplicate_examples.h linter/enum_to_const.h linter/equal_numeric_bounds_to_const.h + linter/forbid_empty_enum.h linter/items_array_default.h linter/items_schema_default.h linter/multiple_of_default.h diff --git a/src/extension/alterschema/alterschema.cc b/src/extension/alterschema/alterschema.cc index 131b20c7b..ac8095862 100644 --- a/src/extension/alterschema/alterschema.cc +++ b/src/extension/alterschema/alterschema.cc @@ -108,6 +108,7 @@ inline auto APPLIES_TO_POINTERS(std::vector &&keywords) #include "linter/duplicate_examples.h" #include "linter/enum_to_const.h" #include "linter/equal_numeric_bounds_to_const.h" +#include "linter/forbid_empty_enum.h" #include "linter/items_array_default.h" #include "linter/items_schema_default.h" #include "linter/multiple_of_default.h" @@ -222,6 +223,7 @@ auto add(SchemaTransformer &bundle, const AlterSchemaMode mode) -> void { bundle.add(); bundle.add(); bundle.add(); + bundle.add(); bundle.add(); bundle.add(); bundle.add(); diff --git a/src/extension/alterschema/linter/forbid_empty_enum.h b/src/extension/alterschema/linter/forbid_empty_enum.h new file mode 100644 index 000000000..a2ce1ed10 --- /dev/null +++ b/src/extension/alterschema/linter/forbid_empty_enum.h @@ -0,0 +1,36 @@ +class ForbidEmptyEnum final : public SchemaTransformRule { +public: + using mutates = std::true_type; + using reframe_after_transform = std::false_type; + ForbidEmptyEnum() + : SchemaTransformRule{"forbid_empty_enum", + "An empty `enum` validates nothing and is " + "equivalent to `false`"} {}; + + [[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 &, + const sourcemeta::core::SchemaResolver &) const + -> sourcemeta::core::SchemaTransformRule::Result override { + ONLY_CONTINUE_IF(vocabularies.contains_any( + {Vocabularies::Known::JSON_Schema_2020_12_Validation, + Vocabularies::Known::JSON_Schema_2019_09_Validation, + Vocabularies::Known::JSON_Schema_Draft_7, + Vocabularies::Known::JSON_Schema_Draft_6, + Vocabularies::Known::JSON_Schema_Draft_4, + Vocabularies::Known::JSON_Schema_Draft_3, + Vocabularies::Known::JSON_Schema_Draft_2, + Vocabularies::Known::JSON_Schema_Draft_1}) && + schema.is_object() && schema.defines("enum") && + schema.at("enum").is_array() && schema.at("enum").empty()); + return APPLIES_TO_KEYWORDS("enum"); + } + + auto transform(JSON &schema, const Result &) const -> void override { + schema.into(JSON{false}); + } +}; diff --git a/test/alterschema/alterschema_lint_2019_09_test.cc b/test/alterschema/alterschema_lint_2019_09_test.cc index b68b20641..0777dc833 100644 --- a/test/alterschema/alterschema_lint_2019_09_test.cc +++ b/test/alterschema/alterschema_lint_2019_09_test.cc @@ -4494,3 +4494,71 @@ TEST(AlterSchema_lint_2019_09, empty_object_as_true_1) { EXPECT_EQ(document, expected); } + +TEST(AlterSchema_lint_2019_09, forbid_empty_enum_1) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [] + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_FALSE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", + "enum must contain at least one value", false); +} + +TEST(AlterSchema_lint_2019_09, forbid_empty_enum_2) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [1, 2] + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_2019_09, forbid_empty_enum_3) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "type": "string" + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_2019_09, forbid_empty_enum_4) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "enum": [] + } + } + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_FALSE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", + "enum must contain at least one value", false); +} diff --git a/test/alterschema/alterschema_lint_2020_12_test.cc b/test/alterschema/alterschema_lint_2020_12_test.cc index ba496eff7..f70c8545a 100644 --- a/test/alterschema/alterschema_lint_2020_12_test.cc +++ b/test/alterschema/alterschema_lint_2020_12_test.cc @@ -9664,3 +9664,71 @@ TEST(AlterSchema_lint_2020_12, object_oneof_required_not_required_6) { "can be elevated", true); } + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_1) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [] + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_FALSE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", + "enum must contain at least one value", false); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_2) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [1, 2] + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_3) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "type": "string" + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_4) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "enum": [] + } + } + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_FALSE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", + "enum must contain at least one value", false); +} diff --git a/test/alterschema/alterschema_lint_draft4_test.cc b/test/alterschema/alterschema_lint_draft4_test.cc index 6c62d61a6..134f958b3 100644 --- a/test/alterschema/alterschema_lint_draft4_test.cc +++ b/test/alterschema/alterschema_lint_draft4_test.cc @@ -2604,3 +2604,67 @@ TEST(AlterSchema_lint_draft4, EXPECT_EQ(document, expected); } + +TEST(AlterSchema_lint_draft4, forbid_empty_enum_1) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "title": "Example", + "description": "Example schema", + "enum": [] + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_FALSE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", + "enum must contain at least one value", false); +} + +TEST(AlterSchema_lint_draft4, forbid_empty_enum_2) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "title": "Example", + "description": "Example schema", + "enum": [1, 2] + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_draft4, forbid_empty_enum_3) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "title": "Example", + "description": "Example schema", + "type": "string" + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_draft4, forbid_empty_enum_4) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "title": "Example", + "description": "Example schema", + "properties": { + "foo": { + "enum": [] + } + } + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_FALSE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", + "enum must contain at least one value", false); +} diff --git a/test/alterschema/alterschema_lint_draft6_test.cc b/test/alterschema/alterschema_lint_draft6_test.cc index 6193d80bb..a13895961 100644 --- a/test/alterschema/alterschema_lint_draft6_test.cc +++ b/test/alterschema/alterschema_lint_draft6_test.cc @@ -2929,3 +2929,71 @@ TEST(AlterSchema_lint_draft6, empty_object_as_true_1) { EXPECT_EQ(document, expected); } + +TEST(AlterSchema_lint_draft6, forbid_empty_enum_1) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [] + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_FALSE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", + "enum must contain at least one value", false); +} + +TEST(AlterSchema_lint_draft6, forbid_empty_enum_2) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [1, 2] + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_draft6, forbid_empty_enum_3) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "type": "string" + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_draft6, forbid_empty_enum_4) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "enum": [] + } + } + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_FALSE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", + "enum must contain at least one value", false); +} diff --git a/test/alterschema/alterschema_lint_draft7_test.cc b/test/alterschema/alterschema_lint_draft7_test.cc index 14b0734c2..eae69230b 100644 --- a/test/alterschema/alterschema_lint_draft7_test.cc +++ b/test/alterschema/alterschema_lint_draft7_test.cc @@ -3507,3 +3507,71 @@ TEST(AlterSchema_lint_draft7, "illustrate the expected data", false); } + +TEST(AlterSchema_lint_draft7, forbid_empty_enum_1) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [] + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_FALSE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", + "enum must contain at least one value", false); +} + +TEST(AlterSchema_lint_draft7, forbid_empty_enum_2) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [1, 2] + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_draft7, forbid_empty_enum_3) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "type": "string" + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_draft7, forbid_empty_enum_4) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "enum": [] + } + } + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_FALSE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", + "enum must contain at least one value", false); +} From cbadb5c2bff75d96d67df770d9e6a4a91152f12a Mon Sep 17 00:00:00 2001 From: Vaibhav mittal Date: Fri, 13 Mar 2026 11:26:39 +0000 Subject: [PATCH 2/6] test(linter): update forbid_empty_enum tests for 2019-09 and 2020-12 Signed-off-by: Vaibhav mittal --- .../alterschema_lint_2019_09_test.cc | 24 ++- .../alterschema_lint_2020_12_test.cc | 194 +++++++++++++++++- 2 files changed, 209 insertions(+), 9 deletions(-) diff --git a/test/alterschema/alterschema_lint_2019_09_test.cc b/test/alterschema/alterschema_lint_2019_09_test.cc index 0777dc833..5d2eebb8e 100644 --- a/test/alterschema/alterschema_lint_2019_09_test.cc +++ b/test/alterschema/alterschema_lint_2019_09_test.cc @@ -4509,7 +4509,9 @@ TEST(AlterSchema_lint_2019_09, forbid_empty_enum_1) { EXPECT_FALSE(result.first); EXPECT_EQ(traces.size(), 1); EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", - "enum must contain at least one value", false); + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); } TEST(AlterSchema_lint_2019_09, forbid_empty_enum_2) { @@ -4543,7 +4545,7 @@ TEST(AlterSchema_lint_2019_09, forbid_empty_enum_3) { } TEST(AlterSchema_lint_2019_09, forbid_empty_enum_4) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "title": "Example", "description": "Example schema", @@ -4554,11 +4556,23 @@ TEST(AlterSchema_lint_2019_09, forbid_empty_enum_4) { } } })JSON"); + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": false + } + })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); - EXPECT_FALSE(result.first); + EXPECT_TRUE(result.first); EXPECT_EQ(traces.size(), 1); EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "enum must contain at least one value", false); + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); + EXPECT_EQ(document, expected); } diff --git a/test/alterschema/alterschema_lint_2020_12_test.cc b/test/alterschema/alterschema_lint_2020_12_test.cc index f70c8545a..f75d0952b 100644 --- a/test/alterschema/alterschema_lint_2020_12_test.cc +++ b/test/alterschema/alterschema_lint_2020_12_test.cc @@ -9679,7 +9679,9 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_1) { EXPECT_FALSE(result.first); EXPECT_EQ(traces.size(), 1); EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", - "enum must contain at least one value", false); + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); } TEST(AlterSchema_lint_2020_12, forbid_empty_enum_2) { @@ -9713,7 +9715,40 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_3) { } TEST(AlterSchema_lint_2020_12, forbid_empty_enum_4) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "enum": [] + } + } + })JSON"); + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": false + } + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "Example", "description": "Example schema", @@ -9721,6 +9756,155 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_4) { "properties": { "foo": { "enum": [] + }, + "bar": { + "enum": [] + }, + "baz": { + "enum": [1, 2] + } + } + })JSON"); + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": false, + "bar": false, + "baz": { + "enum": [1, 2] + } + } + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 2); + bool has_foo{false}; + bool has_bar{false}; + for (const auto &trace : traces) { + const auto pointer{sourcemeta::core::to_string(std::get<0>(trace))}; + const auto &name{std::get<1>(trace)}; + if (pointer == "/properties/foo" && name == "forbid_empty_enum") { + has_foo = true; + } + if (pointer == "/properties/bar" && name == "forbid_empty_enum") { + has_bar = true; + } + } + EXPECT_TRUE(has_foo); + EXPECT_TRUE(has_bar); + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [[]], + "prefixItems": [ + { + "enum": [] + }, + { + "type": "string" + } + ] + })JSON"); + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [[]], + "prefixItems": [ + false, + { + "type": "string" + } + ] + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "/prefixItems/0", "forbid_empty_enum", + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [[]], + "properties": { + "arr": { + "type": "array", + "items": { + "x-note": "placeholder", + "enum": [] + } + } + } + })JSON"); + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [[]], + "properties": { + "arr": { + "type": "array", + "items": false + } + } + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "/properties/arr/items", "forbid_empty_enum", + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_8) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": {} + })JSON"); + + LINT_WITHOUT_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 0); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_9) { + const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "not": { + "enum": [] + } } } })JSON"); @@ -9729,6 +9913,8 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_4) { EXPECT_FALSE(result.first); EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "enum must contain at least one value", false); + EXPECT_LINT_TRACE(traces, 0, "/properties/foo/not", "forbid_empty_enum", + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); } From b5d92d6eae96dddf11cc79a3006c77532240c17f Mon Sep 17 00:00:00 2001 From: Vaibhav mittal Date: Fri, 13 Mar 2026 11:26:53 +0000 Subject: [PATCH 3/6] test(linter): update forbid_empty_enum tests for draft4, draft6, and draft7 Signed-off-by: Vaibhav mittal --- .../alterschema_lint_draft4_test.cc | 23 ++++++++++++++---- .../alterschema_lint_draft6_test.cc | 24 +++++++++++++++---- .../alterschema_lint_draft7_test.cc | 24 +++++++++++++++---- 3 files changed, 56 insertions(+), 15 deletions(-) diff --git a/test/alterschema/alterschema_lint_draft4_test.cc b/test/alterschema/alterschema_lint_draft4_test.cc index 134f958b3..9273804f0 100644 --- a/test/alterschema/alterschema_lint_draft4_test.cc +++ b/test/alterschema/alterschema_lint_draft4_test.cc @@ -2618,7 +2618,9 @@ TEST(AlterSchema_lint_draft4, forbid_empty_enum_1) { EXPECT_FALSE(result.first); EXPECT_EQ(traces.size(), 1); EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", - "enum must contain at least one value", false); + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); } TEST(AlterSchema_lint_draft4, forbid_empty_enum_2) { @@ -2650,7 +2652,7 @@ TEST(AlterSchema_lint_draft4, forbid_empty_enum_3) { } TEST(AlterSchema_lint_draft4, forbid_empty_enum_4) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "title": "Example", "description": "Example schema", @@ -2660,11 +2662,22 @@ TEST(AlterSchema_lint_draft4, forbid_empty_enum_4) { } } })JSON"); + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "title": "Example", + "description": "Example schema", + "properties": { + "foo": false + } + })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); - EXPECT_FALSE(result.first); + EXPECT_TRUE(result.first); EXPECT_EQ(traces.size(), 1); EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "enum must contain at least one value", false); + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); + EXPECT_EQ(document, expected); } diff --git a/test/alterschema/alterschema_lint_draft6_test.cc b/test/alterschema/alterschema_lint_draft6_test.cc index a13895961..361439693 100644 --- a/test/alterschema/alterschema_lint_draft6_test.cc +++ b/test/alterschema/alterschema_lint_draft6_test.cc @@ -2944,7 +2944,9 @@ TEST(AlterSchema_lint_draft6, forbid_empty_enum_1) { EXPECT_FALSE(result.first); EXPECT_EQ(traces.size(), 1); EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", - "enum must contain at least one value", false); + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); } TEST(AlterSchema_lint_draft6, forbid_empty_enum_2) { @@ -2978,7 +2980,7 @@ TEST(AlterSchema_lint_draft6, forbid_empty_enum_3) { } TEST(AlterSchema_lint_draft6, forbid_empty_enum_4) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "title": "Example", "description": "Example schema", @@ -2989,11 +2991,23 @@ TEST(AlterSchema_lint_draft6, forbid_empty_enum_4) { } } })JSON"); + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": false + } + })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); - EXPECT_FALSE(result.first); + EXPECT_TRUE(result.first); EXPECT_EQ(traces.size(), 1); EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "enum must contain at least one value", false); + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); + EXPECT_EQ(document, expected); } diff --git a/test/alterschema/alterschema_lint_draft7_test.cc b/test/alterschema/alterschema_lint_draft7_test.cc index eae69230b..cbebc8f96 100644 --- a/test/alterschema/alterschema_lint_draft7_test.cc +++ b/test/alterschema/alterschema_lint_draft7_test.cc @@ -3522,7 +3522,9 @@ TEST(AlterSchema_lint_draft7, forbid_empty_enum_1) { EXPECT_FALSE(result.first); EXPECT_EQ(traces.size(), 1); EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", - "enum must contain at least one value", false); + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); } TEST(AlterSchema_lint_draft7, forbid_empty_enum_2) { @@ -3556,7 +3558,7 @@ TEST(AlterSchema_lint_draft7, forbid_empty_enum_3) { } TEST(AlterSchema_lint_draft7, forbid_empty_enum_4) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "title": "Example", "description": "Example schema", @@ -3567,11 +3569,23 @@ TEST(AlterSchema_lint_draft7, forbid_empty_enum_4) { } } })JSON"); + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": false + } + })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); - EXPECT_FALSE(result.first); + EXPECT_TRUE(result.first); EXPECT_EQ(traces.size(), 1); EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "enum must contain at least one value", false); + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); + EXPECT_EQ(document, expected); } From ec6066e3d629839bcefb09711caa7bc25d7d42ce Mon Sep 17 00:00:00 2001 From: Vaibhav mittal Date: Fri, 13 Mar 2026 11:27:10 +0000 Subject: [PATCH 4/6] test(linter): add edge cases and draft3 coverage for forbid_empty_enum Signed-off-by: Vaibhav mittal --- .../alterschema_lint_draft3_test.cc | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/test/alterschema/alterschema_lint_draft3_test.cc b/test/alterschema/alterschema_lint_draft3_test.cc index 69aab7efc..a970bbc7a 100644 --- a/test/alterschema/alterschema_lint_draft3_test.cc +++ b/test/alterschema/alterschema_lint_draft3_test.cc @@ -81,6 +81,37 @@ TEST(AlterSchema_lint_draft3, enum_with_type_4) { EXPECT_EQ(document, expected); } +TEST(AlterSchema_lint_draft3, forbid_empty_enum_1) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "title": "Example", + "description": "Example schema", + "properties": { + "foo": { + "enum": [] + } + } + })JSON"); + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-03/schema#", + "title": "Example", + "description": "Example schema", + "properties": { + "foo": false + } + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + EXPECT_EQ(traces.size(), 1); + EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", + "An empty `enum` validates nothing and is equivalent to " + "`false`", + true); + EXPECT_EQ(document, expected); +} + 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#", From 2c908047700c4a79fb3f91b2b588ab6f69586116 Mon Sep 17 00:00:00 2001 From: Vaibhav mittal Date: Fri, 13 Mar 2026 15:17:06 +0000 Subject: [PATCH 5/6] feat(linter): preserve schema structure in forbid_empty_enum autofix Signed-off-by: Vaibhav mittal --- .../alterschema/linter/forbid_empty_enum.h | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/src/extension/alterschema/linter/forbid_empty_enum.h b/src/extension/alterschema/linter/forbid_empty_enum.h index a2ce1ed10..98713e252 100644 --- a/src/extension/alterschema/linter/forbid_empty_enum.h +++ b/src/extension/alterschema/linter/forbid_empty_enum.h @@ -1,11 +1,11 @@ class ForbidEmptyEnum final : public SchemaTransformRule { public: using mutates = std::true_type; - using reframe_after_transform = std::false_type; + using reframe_after_transform = std::true_type; ForbidEmptyEnum() : SchemaTransformRule{"forbid_empty_enum", "An empty `enum` validates nothing and is " - "equivalent to `false`"} {}; + "equivalent to `not: {}`"} {}; [[nodiscard]] auto condition(const sourcemeta::core::JSON &schema, @@ -21,16 +21,15 @@ class ForbidEmptyEnum final : public SchemaTransformRule { Vocabularies::Known::JSON_Schema_2019_09_Validation, Vocabularies::Known::JSON_Schema_Draft_7, Vocabularies::Known::JSON_Schema_Draft_6, - Vocabularies::Known::JSON_Schema_Draft_4, - Vocabularies::Known::JSON_Schema_Draft_3, - Vocabularies::Known::JSON_Schema_Draft_2, - Vocabularies::Known::JSON_Schema_Draft_1}) && + Vocabularies::Known::JSON_Schema_Draft_4}) && schema.is_object() && schema.defines("enum") && - schema.at("enum").is_array() && schema.at("enum").empty()); + !schema.defines("not") && schema.at("enum").is_array() && + schema.at("enum").empty()); return APPLIES_TO_KEYWORDS("enum"); } auto transform(JSON &schema, const Result &) const -> void override { - schema.into(JSON{false}); + schema.erase("enum"); + schema.assign("not", JSON::make_object()); } }; From b86dd961ffb4a9cde2367c5a851e4e88e08c1fc5 Mon Sep 17 00:00:00 2001 From: Vaibhav mittal Date: Fri, 13 Mar 2026 15:48:12 +0000 Subject: [PATCH 6/6] test(linter): extend forbid_empty_enum coverage across dialects and reference edge cases Signed-off-by: Vaibhav mittal --- .../alterschema_lint_2019_09_test.cc | 204 ++++++++++-- .../alterschema_lint_2020_12_test.cc | 314 ++++++++++++++---- .../alterschema_lint_draft3_test.cc | 9 +- .../alterschema_lint_draft4_test.cc | 61 ++-- .../alterschema_lint_draft6_test.cc | 60 ++-- .../alterschema_lint_draft7_test.cc | 60 ++-- 6 files changed, 560 insertions(+), 148 deletions(-) diff --git a/test/alterschema/alterschema_lint_2019_09_test.cc b/test/alterschema/alterschema_lint_2019_09_test.cc index 5d2eebb8e..bf6f714f4 100644 --- a/test/alterschema/alterschema_lint_2019_09_test.cc +++ b/test/alterschema/alterschema_lint_2019_09_test.cc @@ -4496,7 +4496,7 @@ TEST(AlterSchema_lint_2019_09, empty_object_as_true_1) { } TEST(AlterSchema_lint_2019_09, forbid_empty_enum_1) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "title": "Example", "description": "Example schema", @@ -4504,18 +4504,23 @@ TEST(AlterSchema_lint_2019_09, forbid_empty_enum_1) { "enum": [] })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); - EXPECT_FALSE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "not": true + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_2019_09, forbid_empty_enum_2) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "title": "Example", "description": "Example schema", @@ -4523,14 +4528,23 @@ TEST(AlterSchema_lint_2019_09, forbid_empty_enum_2) { "enum": [1, 2] })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [1, 2] + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_2019_09, forbid_empty_enum_3) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2019-09/schema", "title": "Example", "description": "Example schema", @@ -4538,10 +4552,19 @@ TEST(AlterSchema_lint_2019_09, forbid_empty_enum_3) { "type": "string" })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "type": "string" + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_2019_09, forbid_empty_enum_4) { @@ -4562,17 +4585,158 @@ TEST(AlterSchema_lint_2019_09, forbid_empty_enum_4) { "description": "Example schema", "examples": [{}], "properties": { - "foo": false + "foo": { + "not": true + } } })JSON"); LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2019_09, forbid_empty_enum_5) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "enum": [] + } + }, + "$ref": "#/$defs/A" + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "not": true + } + }, + "$ref": "#/$defs/A" + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2019_09, forbid_empty_enum_6) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "enum": [], + "$defs": { + "inner": { "type": "string" } + } + } + }, + "$ref": "#/$defs/A/$defs/inner" + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "$defs": { + "inner": { "type": "string" } + }, + "not": true + } + }, + "$ref": "#/$defs/A/$defs/inner" + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2019_09, forbid_empty_enum_7) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "$id": "https://example.com/schemas/A", + "enum": [] + } + }, + "$ref": "https://example.com/schemas/A" + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "$id": "https://example.com/schemas/A", + "not": true + } + }, + "$ref": "https://example.com/schemas/A" + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2019_09, forbid_empty_enum_8) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "x-note": "placeholder", + "enum": [] + } + } + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2019-09/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "x-note": "placeholder", + "not": true + } + } + })JSON"); + EXPECT_EQ(document, expected); } diff --git a/test/alterschema/alterschema_lint_2020_12_test.cc b/test/alterschema/alterschema_lint_2020_12_test.cc index f75d0952b..c441b4972 100644 --- a/test/alterschema/alterschema_lint_2020_12_test.cc +++ b/test/alterschema/alterschema_lint_2020_12_test.cc @@ -9666,7 +9666,7 @@ TEST(AlterSchema_lint_2020_12, object_oneof_required_not_required_6) { } TEST(AlterSchema_lint_2020_12, forbid_empty_enum_1) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "Example", "description": "Example schema", @@ -9674,18 +9674,23 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_1) { "enum": [] })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); - EXPECT_FALSE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "not": true + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_2020_12, forbid_empty_enum_2) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "Example", "description": "Example schema", @@ -9693,14 +9698,23 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_2) { "enum": [1, 2] })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [1, 2] + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_2020_12, forbid_empty_enum_3) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "Example", "description": "Example schema", @@ -9708,10 +9722,19 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_3) { "type": "string" })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "type": "string" + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_2020_12, forbid_empty_enum_4) { @@ -9732,18 +9755,15 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_4) { "description": "Example schema", "examples": [{}], "properties": { - "foo": false + "foo": { + "not": true + } } })JSON"); LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); EXPECT_EQ(document, expected); } @@ -9771,8 +9791,12 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_5) { "description": "Example schema", "examples": [{}], "properties": { - "foo": false, - "bar": false, + "foo": { + "not": true + }, + "bar": { + "not": true + }, "baz": { "enum": [1, 2] } @@ -9782,21 +9806,6 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_5) { LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 2); - bool has_foo{false}; - bool has_bar{false}; - for (const auto &trace : traces) { - const auto pointer{sourcemeta::core::to_string(std::get<0>(trace))}; - const auto &name{std::get<1>(trace)}; - if (pointer == "/properties/foo" && name == "forbid_empty_enum") { - has_foo = true; - } - if (pointer == "/properties/bar" && name == "forbid_empty_enum") { - has_bar = true; - } - } - EXPECT_TRUE(has_foo); - EXPECT_TRUE(has_bar); EXPECT_EQ(document, expected); } @@ -9821,7 +9830,9 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_6) { "description": "Example schema", "examples": [[]], "prefixItems": [ - false, + { + "not": true + }, { "type": "string" } @@ -9831,11 +9842,6 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_6) { LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "/prefixItems/0", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); EXPECT_EQ(document, expected); } @@ -9863,7 +9869,10 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_7) { "properties": { "arr": { "type": "array", - "items": false + "items": { + "x-note": "placeholder", + "not": true + } } } })JSON"); @@ -9871,16 +9880,11 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_7) { LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "/properties/arr/items", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_2020_12, forbid_empty_enum_8) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "Example", "description": "Example schema", @@ -9888,14 +9892,23 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_8) { "enum": {} })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": {} + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_2020_12, forbid_empty_enum_9) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "https://json-schema.org/draft/2020-12/schema", "title": "Example", "description": "Example schema", @@ -9909,12 +9922,193 @@ TEST(AlterSchema_lint_2020_12, forbid_empty_enum_9) { } })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); - EXPECT_FALSE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "/properties/foo/not", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "not": { + "not": true + } + } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_10) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "enum": [] + } + }, + "$ref": "#/$defs/A" + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "not": true + } + }, + "$ref": "#/$defs/A" + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_11) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "enum": [], + "$defs": { + "inner": { "type": "string" } + } + } + }, + "$ref": "#/$defs/A/$defs/inner" + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "$defs": { + "inner": { "type": "string" } + }, + "not": true + } + }, + "$ref": "#/$defs/A/$defs/inner" + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_12) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "$id": "https://example.com/schemas/A", + "enum": [] + } + }, + "$ref": "https://example.com/schemas/A" + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "$defs": { + "A": { + "$id": "https://example.com/schemas/A", + "not": true + } + }, + "$ref": "https://example.com/schemas/A" + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_13) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "x-note": "placeholder", + "enum": [] + } + } + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "properties": { + "foo": { + "x-note": "placeholder", + "not": true + } + } + })JSON"); + + EXPECT_EQ(document, expected); +} + +TEST(AlterSchema_lint_2020_12, forbid_empty_enum_14) { + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "not": { "type": "string" }, + "enum": [] + })JSON"); + + LINT_AND_FIX(document, result, traces); + + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "title": "Example", + "description": "Example schema", + "examples": [{}], + "not": { "type": "string" }, + "enum": [] + })JSON"); + + EXPECT_EQ(document, expected); } diff --git a/test/alterschema/alterschema_lint_draft3_test.cc b/test/alterschema/alterschema_lint_draft3_test.cc index a970bbc7a..b608808d7 100644 --- a/test/alterschema/alterschema_lint_draft3_test.cc +++ b/test/alterschema/alterschema_lint_draft3_test.cc @@ -97,18 +97,15 @@ TEST(AlterSchema_lint_draft3, forbid_empty_enum_1) { "title": "Example", "description": "Example schema", "properties": { - "foo": false + "foo": { + "enum": [] + } } })JSON"); LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); EXPECT_EQ(document, expected); } diff --git a/test/alterschema/alterschema_lint_draft4_test.cc b/test/alterschema/alterschema_lint_draft4_test.cc index 9273804f0..038954fb5 100644 --- a/test/alterschema/alterschema_lint_draft4_test.cc +++ b/test/alterschema/alterschema_lint_draft4_test.cc @@ -1812,7 +1812,7 @@ TEST(AlterSchema_lint_draft4, not_false_4) { sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "type": "string", - "not": true + "not": {} })JSON"); LINT_AND_FIX(document, result, traces); @@ -1822,7 +1822,7 @@ TEST(AlterSchema_lint_draft4, not_false_4) { const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "type": "string", - "not": true + "not": {} })JSON"); EXPECT_EQ(document, expected); @@ -2606,49 +2606,69 @@ TEST(AlterSchema_lint_draft4, } TEST(AlterSchema_lint_draft4, forbid_empty_enum_1) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "title": "Example", "description": "Example schema", "enum": [] })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); - EXPECT_FALSE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "title": "Example", + "description": "Example schema", + "not": {} + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_draft4, forbid_empty_enum_2) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "title": "Example", "description": "Example schema", "enum": [1, 2] })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "title": "Example", + "description": "Example schema", + "enum": [1, 2] + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_draft4, forbid_empty_enum_3) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-04/schema#", "title": "Example", "description": "Example schema", "type": "string" })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-04/schema#", + "title": "Example", + "description": "Example schema", + "type": "string" + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_draft4, forbid_empty_enum_4) { @@ -2667,17 +2687,14 @@ TEST(AlterSchema_lint_draft4, forbid_empty_enum_4) { "title": "Example", "description": "Example schema", "properties": { - "foo": false + "foo": { + "not": {} + } } })JSON"); LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); EXPECT_EQ(document, expected); } diff --git a/test/alterschema/alterschema_lint_draft6_test.cc b/test/alterschema/alterschema_lint_draft6_test.cc index 361439693..b66a21057 100644 --- a/test/alterschema/alterschema_lint_draft6_test.cc +++ b/test/alterschema/alterschema_lint_draft6_test.cc @@ -2931,7 +2931,7 @@ TEST(AlterSchema_lint_draft6, empty_object_as_true_1) { } TEST(AlterSchema_lint_draft6, forbid_empty_enum_1) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "title": "Example", "description": "Example schema", @@ -2939,18 +2939,23 @@ TEST(AlterSchema_lint_draft6, forbid_empty_enum_1) { "enum": [] })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); - EXPECT_FALSE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "not": true + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_draft6, forbid_empty_enum_2) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "title": "Example", "description": "Example schema", @@ -2958,14 +2963,23 @@ TEST(AlterSchema_lint_draft6, forbid_empty_enum_2) { "enum": [1, 2] })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [1, 2] + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_draft6, forbid_empty_enum_3) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-06/schema#", "title": "Example", "description": "Example schema", @@ -2973,10 +2987,19 @@ TEST(AlterSchema_lint_draft6, forbid_empty_enum_3) { "type": "string" })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-06/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "type": "string" + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_draft6, forbid_empty_enum_4) { @@ -2997,17 +3020,14 @@ TEST(AlterSchema_lint_draft6, forbid_empty_enum_4) { "description": "Example schema", "examples": [{}], "properties": { - "foo": false + "foo": { + "not": true + } } })JSON"); LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); EXPECT_EQ(document, expected); } diff --git a/test/alterschema/alterschema_lint_draft7_test.cc b/test/alterschema/alterschema_lint_draft7_test.cc index cbebc8f96..fe231ed98 100644 --- a/test/alterschema/alterschema_lint_draft7_test.cc +++ b/test/alterschema/alterschema_lint_draft7_test.cc @@ -3509,7 +3509,7 @@ TEST(AlterSchema_lint_draft7, } TEST(AlterSchema_lint_draft7, forbid_empty_enum_1) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "title": "Example", "description": "Example schema", @@ -3517,18 +3517,23 @@ TEST(AlterSchema_lint_draft7, forbid_empty_enum_1) { "enum": [] })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); - EXPECT_FALSE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); + EXPECT_TRUE(result.first); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "not": true + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_draft7, forbid_empty_enum_2) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "title": "Example", "description": "Example schema", @@ -3536,14 +3541,23 @@ TEST(AlterSchema_lint_draft7, forbid_empty_enum_2) { "enum": [1, 2] })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "enum": [1, 2] + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_draft7, forbid_empty_enum_3) { - const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ + sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({ "$schema": "http://json-schema.org/draft-07/schema#", "title": "Example", "description": "Example schema", @@ -3551,10 +3565,19 @@ TEST(AlterSchema_lint_draft7, forbid_empty_enum_3) { "type": "string" })JSON"); - LINT_WITHOUT_FIX(document, result, traces); + LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 0); + + const sourcemeta::core::JSON expected = sourcemeta::core::parse_json(R"JSON({ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "Example", + "description": "Example schema", + "examples": [1], + "type": "string" + })JSON"); + + EXPECT_EQ(document, expected); } TEST(AlterSchema_lint_draft7, forbid_empty_enum_4) { @@ -3575,17 +3598,14 @@ TEST(AlterSchema_lint_draft7, forbid_empty_enum_4) { "description": "Example schema", "examples": [{}], "properties": { - "foo": false + "foo": { + "not": true + } } })JSON"); LINT_AND_FIX(document, result, traces); EXPECT_TRUE(result.first); - EXPECT_EQ(traces.size(), 1); - EXPECT_LINT_TRACE(traces, 0, "/properties/foo", "forbid_empty_enum", - "An empty `enum` validates nothing and is equivalent to " - "`false`", - true); EXPECT_EQ(document, expected); }