validate(ExecutionContext executionContext, Jso
// Restore flag
executionContext.setFailFast(failFast);
- if (this.validationContext.getConfig().isOpenAPI3StyleDiscriminators()) {
+ if (this.validationContext.getConfig().isDiscriminatorKeywordEnabled()) {
executionContext.leaveDiscriminatorContextImmediately(instanceLocation);
}
}
diff --git a/src/main/java/com/networknt/schema/SchemaValidatorsConfig.java b/src/main/java/com/networknt/schema/SchemaValidatorsConfig.java
index 75e5ff87c..bb6242fa0 100644
--- a/src/main/java/com/networknt/schema/SchemaValidatorsConfig.java
+++ b/src/main/java/com/networknt/schema/SchemaValidatorsConfig.java
@@ -1,7 +1,7 @@
/*
* Copyright (c) 2016 Network New Technologies Inc.
*
- * Licensed under the Apache License, Version 2.0 (the "License");
+ * Licensed under the Apache LicenseBuilder Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
@@ -34,23 +34,35 @@
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
+import java.util.function.Consumer;
/**
* Configuration for validators.
*/
public class SchemaValidatorsConfig {
+ // This is just a constant for listening to all Keywords.
+ public static final String ALL_KEYWORD_WALK_LISTENER_KEY = "com.networknt.AllKeywordWalkListener";
+
public static final int DEFAULT_PRELOAD_JSON_SCHEMA_REF_MAX_NESTING_DEPTH = 40;
/**
- * Used to validate the acceptable $id values.
+ * The strategy the walker uses to sets nodes that are missing or NullNode to
+ * the default value, if any, and mutate the input json.
*/
- private JsonSchemaIdValidator schemaIdValidator = JsonSchemaIdValidator.DEFAULT;
+ private ApplyDefaultsStrategy applyDefaultsStrategy = ApplyDefaultsStrategy.EMPTY_APPLY_DEFAULTS_STRATEGY;
/**
- * when validate type, if TYPE_LOOSE = true, will try to convert string to
- * different types to match the type defined in schema.
+ * Controls if schemas loaded from refs will be cached and reused for subsequent runs.
*/
- private boolean typeLoose;
+ private boolean cacheRefs = true;
+
+ /**
+ * When set to true, "messages" provided in schema are used for forming validation errors
+ * else default messages are used
+ */
+ private String errorMessageKeyword = "message";
+
+ private ExecutionContextCustomizer executionContextCustomizer;
/**
* When set to true, validator process is stop immediately when a very first
@@ -59,15 +71,25 @@ public class SchemaValidatorsConfig {
private boolean failFast;
/**
- * When set to true, walker sets nodes that are missing or NullNode to the
- * default value, if any, and mutate the input json.
+ * Since Draft 2019-09 format assertions are not enabled by default.
*/
- private ApplyDefaultsStrategy applyDefaultsStrategy = ApplyDefaultsStrategy.EMPTY_APPLY_DEFAULTS_STRATEGY;
+ private Boolean formatAssertionsEnabled = null;
/**
- * Used to create {@link com.networknt.schema.regex.RegularExpression}.
+ * When a field is set as nullable in the OpenAPI specification, the schema
+ * validator validates that it is nullable however continues with validation
+ * against the nullable field
+ *
+ * If handleNullableField is set to true && incoming field is nullable && value
+ * is field: null --> succeed If handleNullableField is set to false && incoming
+ * field is nullable && value is field: null --> it is up to the type validator
+ * using the SchemaValidator to handle it.
*/
- private RegularExpressionFactory regularExpressionFactory = JDKRegularExpressionFactory.getInstance();
+ private boolean nullableKeywordEnabled = true;
+
+ private final WalkListenerRunner itemWalkListenerRunner;
+
+ private final List itemWalkListeners;
/**
* When set to true, use Java-specific semantics rather than native JavaScript
@@ -75,533 +97,540 @@ public class SchemaValidatorsConfig {
*/
private boolean javaSemantics;
+ private final WalkListenerRunner keywordWalkListenerRunner;
+
+ private final Map> keywordWalkListenersMap;
+
+ /**
+ * The Locale to consider when loading validation messages from the default resource bundle.
+ */
+ private Locale locale;
+
/**
* When set to true, can interpret round doubles as integers
*/
private boolean losslessNarrowing;
/**
- * When set to true, "messages" provided in schema are used for forming validation errors
- * else default messages are used
+ * The message source to use for generating localised messages.
*/
- private boolean customMessageSupported = true;
+ private MessageSource messageSource;
/**
* When set to true, support for discriminators is enabled for validations of
* oneOf, anyOf and allOf as described on GitHub.
*/
- private boolean openAPI3StyleDiscriminators = false;
+ private boolean discriminatorKeywordEnabled = false;
/**
- * Contains a mapping of how strict a keyword's validators should be.
- * Defaults to {@literal true}.
- *
- * Each validator has its own understanding of what constitutes strict
- * and permissive.
+ * The approach used to generate paths in reported messages, logs and errors. Default is the legacy "JSONPath-like" approach.
*/
- private final Map strictness = new HashMap<>(0);
+ private PathType pathType = PathType.DEFAULT;
/**
- * When a field is set as nullable in the OpenAPI specification, the schema
- * validator validates that it is nullable however continues with validation
- * against the nullable field
- *
- * If handleNullableField is set to true && incoming field is nullable && value
- * is field: null --> succeed If handleNullableField is set to false && incoming
- * field is nullable && value is field: null --> it is up to the type validator
- * using the SchemaValidator to handle it.
+ * Controls if the schema will automatically be preloaded.
*/
- private boolean handleNullableField = true;
+ private boolean preloadJsonSchema = true;
/**
- * When set to true assumes that schema is used to validate incoming data from an API.
+ * Controls the max depth of the evaluation path to preload when preloading refs.
*/
- private Boolean readOnly = null;
+ private int preloadJsonSchemaRefMaxNestingDepth = DEFAULT_PRELOAD_JSON_SCHEMA_REF_MAX_NESTING_DEPTH;
- /**
- * When set to true assumes that schema is used to to validate outgoing data from an API.
- */
- private Boolean writeOnly = null;
+ private final WalkListenerRunner propertyWalkListenerRunner;
+
+ private final List propertyWalkListeners;
/**
- * The approach used to generate paths in reported messages, logs and errors. Default is the legacy "JSONPath-like" approach.
+ * When set to true assumes that schema is used to validate incoming data from an API.
*/
- private PathType pathType = PathType.DEFAULT;
+ private Boolean readOnly = null;
/**
- * Controls if the schema will automatically be preloaded.
+ * Used to create {@link com.networknt.schema.regex.RegularExpression}.
*/
- private boolean preloadJsonSchema = true;
+ private RegularExpressionFactory regularExpressionFactory = JDKRegularExpressionFactory.getInstance();
/**
- * Controls the max depth of the evaluation path to preload when preloading refs.
+ * Used to validate the acceptable $id values.
*/
- private int preloadJsonSchemaRefMaxNestingDepth = DEFAULT_PRELOAD_JSON_SCHEMA_REF_MAX_NESTING_DEPTH;
-
+ private JsonSchemaIdValidator schemaIdValidator = JsonSchemaIdValidator.DEFAULT;
+
/**
- * Controls if schemas loaded from refs will be cached and reused for subsequent runs.
+ * Contains a mapping of how strict a keyword's validators should be.
+ * Defaults to {@literal true}.
+ *
+ * Each validator has its own understanding of what constitutes strict
+ * and permissive.
*/
- private boolean cacheRefs = true;
-
- // This is just a constant for listening to all Keywords.
- public static final String ALL_KEYWORD_WALK_LISTENER_KEY = "com.networknt.AllKeywordWalkListener";
-
- private final Map> keywordWalkListenersMap = new HashMap<>();
-
- private final List propertyWalkListeners = new ArrayList<>();
-
- private final List itemWalkListeners = new ArrayList<>();
-
- private ExecutionContextCustomizer executionContextCustomizer;
-
- @Deprecated
- private boolean loadCollectors = true;
+ private final Map strictness;
/**
- * The Locale to consider when loading validation messages from the default resource bundle.
+ * when validate type, if TYPE_LOOSE = true, will try to convert string to
+ * different types to match the type defined in schema.
*/
- private Locale locale;
+ private boolean typeLoose;
/**
- * The message source to use for generating localised messages.
+ * When set to true assumes that schema is used to to validate outgoing data from an API.
*/
- private MessageSource messageSource;
+ private Boolean writeOnly = null;
/**
- * Since Draft 2019-09 format assertions are not enabled by default.
+ * Constructor to create an instance.
+ *
+ * This is deprecated in favor of using the builder
+ * {@link SchemaValidatorsConfig#builder()} to create an instance. Migration
+ * note: The builder has different defaults from the constructor.
+ *
+ * SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ * .pathType(PathType.LEGACY)
+ * .errorMessageKeyword("message")
+ * .nullableKeywordEnabled(true)
+ * .build();
+ *
+ *
+ * - customMessageSupported (errorMessageKeyword): change from message to null
+ *
- pathType: changed from PathType.LEGACY to PathType.JSON_POINTER.
+ *
- handleNullableField (nullableKeywordEnabled): changed from true to false
+ *
*/
- private Boolean formatAssertionsEnabled = null;
-
- /************************ START OF UNEVALUATED CHECKS **********************************/
-
@Deprecated
- public SchemaValidatorsConfig disableUnevaluatedAnalysis() {
- return this;
- }
+ public SchemaValidatorsConfig() {
+ this.strictness = new HashMap<>(0);
+
+ this.keywordWalkListenersMap = new HashMap<>();
+ this.propertyWalkListeners = new ArrayList<>();
+ this.itemWalkListeners = new ArrayList<>();
+
+ this.itemWalkListenerRunner = new DefaultItemWalkListenerRunner(getArrayItemWalkListeners());
+ this.keywordWalkListenerRunner = new DefaultKeywordWalkListenerRunner(getKeywordWalkListenersMap());
+ this.propertyWalkListenerRunner = new DefaultPropertyWalkListenerRunner(getPropertyWalkListeners());
+ }
+
+ SchemaValidatorsConfig(ApplyDefaultsStrategy applyDefaultsStrategy, boolean cacheRefs,
+ String errorMessageKeyword, ExecutionContextCustomizer executionContextCustomizer, boolean failFast,
+ Boolean formatAssertionsEnabled, boolean nullableKeywordEnabled,
+ List itemWalkListeners, boolean javaSemantics,
+ Map> keywordWalkListenersMap, Locale locale, boolean losslessNarrowing,
+ MessageSource messageSource, boolean discriminatorKeywordEnabled, PathType pathType,
+ boolean preloadJsonSchema, int preloadJsonSchemaRefMaxNestingDepth,
+ List propertyWalkListeners, Boolean readOnly,
+ RegularExpressionFactory regularExpressionFactory, JsonSchemaIdValidator schemaIdValidator,
+ Map strictness, boolean typeLoose, Boolean writeOnly) {
+ super();
+ this.applyDefaultsStrategy = applyDefaultsStrategy;
+ this.cacheRefs = cacheRefs;
+ this.errorMessageKeyword = errorMessageKeyword;
+ this.executionContextCustomizer = executionContextCustomizer;
+ this.failFast = failFast;
+ this.formatAssertionsEnabled = formatAssertionsEnabled;
+ this.nullableKeywordEnabled = nullableKeywordEnabled;
+ this.itemWalkListeners = itemWalkListeners;
+ this.javaSemantics = javaSemantics;
+ this.keywordWalkListenersMap = keywordWalkListenersMap;
+ this.locale = locale;
+ this.losslessNarrowing = losslessNarrowing;
+ this.messageSource = messageSource;
+ this.discriminatorKeywordEnabled = discriminatorKeywordEnabled;
+ this.pathType = pathType;
+ this.preloadJsonSchema = preloadJsonSchema;
+ this.preloadJsonSchemaRefMaxNestingDepth = preloadJsonSchemaRefMaxNestingDepth;
+ this.propertyWalkListeners = propertyWalkListeners;
+ this.readOnly = readOnly;
+ this.regularExpressionFactory = regularExpressionFactory;
+ this.schemaIdValidator = schemaIdValidator;
+ this.strictness = strictness;
+ this.typeLoose = typeLoose;
+ this.writeOnly = writeOnly;
- @Deprecated
- public SchemaValidatorsConfig disableUnevaluatedItems() {
- return this;
+ this.itemWalkListenerRunner = new DefaultItemWalkListenerRunner(getArrayItemWalkListeners());
+ this.keywordWalkListenerRunner = new DefaultKeywordWalkListenerRunner(getKeywordWalkListenersMap());
+ this.propertyWalkListenerRunner = new DefaultPropertyWalkListenerRunner(getPropertyWalkListeners());
}
- @Deprecated
- public SchemaValidatorsConfig disableUnevaluatedProperties() {
- return this;
+ public void addItemWalkListener(JsonSchemaWalkListener itemWalkListener) {
+ this.itemWalkListeners.add(itemWalkListener);
}
- @Deprecated
- public SchemaValidatorsConfig enableUnevaluatedAnalysis() {
- return this;
+ public void addItemWalkListeners(List itemWalkListeners) {
+ this.itemWalkListeners.addAll(itemWalkListeners);
}
- @Deprecated
- public SchemaValidatorsConfig enableUnevaluatedItems() {
- return this;
+ public void addKeywordWalkListener(JsonSchemaWalkListener keywordWalkListener) {
+ if (this.keywordWalkListenersMap.get(ALL_KEYWORD_WALK_LISTENER_KEY) == null) {
+ List keywordWalkListeners = new ArrayList<>();
+ this.keywordWalkListenersMap.put(ALL_KEYWORD_WALK_LISTENER_KEY, keywordWalkListeners);
+ }
+ this.keywordWalkListenersMap.get(ALL_KEYWORD_WALK_LISTENER_KEY).add(keywordWalkListener);
}
- @Deprecated
- public SchemaValidatorsConfig enableUnevaluatedProperties() {
- return this;
+ public void addKeywordWalkListener(String keyword, JsonSchemaWalkListener keywordWalkListener) {
+ if (this.keywordWalkListenersMap.get(keyword) == null) {
+ List keywordWalkListeners = new ArrayList<>();
+ this.keywordWalkListenersMap.put(keyword, keywordWalkListeners);
+ }
+ this.keywordWalkListenersMap.get(keyword).add(keywordWalkListener);
}
- @Deprecated
- public boolean isUnevaluatedItemsAnalysisDisabled() {
- return false;
+ public void addKeywordWalkListeners(List keywordWalkListeners) {
+ if (this.keywordWalkListenersMap.get(ALL_KEYWORD_WALK_LISTENER_KEY) == null) {
+ List ikeywordWalkListeners = new ArrayList<>();
+ this.keywordWalkListenersMap.put(ALL_KEYWORD_WALK_LISTENER_KEY, ikeywordWalkListeners);
+ }
+ this.keywordWalkListenersMap.get(ALL_KEYWORD_WALK_LISTENER_KEY).addAll(keywordWalkListeners);
}
- @Deprecated
- public boolean isUnevaluatedItemsAnalysisEnabled() {
- return !isUnevaluatedItemsAnalysisDisabled();
+ public void addKeywordWalkListeners(String keyword, List keywordWalkListeners) {
+ if (this.keywordWalkListenersMap.get(keyword) == null) {
+ List ikeywordWalkListeners = new ArrayList<>();
+ this.keywordWalkListenersMap.put(keyword, ikeywordWalkListeners);
+ }
+ this.keywordWalkListenersMap.get(keyword).addAll(keywordWalkListeners);
}
- @Deprecated
- public boolean isUnevaluatedPropertiesAnalysisDisabled() {
- return false;
+ public void addPropertyWalkListener(JsonSchemaWalkListener propertyWalkListener) {
+ this.propertyWalkListeners.add(propertyWalkListener);
}
- @Deprecated
- public boolean isUnevaluatedPropertiesAnalysisEnabled() {
- return !isUnevaluatedPropertiesAnalysisDisabled();
+ public void addPropertyWalkListeners(List propertyWalkListeners) {
+ this.propertyWalkListeners.addAll(propertyWalkListeners);
}
- /************************ END OF UNEVALUATED CHECKS **********************************/
+ public ApplyDefaultsStrategy getApplyDefaultsStrategy() {
+ return this.applyDefaultsStrategy;
+ }
- /**
- *
- * @return true if type loose is used.
- */
- public boolean isTypeLoose() {
- return this.typeLoose;
+ public List getArrayItemWalkListeners() {
+ return this.itemWalkListeners;
}
- public void setTypeLoose(boolean typeLoose) {
- this.typeLoose = typeLoose;
+ public ExecutionContextCustomizer getExecutionContextCustomizer() {
+ return this.executionContextCustomizer;
}
/**
- * When enabled,
- * {@link JsonValidator#validate(ExecutionContext, JsonNode, JsonNode, JsonNodePath)}
- * doesn't return any {@link java.util.Set}<{@link ValidationMessage}>,
- * instead a {@link JsonSchemaException} is thrown as soon as a validation
- * errors is discovered.
- *
- * @param failFast boolean
+ * Gets the format assertion enabled flag.
+ *
+ * This defaults to null meaning that it will follow the defaults of the
+ * specification.
+ *
+ * Since draft 2019-09 this will default to false unless enabled by using the
+ * $vocabulary keyword.
+ *
+ * @return the format assertions enabled flag
*/
- public void setFailFast(final boolean failFast) {
- this.failFast = failFast;
- }
-
- public boolean isFailFast() {
- return this.failFast;
- }
-
- public void setApplyDefaultsStrategy(ApplyDefaultsStrategy applyDefaultsStrategy) {
- this.applyDefaultsStrategy = applyDefaultsStrategy != null ? applyDefaultsStrategy
- : ApplyDefaultsStrategy.EMPTY_APPLY_DEFAULTS_STRATEGY;
+ public Boolean getFormatAssertionsEnabled() {
+ return formatAssertionsEnabled;
}
- public ApplyDefaultsStrategy getApplyDefaultsStrategy() {
- return this.applyDefaultsStrategy;
+ WalkListenerRunner getItemWalkListenerRunner() {
+ return this.itemWalkListenerRunner;
}
- public boolean isHandleNullableField() {
- return this.handleNullableField;
+ WalkListenerRunner getKeywordWalkListenerRunner() {
+ return this.keywordWalkListenerRunner;
}
- public void setHandleNullableField(boolean handleNullableField) {
- this.handleNullableField = handleNullableField;
+ public Map> getKeywordWalkListenersMap() {
+ return this.keywordWalkListenersMap;
}
/**
- * Gets whether to use a ECMA-262 compliant regular expression validator.
+ * Get the locale to consider when generating localised messages (default is the
+ * JVM default).
*
- * This defaults to the false and setting true require inclusion of optional
- * org.jruby.joni:joni or org.graalvm.js:js dependencies.
+ * This locale is on a schema basis and will be used as the default locale for
+ * {@link com.networknt.schema.ExecutionConfig}.
*
- * @return true if ECMA-262 compliant
+ * @return The locale.
*/
- public boolean isEcma262Validator() {
- return !(this.regularExpressionFactory instanceof JDKRegularExpressionFactory);
+ public Locale getLocale() {
+ if (this.locale == null) {
+ // This should not be cached as it can be changed using Locale#setDefault(Locale)
+ return Locale.getDefault();
+ }
+ return this.locale;
}
/**
- * Sets whether to use a ECMA-262 compliant regular expression validator.
- *
- * This defaults to the false and setting true require inclusion of optional
- * org.jruby.joni:joni or org.graalvm.js:js dependencies.
- *
- * @param ecma262Validator true if ECMA-262 compliant
+ * Get the message source to use for generating localised messages.
+ *
+ * @return the message source
*/
- public void setEcma262Validator(boolean ecma262Validator) {
- this.regularExpressionFactory = ecma262Validator ? ECMAScriptRegularExpressionFactory.getInstance()
- : JDKRegularExpressionFactory.getInstance();
+ public MessageSource getMessageSource() {
+ if (this.messageSource == null) {
+ return DefaultMessageSource.getInstance();
+ }
+ return this.messageSource;
}
/**
- * Gets the regular expression factory.
- *
- * This defaults to the JDKRegularExpressionFactory and the implementations
- * require inclusion of optional org.jruby.joni:joni or org.graalvm.js:js dependencies.
+ * Get the approach used to generate paths in messages, logs and errors.
*
- * @return the factory
+ * @return The path generation approach.
*/
- public RegularExpressionFactory getRegularExpressionFactory() {
- return regularExpressionFactory;
+ public PathType getPathType() {
+ return this.pathType;
}
/**
- * Sets the regular expression factory.
- *
- * This defaults to the JDKRegularExpressionFactory and the implementations
- * require inclusion of optional org.jruby.joni:joni or org.graalvm.js:js dependencies.
+ * Gets the max depth of the evaluation path to preload when preloading refs.
*
- * @see JDKRegularExpressionFactory
- * @see ECMAScriptRegularExpressionFactory
- * @param regularExpressionFactory the factory
+ * @return the max depth to preload
*/
- public void setRegularExpressionFactory(RegularExpressionFactory regularExpressionFactory) {
- this.regularExpressionFactory = regularExpressionFactory;
- }
-
- public boolean isJavaSemantics() {
- return this.javaSemantics;
- }
-
- public void setJavaSemantics(boolean javaSemantics) {
- this.javaSemantics = javaSemantics;
- }
-
- public boolean isCustomMessageSupported() {
- return customMessageSupported;
- }
-
- public void setCustomMessageSupported(boolean customMessageSupported) {
- this.customMessageSupported = customMessageSupported;
- }
-
- public void addKeywordWalkListener(JsonSchemaWalkListener keywordWalkListener) {
- if (this.keywordWalkListenersMap.get(ALL_KEYWORD_WALK_LISTENER_KEY) == null) {
- List keywordWalkListeners = new ArrayList<>();
- this.keywordWalkListenersMap.put(ALL_KEYWORD_WALK_LISTENER_KEY, keywordWalkListeners);
- }
- this.keywordWalkListenersMap.get(ALL_KEYWORD_WALK_LISTENER_KEY).add(keywordWalkListener);
- }
-
- public void addKeywordWalkListener(String keyword, JsonSchemaWalkListener keywordWalkListener) {
- if (this.keywordWalkListenersMap.get(keyword) == null) {
- List keywordWalkListeners = new ArrayList<>();
- this.keywordWalkListenersMap.put(keyword, keywordWalkListeners);
- }
- this.keywordWalkListenersMap.get(keyword).add(keywordWalkListener);
- }
-
- public void addKeywordWalkListeners(List keywordWalkListeners) {
- if (this.keywordWalkListenersMap.get(ALL_KEYWORD_WALK_LISTENER_KEY) == null) {
- List ikeywordWalkListeners = new ArrayList<>();
- this.keywordWalkListenersMap.put(ALL_KEYWORD_WALK_LISTENER_KEY, ikeywordWalkListeners);
- }
- this.keywordWalkListenersMap.get(ALL_KEYWORD_WALK_LISTENER_KEY).addAll(keywordWalkListeners);
- }
-
- public void addKeywordWalkListeners(String keyword, List keywordWalkListeners) {
- if (this.keywordWalkListenersMap.get(keyword) == null) {
- List ikeywordWalkListeners = new ArrayList<>();
- this.keywordWalkListenersMap.put(keyword, ikeywordWalkListeners);
- }
- this.keywordWalkListenersMap.get(keyword).addAll(keywordWalkListeners);
+ public int getPreloadJsonSchemaRefMaxNestingDepth() {
+ return preloadJsonSchemaRefMaxNestingDepth;
}
- public void addPropertyWalkListeners(List propertyWalkListeners) {
- this.propertyWalkListeners.addAll(propertyWalkListeners);
+ WalkListenerRunner getPropertyWalkListenerRunner() {
+ return this.propertyWalkListenerRunner;
}
- public void addPropertyWalkListener(JsonSchemaWalkListener propertyWalkListener) {
- this.propertyWalkListeners.add(propertyWalkListener);
+ public List getPropertyWalkListeners() {
+ return this.propertyWalkListeners;
}
- public void addItemWalkListener(JsonSchemaWalkListener itemWalkListener) {
- this.itemWalkListeners.add(itemWalkListener);
+ /**
+ * Gets the regular expression factory.
+ *
+ * This defaults to the JDKRegularExpressionFactory and the implementations
+ * require inclusion of optional org.jruby.joni:joni or org.graalvm.js:js dependencies.
+ *
+ * @return the factory
+ */
+ public RegularExpressionFactory getRegularExpressionFactory() {
+ return regularExpressionFactory;
}
- public void addItemWalkListeners(List itemWalkListeners) {
- this.itemWalkListeners.addAll(itemWalkListeners);
+ /**
+ * Gets the schema id validator to validate $id.
+ *
+ * @return the validator
+ */
+ public JsonSchemaIdValidator getSchemaIdValidator() {
+ return schemaIdValidator;
}
- public List getPropertyWalkListeners() {
- return this.propertyWalkListeners;
+ /**
+ * Gets if schemas loaded from refs will be cached and reused for subsequent
+ * runs.
+ *
+ * @return true if schemas loaded from refs should be cached
+ */
+ public boolean isCacheRefs() {
+ return cacheRefs;
}
- public Map> getKeywordWalkListenersMap() {
- return this.keywordWalkListenersMap;
+ @Deprecated
+ public boolean isCustomMessageSupported() {
+ return this.errorMessageKeyword != null;
}
- public List getArrayItemWalkListeners() {
- return this.itemWalkListeners;
+ public String getErrorMessageKeyword() {
+ return this.errorMessageKeyword;
}
- private final WalkListenerRunner itemWalkListenerRunner = new DefaultItemWalkListenerRunner(getArrayItemWalkListeners());
-
- WalkListenerRunner getItemWalkListenerRunner() {
- return this.itemWalkListenerRunner;
+ /**
+ * Gets whether to use a ECMA-262 compliant regular expression validator.
+ *
+ * This defaults to the false and setting true require inclusion of optional
+ * org.jruby.joni:joni or org.graalvm.js:js dependencies.
+ *
+ * @return true if ECMA-262 compliant
+ */
+ public boolean isEcma262Validator() {
+ return !(this.regularExpressionFactory instanceof JDKRegularExpressionFactory);
}
- private final WalkListenerRunner keywordWalkListenerRunner = new DefaultKeywordWalkListenerRunner(getKeywordWalkListenersMap());
-
- WalkListenerRunner getKeywordWalkListenerRunner() {
- return this.keywordWalkListenerRunner;
- }
-
- private final WalkListenerRunner propertyWalkListenerRunner = new DefaultPropertyWalkListenerRunner(getPropertyWalkListeners());
-
- WalkListenerRunner getPropertyWalkListenerRunner() {
- return this.propertyWalkListenerRunner;
+ public boolean isFailFast() {
+ return this.failFast;
}
- public SchemaValidatorsConfig() {
+ /**
+ * Deprecated use {{@link #isNullableKeywordEnabled()} instead.
+ *
+ * @return true if the nullable keyword is enabled
+ */
+ @Deprecated
+ public boolean isHandleNullableField() {
+ return isNullableKeywordEnabled();
}
- public ExecutionContextCustomizer getExecutionContextCustomizer() {
- return this.executionContextCustomizer;
+ /**
+ * Gets if the nullable keyword is enabled.
+ *
+ * @return true if the nullable keyword is enabled
+ */
+ public boolean isNullableKeywordEnabled() {
+ return this.nullableKeywordEnabled;
}
- public void setExecutionContextCustomizer(ExecutionContextCustomizer executionContextCustomizer) {
- this.executionContextCustomizer = executionContextCustomizer;
+ public boolean isJavaSemantics() {
+ return this.javaSemantics;
}
public boolean isLosslessNarrowing() {
return this.losslessNarrowing;
}
- public void setLosslessNarrowing(boolean losslessNarrowing) {
- this.losslessNarrowing = losslessNarrowing;
- }
-
/**
* Indicates whether OpenAPI 3 style discriminators should be supported
+ *
+ * Deprecated use {{@link #isDiscriminatorKeywordEnabled()} instead.
*
* @return true in case discriminators are enabled
* @since 1.0.51
*/
+ @Deprecated
public boolean isOpenAPI3StyleDiscriminators() {
- return this.openAPI3StyleDiscriminators;
- }
-
- /**
- * When enabled, the validation of anyOf and allOf in
- * polymorphism will respect OpenAPI 3 style discriminators as described in the
- * OpenAPI
- * 3.0.3 spec. The presence of a discriminator configuration on the schema
- * will lead to the following changes in the behavior:
- *
- * - for
oneOf the spec is unfortunately very vague. Whether
- * oneOf semantics should be affected by discriminators or not is
- * not even 100% clear within the members of the OAS steering committee.
- * Therefore oneOf at the moment ignores discriminators
- * - for
anyOf the validation will choose one of the candidate
- * schemas for validation based on the discriminator property value and will
- * pass validation when this specific schema passes. This is in particular
- * useful when the payload could match multiple candidates in the
- * anyOf list and could lead to ambiguity. Example: type B has all
- * mandatory properties of A and adds more mandatory ones. Whether the payload
- * is an A or B is determined via the discriminator property name. A payload
- * indicating it is an instance of B then requires passing the validation of B
- * and passing the validation of A would not be sufficient anymore.
- * - for
allOf use cases with discriminators defined on the
- * copied-in parent type, it is possible to automatically validate against a
- * subtype. Example: some schema specifies that there is a field of type A. A
- * carries a discriminator field and B inherits from A. Then B is automatically
- * a candidate for validation as well and will be chosen in case the
- * discriminator property matches
- *
- *
- * @param openAPI3StyleDiscriminators whether or not discriminators should be
- * used. Defaults to false
- * @since 1.0.51
- */
- public void setOpenAPI3StyleDiscriminators(boolean openAPI3StyleDiscriminators) {
- this.openAPI3StyleDiscriminators = openAPI3StyleDiscriminators;
+ return isDiscriminatorKeywordEnabled();
}
/**
- * Sets if collectors are to be loaded.
- *
- * This is deprecated in favor of the caller calling {@link CollectorContext#loadCollectors()} manually.
+ * Gets if the discriminator keyword is enabled.
*
- * @param loadCollectors to load collectors
+ * @return true if the discriminator keyword is enabled
*/
- @Deprecated
- public void setLoadCollectors(boolean loadCollectors) {
- this.loadCollectors = loadCollectors;
+ public boolean isDiscriminatorKeywordEnabled() {
+ return this.discriminatorKeywordEnabled;
}
/**
- * Gets if collectors are to be loaded.
+ * Gets if the schema should be preloaded.
*
- * @return if collectors are to be loader
+ * @return true if it should be preloaded
*/
- @Deprecated
- public boolean doLoadCollectors() {
- return this.loadCollectors;
+ public boolean isPreloadJsonSchema() {
+ return preloadJsonSchema;
}
public boolean isReadOnly() {
return null != this.readOnly && this.readOnly;
}
- public void setReadOnly(boolean readOnly) {
- this.readOnly = readOnly;
- }
-
- public boolean isWriteOnly() {
- return null != this.writeOnly && this.writeOnly;
- }
-
- public void setWriteOnly(boolean writeOnly) {
- this.writeOnly = writeOnly;
+ /**
+ * Answers whether a keyword's validators may relax their analysis. The
+ * default is to perform strict checking. One must explicitly allow a
+ * validator to be more permissive.
+ *
+ * Each validator has its own understanding of what is permissive and
+ * strict. Consult the keyword's documentation for details.
+ *
+ * @param keyword the keyword to adjust (not null)
+ * @return Whether to perform a strict validation.
+ */
+ public boolean isStrict(String keyword) {
+ return isStrict(keyword, Boolean.TRUE);
}
/**
- * Use {@code isReadOnly} or {@code isWriteOnly}
- * @return true if schema is used to write data
+ * Determines if the validator should perform strict checking.
+ *
+ * @param keyword the keyword
+ * @param defaultValue the default value
+ * @return whether to perform a strict validation
*/
- @Deprecated
- public boolean isWriteMode() {
- return null == this.writeOnly || this.writeOnly;
+ public boolean isStrict(String keyword, Boolean defaultValue) {
+ return this.strictness.getOrDefault(Objects.requireNonNull(keyword, "keyword cannot be null"), defaultValue);
}
/**
- * Set the approach used to generate paths in messages, logs and errors (default is PathType.LEGACY).
*
- * @param pathType The path generation approach.
+ * @return true if type loose is used.
*/
- public void setPathType(PathType pathType) {
- this.pathType = pathType;
+ public boolean isTypeLoose() {
+ return this.typeLoose;
+ }
+
+ public boolean isWriteOnly() {
+ return null != this.writeOnly && this.writeOnly;
+ }
+
+ public void setApplyDefaultsStrategy(ApplyDefaultsStrategy applyDefaultsStrategy) {
+ this.applyDefaultsStrategy = applyDefaultsStrategy != null ? applyDefaultsStrategy
+ : ApplyDefaultsStrategy.EMPTY_APPLY_DEFAULTS_STRATEGY;
}
/**
- * Get the approach used to generate paths in messages, logs and errors.
- *
- * @return The path generation approach.
+ * Sets if schemas loaded from refs will be cached and reused for subsequent
+ * runs.
+ *
+ * Note that setting this to false will affect performance as refs will need to
+ * be repeatedly resolved for each evaluation run. It may be needed to be set to
+ * false if there are multiple nested applicators like anyOf, oneOf and allOf as
+ * that will consume a lot of memory to cache all the permutations.
+ *
+ * @param cacheRefs true to cache
*/
- public PathType getPathType() {
- return this.pathType;
+ public void setCacheRefs(boolean cacheRefs) {
+ this.cacheRefs = cacheRefs;
}
/**
- * Answers whether a keyword's validators may relax their analysis. The
- * default is to perform strict checking. One must explicitly allow a
- * validator to be more permissive.
+ * Sets whether custom error messages in the schema are used.
*
- * Each validator has its own understanding of what is permissive and
- * strict. Consult the keyword's documentation for details.
- *
- * @param keyword the keyword to adjust (not null)
- * @return Whether to perform a strict validation.
+ * This is deprecated in favor of setting the error message keyword to use.
+ *
+ * @param customMessageSupported true to use message as the error message keyword
*/
- public boolean isStrict(String keyword) {
- return isStrict(keyword, Boolean.TRUE);
+ @Deprecated
+ public void setCustomMessageSupported(boolean customMessageSupported) {
+ this.errorMessageKeyword = customMessageSupported ? "message" : null;
}
/**
- * Determines if the validator should perform strict checking.
+ * Sets whether to use a ECMA-262 compliant regular expression validator.
+ *
+ * This defaults to the false and setting true require inclusion of optional
+ * org.jruby.joni:joni or org.graalvm.js:js dependencies.
*
- * @param keyword the keyword
- * @param defaultValue the default value
- * @return whether to perform a strict validation
+ * @param ecma262Validator true if ECMA-262 compliant
*/
- public boolean isStrict(String keyword, Boolean defaultValue) {
- return this.strictness.getOrDefault(Objects.requireNonNull(keyword, "keyword cannot be null"), defaultValue);
+ public void setEcma262Validator(boolean ecma262Validator) {
+ this.regularExpressionFactory = ecma262Validator ? ECMAScriptRegularExpressionFactory.getInstance()
+ : JDKRegularExpressionFactory.getInstance();
+ }
+
+ public void setExecutionContextCustomizer(ExecutionContextCustomizer executionContextCustomizer) {
+ this.executionContextCustomizer = executionContextCustomizer;
}
/**
- * Alters the strictness of validations for a specific keyword. When set to
- * {@literal true}, instructs the keyword's validators to perform strict
- * validation. Otherwise, a validator may perform a more permissive check.
- *
- * @param keyword The keyword to adjust (not null)
- * @param strict Whether to perform strict validations
+ * When enabled,
+ * {@link JsonValidator#validate(ExecutionContext, JsonNode, JsonNode, JsonNodePath)}
+ * doesn't return any {@link java.util.Set}<{@link ValidationMessage}>,
+ * instead a {@link JsonSchemaException} is thrown as soon as a validation
+ * errors is discovered.
+ *
+ * @param failFast boolean
*/
- public void setStrict(String keyword, boolean strict) {
- this.strictness.put(Objects.requireNonNull(keyword, "keyword cannot be null"), strict);
+ public void setFailFast(final boolean failFast) {
+ this.failFast = failFast;
}
/**
- * Get the locale to consider when generating localised messages (default is the
- * JVM default).
+ * Sets the format assertion enabled flag.
*
- * This locale is on a schema basis and will be used as the default locale for
- * {@link com.networknt.schema.ExecutionConfig}.
- *
- * @return The locale.
+ * This is deprecated. Either set this using the builder
+ * SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build() or
+ * this should be set via
+ * executionContext.getExecutionConfig().setFormatAssertionsEnabled(true).
+ *
+ * @param formatAssertionsEnabled the format assertions enabled flag
*/
- public Locale getLocale() {
- if (this.locale == null) {
- // This should not be cached as it can be changed using Locale#setDefault(Locale)
- return Locale.getDefault();
- }
- return this.locale;
+ @Deprecated
+ public void setFormatAssertionsEnabled(Boolean formatAssertionsEnabled) {
+ this.formatAssertionsEnabled = formatAssertionsEnabled;
+ }
+
+ public void setHandleNullableField(boolean handleNullableField) {
+ this.nullableKeywordEnabled = handleNullableField;
+ }
+
+ public void setJavaSemantics(boolean javaSemantics) {
+ this.javaSemantics = javaSemantics;
}
/**
@@ -610,23 +639,20 @@ public Locale getLocale() {
* Note that this locale is set on a schema basis. To configure the schema on a
* per execution basis use
* {@link com.networknt.schema.ExecutionConfig#setLocale(Locale)}.
+ *
+ * This is deprecated. Either set this using the builder
+ * SchemaValidatorsConfig.builder().locale(locale).build() or this should be set
+ * via executionContext.getExecutionConfig().setLocale(locale).
*
* @param locale The locale.
*/
+ @Deprecated
public void setLocale(Locale locale) {
this.locale = locale;
}
- /**
- * Get the message source to use for generating localised messages.
- *
- * @return the message source
- */
- public MessageSource getMessageSource() {
- if (this.messageSource == null) {
- return DefaultMessageSource.getInstance();
- }
- return this.messageSource;
+ public void setLosslessNarrowing(boolean losslessNarrowing) {
+ this.losslessNarrowing = losslessNarrowing;
}
/**
@@ -639,36 +665,85 @@ public void setMessageSource(MessageSource messageSource) {
}
/**
- * Gets the format assertion enabled flag.
- *
- * This defaults to null meaning that it will follow the defaults of the
- * specification.
- *
- * Since draft 2019-09 this will default to false unless enabled by using the
- * $vocabulary keyword.
+ * When enabled, the validation of anyOf and allOf in
+ * polymorphism will respect OpenAPI 3 style discriminators as described in the
+ * OpenAPI
+ * 3.0.3 spec. The presence of a discriminator configuration on the schema
+ * will lead to the following changes in the behavior:
+ *
+ * - for
oneOf the spec is unfortunately very vague. Whether
+ * oneOf semantics should be affected by discriminators or not is
+ * not even 100% clear within the members of the OAS steering committee.
+ * Therefore oneOf at the moment ignores discriminators
+ * - for
anyOf the validation will choose one of the candidate
+ * schemas for validation based on the discriminator property value and will
+ * pass validation when this specific schema passes. This is in particular
+ * useful when the payload could match multiple candidates in the
+ * anyOf list and could lead to ambiguity. Example: type B has all
+ * mandatory properties of A and adds more mandatory ones. Whether the payload
+ * is an A or B is determined via the discriminator property name. A payload
+ * indicating it is an instance of B then requires passing the validation of B
+ * and passing the validation of A would not be sufficient anymore.
+ * - for
allOf use cases with discriminators defined on the
+ * copied-in parent type, it is possible to automatically validate against a
+ * subtype. Example: some schema specifies that there is a field of type A. A
+ * carries a discriminator field and B inherits from A. Then B is automatically
+ * a candidate for validation as well and will be chosen in case the
+ * discriminator property matches
+ *
*
- * @return the format assertions enabled flag
+ * @param openAPI3StyleDiscriminators whether or not discriminators should be
+ * used. Defaults to false
+ * @since 1.0.51
*/
- public Boolean getFormatAssertionsEnabled() {
- return formatAssertionsEnabled;
+ public void setOpenAPI3StyleDiscriminators(boolean openAPI3StyleDiscriminators) {
+ this.discriminatorKeywordEnabled = openAPI3StyleDiscriminators;
}
/**
- * Sets the format assertion enabled flag.
- *
- * @param formatAssertionsEnabled the format assertions enabled flag
+ * Set the approach used to generate paths in messages, logs and errors (default is PathType.LEGACY).
+ *
+ * @param pathType The path generation approach.
*/
- public void setFormatAssertionsEnabled(Boolean formatAssertionsEnabled) {
- this.formatAssertionsEnabled = formatAssertionsEnabled;
+ public void setPathType(PathType pathType) {
+ this.pathType = pathType;
}
/**
- * Gets the schema id validator to validate $id.
+ * Sets if the schema should be preloaded.
*
- * @return the validator
+ * @param preloadJsonSchema true to preload
*/
- public JsonSchemaIdValidator getSchemaIdValidator() {
- return schemaIdValidator;
+ public void setPreloadJsonSchema(boolean preloadJsonSchema) {
+ this.preloadJsonSchema = preloadJsonSchema;
+ }
+
+ /**
+ * Sets the max depth of the evaluation path to preload when preloading refs.
+ *
+ * @param preloadJsonSchemaRefMaxNestingDepth the max depth to preload
+ */
+ public void setPreloadJsonSchemaRefMaxNestingDepth(int preloadJsonSchemaRefMaxNestingDepth) {
+ this.preloadJsonSchemaRefMaxNestingDepth = preloadJsonSchemaRefMaxNestingDepth;
+ }
+
+ public void setReadOnly(boolean readOnly) {
+ this.readOnly = readOnly;
+ }
+
+ /**
+ * Sets the regular expression factory.
+ *
+ * This defaults to the JDKRegularExpressionFactory and the implementations
+ * require inclusion of optional org.jruby.joni:joni or org.graalvm.js:js dependencies.
+ *
+ * @see JDKRegularExpressionFactory
+ * @see ECMAScriptRegularExpressionFactory
+ * @param regularExpressionFactory the factory
+ */
+ public void setRegularExpressionFactory(RegularExpressionFactory regularExpressionFactory) {
+ this.regularExpressionFactory = regularExpressionFactory;
}
/**
@@ -681,63 +756,646 @@ public void setSchemaIdValidator(JsonSchemaIdValidator schemaIdValidator) {
}
/**
- * Gets if the schema should be preloaded.
+ * Alters the strictness of validations for a specific keyword. When set to
+ * {@literal true}, instructs the keyword's validators to perform strict
+ * validation. Otherwise, a validator may perform a more permissive check.
*
- * @return true if it should be preloaded
+ * @param keyword The keyword to adjust (not null)
+ * @param strict Whether to perform strict validations
*/
- public boolean isPreloadJsonSchema() {
- return preloadJsonSchema;
+ public void setStrict(String keyword, boolean strict) {
+ this.strictness.put(Objects.requireNonNull(keyword, "keyword cannot be null"), strict);
+ }
+
+ public void setTypeLoose(boolean typeLoose) {
+ this.typeLoose = typeLoose;
+ }
+
+ public void setWriteOnly(boolean writeOnly) {
+ this.writeOnly = writeOnly;
+ }
+
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ public static Builder builder(SchemaValidatorsConfig config) {
+ Builder builder = new Builder();
+ builder.applyDefaultsStrategy = config.applyDefaultsStrategy;
+ builder.cacheRefs = config.cacheRefs;
+ builder.errorMessageKeyword = config.errorMessageKeyword;
+ builder.executionContextCustomizer = config.executionContextCustomizer;
+ builder.failFast = config.failFast;
+ builder.formatAssertionsEnabled = config.formatAssertionsEnabled;
+ builder.nullableKeywordEnabled = config.nullableKeywordEnabled;
+ builder.itemWalkListeners = config.itemWalkListeners;
+ builder.javaSemantics = config.javaSemantics;
+ builder.keywordWalkListeners = config.keywordWalkListenersMap;
+ builder.locale = config.locale;
+ builder.losslessNarrowing = config.losslessNarrowing;
+ builder.messageSource = config.messageSource;
+ builder.discriminatorKeywordEnabled = config.discriminatorKeywordEnabled;
+ builder.pathType = config.pathType;
+ builder.preloadJsonSchema = config.preloadJsonSchema;
+ builder.preloadJsonSchemaRefMaxNestingDepth = config.preloadJsonSchemaRefMaxNestingDepth;
+ builder.propertyWalkListeners = config.propertyWalkListeners;
+ builder.readOnly = config.readOnly;
+ builder.regularExpressionFactory = config.regularExpressionFactory;
+ builder.schemaIdValidator = config.schemaIdValidator;
+ builder.strictness = config.strictness;
+ builder.typeLoose = config.typeLoose;
+ builder.writeOnly = config.writeOnly;
+ return builder;
}
/**
- * Sets if the schema should be preloaded.
- *
- * @param preloadJsonSchema true to preload
+ * Builder for {@link SchemaValidatorsConfig}.
*/
- public void setPreloadJsonSchema(boolean preloadJsonSchema) {
- this.preloadJsonSchema = preloadJsonSchema;
+ public static class Builder {
+ private ApplyDefaultsStrategy applyDefaultsStrategy = ApplyDefaultsStrategy.EMPTY_APPLY_DEFAULTS_STRATEGY;
+ private boolean cacheRefs = true;
+ private String errorMessageKeyword = null;
+ private ExecutionContextCustomizer executionContextCustomizer = null;
+ private boolean failFast = false;
+ private Boolean formatAssertionsEnabled = false;
+ private boolean nullableKeywordEnabled = false;
+ private List itemWalkListeners = new ArrayList<>();
+ private boolean javaSemantics = false;
+ private Map> keywordWalkListeners = new HashMap<>();
+ private Locale locale = null; // This must be null to use Locale.getDefault() as the default can be changed
+ private boolean losslessNarrowing = false;
+ private MessageSource messageSource = null;
+ private boolean discriminatorKeywordEnabled = false;
+ private PathType pathType = PathType.JSON_POINTER;
+ private boolean preloadJsonSchema = true;
+ private int preloadJsonSchemaRefMaxNestingDepth = DEFAULT_PRELOAD_JSON_SCHEMA_REF_MAX_NESTING_DEPTH;
+ private List propertyWalkListeners = new ArrayList<>();
+ private Boolean readOnly = null;
+ private RegularExpressionFactory regularExpressionFactory = JDKRegularExpressionFactory.getInstance();
+ private JsonSchemaIdValidator schemaIdValidator = JsonSchemaIdValidator.DEFAULT;
+ private Map strictness = new HashMap<>(0);
+ private boolean typeLoose = false;
+ private Boolean writeOnly = null;
+
+ /**
+ * Sets the strategy the walker uses to sets nodes to the default value.
+ *
+ * Defaults to {@link ApplyDefaultsStrategy#EMPTY_APPLY_DEFAULTS_STRATEGY}.
+ *
+ * @param applyDefaultsStrategy the strategy
+ * @return the builder
+ */
+ public Builder applyDefaultsStrategy(ApplyDefaultsStrategy applyDefaultsStrategy) {
+ this.applyDefaultsStrategy = applyDefaultsStrategy != null ? applyDefaultsStrategy
+ : ApplyDefaultsStrategy.EMPTY_APPLY_DEFAULTS_STRATEGY;
+ return this;
+ }
+ /**
+ * Sets if schemas loaded from refs will be cached and reused for subsequent runs.
+ *
+ * Defaults to true.
+ *
+ * @param cacheRefs true to cache
+ * @return the builder
+ */
+ public Builder cacheRefs(boolean cacheRefs) {
+ this.cacheRefs = cacheRefs;
+ return this;
+ }
+ /**
+ * Sets the error message keyword for setting custom messages in the schema.
+ *
+ * Defaults to null meaning custom messages are not enabled.
+ *
+ * @param errorMessageKeyword to use for custom messages in the schema
+ * @return the builder
+ */
+ public Builder errorMessageKeyword(String errorMessageKeyword) {
+ this.errorMessageKeyword = errorMessageKeyword;
+ return this;
+ }
+ /**
+ * Sets the execution context customizer that is run before each run.
+ *
+ * @param executionContextCustomizer the customizer
+ * @return the builder
+ */
+ public Builder executionContextCustomizer(ExecutionContextCustomizer executionContextCustomizer) {
+ this.executionContextCustomizer = executionContextCustomizer;
+ return this;
+ }
+
+ /**
+ * Sets if the validation should immediately return once a validation error has
+ * occurred. This can improve performance if inputs are invalid but cannot
+ * return all error messages to the caller.
+ *
+ * Defaults to false.
+ *
+ * @param failFast true to enable
+ * @return the builder
+ */
+ public Builder failFast(boolean failFast) {
+ this.failFast = failFast;
+ return this;
+ }
+
+ /**
+ * Sets if format assertions are enabled. If format assertions are not enabled
+ * the format keyword will behave like a annotation and not attempt to validate
+ * if the inputs are valid.
+ *
+ * Defaults to not enabling format assertions for Draft 2019-09 and above and
+ * enabling format assertions for Draft 7 and below.
+ *
+ * @param formatAssertionsEnabled true to enable
+ * @return the builder
+ */
+ public Builder formatAssertionsEnabled(Boolean formatAssertionsEnabled) {
+ this.formatAssertionsEnabled = formatAssertionsEnabled;
+ return this;
+ }
+
+ /**
+ * Sets if the nullable keyword is enabled.
+ *
+ * @param nullableKeywordEnabled true to enable
+ * @return the builder
+ */
+ public Builder nullableKeywordEnabled(boolean nullableKeywordEnabled) {
+ this.nullableKeywordEnabled = nullableKeywordEnabled;
+ return this;
+ }
+ public Builder itemWalkListeners(List itemWalkListeners) {
+ this.itemWalkListeners = itemWalkListeners;
+ return this;
+ }
+ public Builder javaSemantics(boolean javaSemantics) {
+ this.javaSemantics = javaSemantics;
+ return this;
+ }
+ public Builder keywordWalkListeners(Map> keywordWalkListeners) {
+ this.keywordWalkListeners = keywordWalkListeners;
+ return this;
+ }
+ /**
+ * Set the locale to consider when generating localised messages.
+ *
+ * Note that this locale is set on a schema basis. To configure the schema on a
+ * per execution basis use
+ * {@link com.networknt.schema.ExecutionConfig#setLocale(Locale)}.
+ *
+ * Defaults to use {@link Locale#getDefault()}.
+ *
+ * @param locale The locale.
+ */
+ public Builder locale(Locale locale) {
+ this.locale = locale;
+ return this;
+ }
+ public Builder losslessNarrowing(boolean losslessNarrowing) {
+ this.losslessNarrowing = losslessNarrowing;
+ return this;
+ }
+ /**
+ * Sets the message source to use for generating localised messages.
+ *
+ * @param messageSource the message source
+ * @return the builder
+ */
+ public Builder messageSource(MessageSource messageSource) {
+ this.messageSource = messageSource;
+ return this;
+ }
+ /**
+ * Sets if the discriminator keyword is enabled.
+ *
+ * Defaults to false.
+ *
+ * @param discriminatorKeywordEnabled true to enable
+ * @return the builder
+ */
+ public Builder discriminatorKeywordEnabled(boolean discriminatorKeywordEnabled) {
+ this.discriminatorKeywordEnabled = discriminatorKeywordEnabled;
+ return this;
+ }
+ /**
+ * Sets the path type to use when reporting the instance location of errors.
+ *
+ * Defaults to {@link PathType#JSON_POINTER}.
+ *
+ * @param pathType the path type
+ * @return the path type
+ */
+ public Builder pathType(PathType pathType) {
+ this.pathType = pathType;
+ return this;
+ }
+ /**
+ * Sets if the schema should be preloaded.
+ *
+ * Defaults to true.
+ *
+ * @param preloadJsonSchema true to preload
+ * @return the builder
+ */
+ public Builder preloadJsonSchema(boolean preloadJsonSchema) {
+ this.preloadJsonSchema = preloadJsonSchema;
+ return this;
+ }
+ /**
+ * Sets the max depth of the evaluation path to preload when preloading refs.
+ *
+ * Defaults to 40.
+ *
+ * @param preloadJsonSchemaRefMaxNestingDepth to preload
+ * @return the builder
+ */
+ public Builder preloadJsonSchemaRefMaxNestingDepth(int preloadJsonSchemaRefMaxNestingDepth) {
+ this.preloadJsonSchemaRefMaxNestingDepth = preloadJsonSchemaRefMaxNestingDepth;
+ return this;
+ }
+ public Builder propertyWalkListeners(List propertyWalkListeners) {
+ this.propertyWalkListeners = propertyWalkListeners;
+ return this;
+ }
+ public Builder readOnly(Boolean readOnly) {
+ this.readOnly = readOnly;
+ return this;
+ }
+ /**
+ * Sets the regular expression factory.
+ *
+ * Defaults to the {@link JDKRegularExpressionFactory}
+ *
+ * The {@link ECMAScriptRegularExpressionFactory} requires the inclusion of
+ * optional org.jruby.joni:joni or org.graalvm.js:js dependencies.
+ *
+ * @see JDKRegularExpressionFactory
+ * @see ECMAScriptRegularExpressionFactory
+ * @param regularExpressionFactory the factory
+ * @return the builder
+ */
+ public Builder regularExpressionFactory(RegularExpressionFactory regularExpressionFactory) {
+ this.regularExpressionFactory = regularExpressionFactory;
+ return this;
+ }
+ /**
+ * Sets the schema id validator to use.
+ *
+ * Defaults to {@link JsonSchemaIdValidator#DEFAULT}.
+ *
+ * @param schemaIdValidator the builder
+ * @return the builder
+ */
+ public Builder schemaIdValidator(JsonSchemaIdValidator schemaIdValidator) {
+ this.schemaIdValidator = schemaIdValidator;
+ return this;
+ }
+ public Builder strict(Map strict) {
+ this.strictness = strict;
+ return this;
+ }
+ public Builder typeLoose(boolean typeLoose) {
+ this.typeLoose = typeLoose;
+ return this;
+ }
+ public Builder writeOnly(Boolean writeOnly) {
+ this.writeOnly = writeOnly;
+ return this;
+ }
+ public SchemaValidatorsConfig build() {
+ return new ImmutableSchemaValidatorsConfig(applyDefaultsStrategy, cacheRefs, errorMessageKeyword,
+ executionContextCustomizer, failFast, formatAssertionsEnabled, nullableKeywordEnabled,
+ itemWalkListeners, javaSemantics, keywordWalkListeners, locale, losslessNarrowing, messageSource,
+ discriminatorKeywordEnabled, pathType, preloadJsonSchema, preloadJsonSchemaRefMaxNestingDepth,
+ propertyWalkListeners, readOnly, regularExpressionFactory, schemaIdValidator, strictness, typeLoose,
+ writeOnly);
+ }
+ public Builder strict(String keyword, boolean strict) {
+ this.strictness.put(Objects.requireNonNull(keyword, "keyword cannot be null"), strict);
+ return this;
+ }
+ public Builder keywordWalkListener(String keyword, JsonSchemaWalkListener keywordWalkListener) {
+ this.keywordWalkListeners.computeIfAbsent(keyword, key -> new ArrayList<>()).add(keywordWalkListener);
+ return this;
+ }
+ public Builder keywordWalkListener(JsonSchemaWalkListener keywordWalkListener) {
+ return keywordWalkListener(ALL_KEYWORD_WALK_LISTENER_KEY, keywordWalkListener);
+ }
+ public Builder keywordWalkListeners(Consumer>> keywordWalkListeners) {
+ keywordWalkListeners.accept(this.keywordWalkListeners);
+ return this;
+ }
+ public Builder propertyWalkListener(JsonSchemaWalkListener propertyWalkListener) {
+ this.propertyWalkListeners.add(propertyWalkListener);
+ return this;
+ }
+ public Builder propertyWalkListeners(Consumer> propertyWalkListeners) {
+ propertyWalkListeners.accept(this.propertyWalkListeners);
+ return this;
+ }
+ public Builder itemWalkListener(JsonSchemaWalkListener itemWalkListener) {
+ this.itemWalkListeners.add(itemWalkListener);
+ return this;
+ }
+ public Builder itemWalkListeners(Consumer> itemWalkListeners) {
+ itemWalkListeners.accept(this.itemWalkListeners);
+ return this;
+ }
}
/**
- * Gets the max depth of the evaluation path to preload when preloading refs.
- *
- * @return the max depth to preload
+ * {@link SchemaValidatorsConfig} that throws on mutators or deprecated methods.
+ *
+ * The {@link SchemaValidatorsConfig} will be made immutable in a future breaking release.
*/
- public int getPreloadJsonSchemaRefMaxNestingDepth() {
- return preloadJsonSchemaRefMaxNestingDepth;
+ public static class ImmutableSchemaValidatorsConfig extends SchemaValidatorsConfig {
+ public ImmutableSchemaValidatorsConfig(ApplyDefaultsStrategy applyDefaultsStrategy, boolean cacheRefs,
+ String errorMessageKeyword, ExecutionContextCustomizer executionContextCustomizer, boolean failFast,
+ Boolean formatAssertionsEnabled, boolean handleNullableField,
+ List itemWalkListeners, boolean javaSemantics,
+ Map> keywordWalkListenersMap, Locale locale,
+ boolean losslessNarrowing, MessageSource messageSource, boolean openAPI3StyleDiscriminators,
+ PathType pathType, boolean preloadJsonSchema, int preloadJsonSchemaRefMaxNestingDepth,
+ List propertyWalkListeners, Boolean readOnly,
+ RegularExpressionFactory regularExpressionFactory, JsonSchemaIdValidator schemaIdValidator,
+ Map strictness, boolean typeLoose, Boolean writeOnly) {
+ super(applyDefaultsStrategy, cacheRefs, errorMessageKeyword, executionContextCustomizer, failFast,
+ formatAssertionsEnabled, handleNullableField, itemWalkListeners, javaSemantics, keywordWalkListenersMap, locale,
+ losslessNarrowing, messageSource, openAPI3StyleDiscriminators, pathType, preloadJsonSchema,
+ preloadJsonSchemaRefMaxNestingDepth, propertyWalkListeners, readOnly, regularExpressionFactory,
+ schemaIdValidator, strictness, typeLoose, writeOnly);
+ }
+
+ @Override
+ public void addItemWalkListener(JsonSchemaWalkListener itemWalkListener) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addItemWalkListeners(List itemWalkListeners) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addKeywordWalkListener(JsonSchemaWalkListener keywordWalkListener) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addKeywordWalkListener(String keyword, JsonSchemaWalkListener keywordWalkListener) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addKeywordWalkListeners(List keywordWalkListeners) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addKeywordWalkListeners(String keyword, List keywordWalkListeners) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addPropertyWalkListener(JsonSchemaWalkListener propertyWalkListener) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addPropertyWalkListeners(List propertyWalkListeners) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setApplyDefaultsStrategy(ApplyDefaultsStrategy applyDefaultsStrategy) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setCacheRefs(boolean cacheRefs) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setCustomMessageSupported(boolean customMessageSupported) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setEcma262Validator(boolean ecma262Validator) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setExecutionContextCustomizer(ExecutionContextCustomizer executionContextCustomizer) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setFailFast(boolean failFast) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setFormatAssertionsEnabled(Boolean formatAssertionsEnabled) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setHandleNullableField(boolean handleNullableField) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setJavaSemantics(boolean javaSemantics) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setLocale(Locale locale) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setLosslessNarrowing(boolean losslessNarrowing) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setMessageSource(MessageSource messageSource) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setOpenAPI3StyleDiscriminators(boolean openAPI3StyleDiscriminators) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setPathType(PathType pathType) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setPreloadJsonSchema(boolean preloadJsonSchema) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setPreloadJsonSchemaRefMaxNestingDepth(int preloadJsonSchemaRefMaxNestingDepth) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setReadOnly(boolean readOnly) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setRegularExpressionFactory(RegularExpressionFactory regularExpressionFactory) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setSchemaIdValidator(JsonSchemaIdValidator schemaIdValidator) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setStrict(String keyword, boolean strict) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setTypeLoose(boolean typeLoose) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setWriteOnly(boolean writeOnly) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setLoadCollectors(boolean loadCollectors) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public SchemaValidatorsConfig disableUnevaluatedAnalysis() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public SchemaValidatorsConfig disableUnevaluatedItems() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public SchemaValidatorsConfig disableUnevaluatedProperties() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public SchemaValidatorsConfig enableUnevaluatedAnalysis() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public SchemaValidatorsConfig enableUnevaluatedItems() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public SchemaValidatorsConfig enableUnevaluatedProperties() {
+ throw new UnsupportedOperationException();
+ }
}
+ /* Below are deprecated for removal */
+ @Deprecated
+ private boolean loadCollectors = true;
+
/**
- * Sets the max depth of the evaluation path to preload when preloading refs.
- *
- * @param preloadJsonSchemaRefMaxNestingDepth the max depth to preload
+ * Use {@code isReadOnly} or {@code isWriteOnly}
+ * @return true if schema is used to write data
*/
- public void setPreloadJsonSchemaRefMaxNestingDepth(int preloadJsonSchemaRefMaxNestingDepth) {
- this.preloadJsonSchemaRefMaxNestingDepth = preloadJsonSchemaRefMaxNestingDepth;
+ @Deprecated
+ public boolean isWriteMode() {
+ return null == this.writeOnly || this.writeOnly;
}
-
+
/**
- * Gets if schemas loaded from refs will be cached and reused for subsequent
- * runs.
- *
- * @return true if schemas loaded from refs should be cached
+ * Sets if collectors are to be loaded.
+ *
+ * This is deprecated in favor of the caller calling {@link CollectorContext#loadCollectors()} manually.
+ *
+ * @param loadCollectors to load collectors
*/
- public boolean isCacheRefs() {
- return cacheRefs;
+ @Deprecated
+ public void setLoadCollectors(boolean loadCollectors) {
+ this.loadCollectors = loadCollectors;
}
/**
- * Sets if schemas loaded from refs will be cached and reused for subsequent
- * runs.
- *
- * Note that setting this to false will affect performance as refs will need to
- * be repeatedly resolved for each evaluation run. It may be needed to be set to
- * false if there are multiple nested applicators like anyOf, oneOf and allOf as
- * that will consume a lot of memory to cache all the permutations.
+ * Gets if collectors are to be loaded.
*
- * @param cacheRefs true to cache
+ * @return if collectors are to be loader
*/
- public void setCacheRefs(boolean cacheRefs) {
- this.cacheRefs = cacheRefs;
+ @Deprecated
+ public boolean doLoadCollectors() {
+ return this.loadCollectors;
+ }
+
+ @Deprecated
+ public SchemaValidatorsConfig disableUnevaluatedAnalysis() {
+ return this;
+ }
+
+ @Deprecated
+ public SchemaValidatorsConfig disableUnevaluatedItems() {
+ return this;
+ }
+
+ @Deprecated
+ public SchemaValidatorsConfig disableUnevaluatedProperties() {
+ return this;
+ }
+
+ @Deprecated
+ public SchemaValidatorsConfig enableUnevaluatedAnalysis() {
+ return this;
+ }
+
+ @Deprecated
+ public SchemaValidatorsConfig enableUnevaluatedItems() {
+ return this;
+ }
+
+ @Deprecated
+ public SchemaValidatorsConfig enableUnevaluatedProperties() {
+ return this;
+ }
+
+ @Deprecated
+ public boolean isUnevaluatedItemsAnalysisDisabled() {
+ return false;
+ }
+
+ @Deprecated
+ public boolean isUnevaluatedItemsAnalysisEnabled() {
+ return !isUnevaluatedItemsAnalysisDisabled();
+ }
+
+ @Deprecated
+ public boolean isUnevaluatedPropertiesAnalysisDisabled() {
+ return false;
+ }
+
+ @Deprecated
+ public boolean isUnevaluatedPropertiesAnalysisEnabled() {
+ return !isUnevaluatedPropertiesAnalysisDisabled();
}
}
diff --git a/src/main/java/com/networknt/schema/ValidationContext.java b/src/main/java/com/networknt/schema/ValidationContext.java
index 8572a9a9d..f4d6e12f7 100644
--- a/src/main/java/com/networknt/schema/ValidationContext.java
+++ b/src/main/java/com/networknt/schema/ValidationContext.java
@@ -47,6 +47,7 @@ public ValidationContext(JsonMetaSchema metaSchema, JsonSchemaFactory jsonSchema
}
this.metaSchema = metaSchema;
this.jsonSchemaFactory = jsonSchemaFactory;
+ // The deprecated SchemaValidatorsConfig constructor needs to remain until removed
this.config = config == null ? new SchemaValidatorsConfig() : config;
this.schemaReferences = schemaReferences;
this.schemaResources = schemaResources;
diff --git a/src/main/java/com/networknt/schema/ValidationMessage.java b/src/main/java/com/networknt/schema/ValidationMessage.java
index 41850940d..aa5f73ec8 100644
--- a/src/main/java/com/networknt/schema/ValidationMessage.java
+++ b/src/main/java/com/networknt/schema/ValidationMessage.java
@@ -39,7 +39,7 @@
* "https://github.com/json-schema-org/json-schema-spec/blob/main/jsonschema-validation-output-machines.md">JSON
* Schema
*/
-@JsonIgnoreProperties({ "messageSupplier", "schemaNode", "instanceNode", "valid" })
+@JsonIgnoreProperties({ "messageSupplier", "schemaNode", "instanceNode", "valid", "error" })
@JsonPropertyOrder({ "type", "code", "message", "instanceLocation", "property", "evaluationPath", "schemaLocation",
"messageKey", "arguments", "details" })
@JsonInclude(Include.NON_NULL)
@@ -158,6 +158,11 @@ public Map getDetails() {
return details;
}
+ /**
+ * Gets the formatted error message.
+ *
+ * @return the error message
+ */
public String getMessage() {
return messageSupplier.get();
}
@@ -170,6 +175,28 @@ public boolean isValid() {
return messageSupplier != null;
}
+ /**
+ * Gets the error.
+ *
+ * @return the error
+ */
+ public String getError() {
+ String message = getMessage();
+ int index = message.indexOf(':');
+ if (index != -1) {
+ int length = message.length();
+ while (index + 1 < length) {
+ if (message.charAt(index + 1) == ' ') {
+ index++;
+ } else {
+ break;
+ }
+ }
+ return message.substring(index + 1);
+ }
+ return message;
+ }
+
@Override
public String toString() {
return messageSupplier.get();
diff --git a/src/main/java/com/networknt/schema/ValidationMessageHandler.java b/src/main/java/com/networknt/schema/ValidationMessageHandler.java
index 1183f4ada..c0ca43d34 100644
--- a/src/main/java/com/networknt/schema/ValidationMessageHandler.java
+++ b/src/main/java/com/networknt/schema/ValidationMessageHandler.java
@@ -14,7 +14,7 @@
*/
public abstract class ValidationMessageHandler {
protected final ErrorMessageType errorMessageType;
- protected final boolean customErrorMessagesEnabled;
+ protected final String errorMessageKeyword;
protected final MessageSource messageSource;
protected final Keyword keyword;
protected final JsonSchema parentSchema;
@@ -23,7 +23,7 @@ public abstract class ValidationMessageHandler {
protected final JsonSchema evaluationParentSchema;
protected final Map errorMessage;
- protected ValidationMessageHandler(ErrorMessageType errorMessageType, boolean customErrorMessagesEnabled,
+ protected ValidationMessageHandler(ErrorMessageType errorMessageType, String errorMessageKeyword,
MessageSource messageSource, Keyword keyword, JsonSchema parentSchema, SchemaLocation schemaLocation,
JsonNodePath evaluationPath) {
ErrorMessageType currentErrorMessageType = errorMessageType;
@@ -32,14 +32,15 @@ protected ValidationMessageHandler(ErrorMessageType errorMessageType, boolean cu
this.evaluationPath = Objects.requireNonNull(evaluationPath);
this.parentSchema = parentSchema;
this.evaluationParentSchema = null;
- this.customErrorMessagesEnabled = customErrorMessagesEnabled;
+ this.errorMessageKeyword = errorMessageKeyword;
this.keyword = keyword;
Map currentErrorMessage = null;
if (this.keyword != null) {
- if (this.customErrorMessagesEnabled && keyword != null && parentSchema != null) {
- currentErrorMessage = getErrorMessage(parentSchema.getSchemaNode(), keyword.getValue());
+ if (this.errorMessageKeyword != null && keyword != null && parentSchema != null) {
+ currentErrorMessage = getErrorMessage(this.errorMessageKeyword, parentSchema.getSchemaNode(),
+ keyword.getValue());
}
String errorCodeKey = getErrorCodeKey(keyword.getValue());
if (errorCodeKey != null && this.parentSchema != null) {
@@ -60,7 +61,7 @@ protected ValidationMessageHandler(ErrorMessageType errorMessageType, boolean cu
* Constructor to create a copy using fields.
*
* @param errorMessageType the error message type
- * @param customErrorMessagesEnabled whether custom error msessages are enabled
+ * @param errorMessageKeyword the error message keyword
* @param messageSource the message source
* @param keyword the keyword
* @param parentSchema the parent schema
@@ -69,11 +70,11 @@ protected ValidationMessageHandler(ErrorMessageType errorMessageType, boolean cu
* @param evaluationParentSchema the evaluation parent schema
* @param errorMessage the error message
*/
- protected ValidationMessageHandler(ErrorMessageType errorMessageType, boolean customErrorMessagesEnabled,
+ protected ValidationMessageHandler(ErrorMessageType errorMessageType, String errorMessageKeyword,
MessageSource messageSource, Keyword keyword, JsonSchema parentSchema, SchemaLocation schemaLocation,
JsonNodePath evaluationPath, JsonSchema evaluationParentSchema, Map errorMessage) {
this.errorMessageType = errorMessageType;
- this.customErrorMessagesEnabled = customErrorMessagesEnabled;
+ this.errorMessageKeyword = errorMessageKeyword;
this.messageSource = messageSource;
this.keyword = keyword;
this.parentSchema = parentSchema;
@@ -104,9 +105,9 @@ protected ErrorMessageType getErrorMessageType() {
* @param keyword the keyword
* @return the custom error message
*/
- protected Map getErrorMessage(JsonNode schemaNode, String keyword) {
+ protected Map getErrorMessage(String errorMessageKeyword, JsonNode schemaNode, String keyword) {
final JsonSchema parentSchema = this.parentSchema;
- final JsonNode message = getMessageNode(schemaNode, parentSchema, keyword);
+ final JsonNode message = getMessageNode(errorMessageKeyword, schemaNode, parentSchema, keyword);
if (message != null) {
JsonNode messageNode = message.get(keyword);
if (messageNode != null) {
@@ -126,16 +127,18 @@ protected Map getErrorMessage(JsonNode schemaNode, String keywor
return Collections.emptyMap();
}
- protected JsonNode getMessageNode(JsonNode schemaNode, JsonSchema parentSchema, String pname) {
- if (schemaNode.get("message") != null && schemaNode.get("message").get(pname) != null) {
- return schemaNode.get("message");
+ protected JsonNode getMessageNode(String errorMessageKeyword, JsonNode schemaNode, JsonSchema parentSchema,
+ String pname) {
+ if (schemaNode.get(errorMessageKeyword) != null && schemaNode.get(errorMessageKeyword).get(pname) != null) {
+ return schemaNode.get(errorMessageKeyword);
}
JsonNode messageNode;
- messageNode = schemaNode.get("message");
+ messageNode = schemaNode.get(errorMessageKeyword);
if (messageNode == null && parentSchema != null) {
- messageNode = parentSchema.schemaNode.get("message");
+ messageNode = parentSchema.schemaNode.get(errorMessageKeyword);
if (messageNode == null) {
- return getMessageNode(parentSchema.schemaNode, parentSchema.getParentSchema(), pname);
+ return getMessageNode(errorMessageKeyword, parentSchema.schemaNode, parentSchema.getParentSchema(),
+ pname);
}
}
return messageNode;
diff --git a/src/main/java/com/networknt/schema/output/OutputUnitData.java b/src/main/java/com/networknt/schema/output/OutputUnitData.java
index 7489c8f82..8867f71c2 100644
--- a/src/main/java/com/networknt/schema/output/OutputUnitData.java
+++ b/src/main/java/com/networknt/schema/output/OutputUnitData.java
@@ -57,7 +57,7 @@ public static String formatAssertion(ValidationMessage validationMessage) {
}
public static String formatMessage(String message) {
- int index = message.indexOf(":");
+ int index = message.indexOf(':');
if (index != -1) {
int length = message.length();
while (index + 1 < length) {
diff --git a/src/main/java/com/networknt/schema/utils/JsonNodeUtil.java b/src/main/java/com/networknt/schema/utils/JsonNodeUtil.java
index 793856e95..07c3b9151 100644
--- a/src/main/java/com/networknt/schema/utils/JsonNodeUtil.java
+++ b/src/main/java/com/networknt/schema/utils/JsonNodeUtil.java
@@ -63,7 +63,7 @@ public static boolean isNodeNullable(JsonNode schema){
//Check to see if a JsonNode is nullable with checking the isHandleNullableField
public static boolean isNodeNullable(JsonNode schema, SchemaValidatorsConfig config){
// check if the parent schema declares the fields as nullable
- if (config.isHandleNullableField()) {
+ if (config.isNullableKeywordEnabled()) {
return isNodeNullable(schema);
}
return false;
diff --git a/src/test/java/com/networknt/schema/AbstractJsonSchemaTestSuite.java b/src/test/java/com/networknt/schema/AbstractJsonSchemaTestSuite.java
index cc066e93b..2b0577f54 100644
--- a/src/test/java/com/networknt/schema/AbstractJsonSchemaTestSuite.java
+++ b/src/test/java/com/networknt/schema/AbstractJsonSchemaTestSuite.java
@@ -200,27 +200,27 @@ private DynamicNode buildTest(JsonSchemaFactory validatorFactory, TestSpec testS
// if test file do not contains typeLoose flag, use default value: false.
@SuppressWarnings("deprecation") boolean typeLoose = testSpec.isTypeLoose();
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setTypeLoose(typeLoose);
- config.setRegularExpressionFactory(
+ SchemaValidatorsConfig.Builder configBuilder = SchemaValidatorsConfig.builder();
+ configBuilder.typeLoose(typeLoose);
+ configBuilder.regularExpressionFactory(
TestSpec.RegexKind.JDK == testSpec.getRegex() ? JDKRegularExpressionFactory.getInstance()
: JoniRegularExpressionFactory.getInstance());
- testSpec.getStrictness().forEach(config::setStrict);
+ testSpec.getStrictness().forEach(configBuilder::strict);
if (testSpec.getConfig() != null) {
if (testSpec.getConfig().containsKey("isCustomMessageSupported")) {
- config.setCustomMessageSupported((Boolean) testSpec.getConfig().get("isCustomMessageSupported"));
+ configBuilder.errorMessageKeyword(
+ (Boolean) testSpec.getConfig().get("isCustomMessageSupported") ? "message" : null);
}
if (testSpec.getConfig().containsKey("readOnly")) {
- config.setReadOnly((Boolean) testSpec.getConfig().get("readOnly"));
+ configBuilder.readOnly((Boolean) testSpec.getConfig().get("readOnly"));
}
if (testSpec.getConfig().containsKey("writeOnly")) {
- config.setWriteOnly((Boolean) testSpec.getConfig().get("writeOnly"));
+ configBuilder.writeOnly((Boolean) testSpec.getConfig().get("writeOnly"));
}
}
-
SchemaLocation testCaseFileUri = SchemaLocation.of("classpath:" + toForwardSlashPath(testSpec.getTestCase().getSpecification()));
- JsonSchema schema = validatorFactory.getSchema(testCaseFileUri, testSpec.getTestCase().getSchema(), config);
+ JsonSchema schema = validatorFactory.getSchema(testCaseFileUri, testSpec.getTestCase().getSchema(), configBuilder.build());
return dynamicTest(testSpec.getDescription(), () -> executeAndReset(schema, testSpec));
}
diff --git a/src/test/java/com/networknt/schema/AdditionalPropertiesValidatorTest.java b/src/test/java/com/networknt/schema/AdditionalPropertiesValidatorTest.java
index c133d83af..0bb20407f 100644
--- a/src/test/java/com/networknt/schema/AdditionalPropertiesValidatorTest.java
+++ b/src/test/java/com/networknt/schema/AdditionalPropertiesValidatorTest.java
@@ -46,8 +46,7 @@ void messageFalse() {
+ " \"additionalProperties\": false\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "{\r\n"
+ " \"foo\":\"hello\",\r\n"
@@ -82,8 +81,7 @@ void messageSchema() {
+ " \"additionalProperties\": { \"type\": \"number\" }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "{\r\n"
+ " \"foo\":\"hello\",\r\n"
diff --git a/src/test/java/com/networknt/schema/CollectorContextTest.java b/src/test/java/com/networknt/schema/CollectorContextTest.java
index dae6baf40..a91eb5f74 100644
--- a/src/test/java/com/networknt/schema/CollectorContextTest.java
+++ b/src/test/java/com/networknt/schema/CollectorContextTest.java
@@ -154,7 +154,7 @@ private void setupSchema() throws Exception {
final JsonSchemaFactory schemaFactory = JsonSchemaFactory
.builder(JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V201909)).metaSchema(metaSchema)
.build();
- SchemaValidatorsConfig schemaValidatorsConfig = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder().build();
this.jsonSchema = schemaFactory.getSchema(getSchemaString(), schemaValidatorsConfig);
this.jsonSchemaForCombine = schemaFactory.getSchema(getSchemaStringMultipleProperties(), schemaValidatorsConfig);
}
diff --git a/src/test/java/com/networknt/schema/ConstValidatorTest.java b/src/test/java/com/networknt/schema/ConstValidatorTest.java
index 0d22c2d70..f412fd722 100644
--- a/src/test/java/com/networknt/schema/ConstValidatorTest.java
+++ b/src/test/java/com/networknt/schema/ConstValidatorTest.java
@@ -36,12 +36,13 @@ void localeMessageOthers() {
String schemaData = "{\r\n"
+ " \"const\": \"aa\"\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setMessageSource(new ResourceBundleMessageSource("const-messages-override", "jsv-messages"));
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .messageSource(new ResourceBundleMessageSource("const-messages-override", "jsv-messages"))
+ .build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
String inputData = "\"bb\"";
Set messages = schema.validate(inputData, InputFormat.JSON);
- assertEquals("$: must be the constant value 'aa' but is 'bb'", messages.iterator().next().getMessage());
+ assertEquals(": must be the constant value 'aa' but is 'bb'", messages.iterator().next().getMessage());
}
@Test
@@ -49,12 +50,13 @@ void localeMessageNumber() {
String schemaData = "{\r\n"
+ " \"const\": 1\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setMessageSource(new ResourceBundleMessageSource("const-messages-override", "jsv-messages"));
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .messageSource(new ResourceBundleMessageSource("const-messages-override", "jsv-messages"))
+ .build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
String inputData = "2";
Set messages = schema.validate(inputData, InputFormat.JSON);
- assertEquals("$: must be the constant value '1' but is '2'", messages.iterator().next().getMessage());
+ assertEquals(": must be the constant value '1' but is '2'", messages.iterator().next().getMessage());
}
@Test
@@ -62,7 +64,7 @@ void validOthers() {
String schemaData = "{\r\n"
+ " \"const\": \"aa\"\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
String inputData = "\"aa\"";
Set messages = schema.validate(inputData, InputFormat.JSON);
@@ -74,7 +76,7 @@ void validNumber() {
String schemaData = "{\r\n"
+ " \"const\": 1234.56789\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
String inputData = "1234.56789";
Set messages = schema.validate(inputData, InputFormat.JSON);
@@ -86,7 +88,7 @@ void invalidNumber() {
String schemaData = "{\r\n"
+ " \"const\": 1234.56789\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
String inputData = "\"1234.56789\"";
Set messages = schema.validate(inputData, InputFormat.JSON);
diff --git a/src/test/java/com/networknt/schema/ContentSchemaValidatorTest.java b/src/test/java/com/networknt/schema/ContentSchemaValidatorTest.java
index d5f4607b2..187f51a9b 100644
--- a/src/test/java/com/networknt/schema/ContentSchemaValidatorTest.java
+++ b/src/test/java/com/networknt/schema/ContentSchemaValidatorTest.java
@@ -55,8 +55,7 @@ void annotationCollection() throws JsonProcessingException {
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "\"helloworld\"";
diff --git a/src/test/java/com/networknt/schema/CyclicDependencyTest.java b/src/test/java/com/networknt/schema/CyclicDependencyTest.java
index 8dd294d67..5b6a356db 100644
--- a/src/test/java/com/networknt/schema/CyclicDependencyTest.java
+++ b/src/test/java/com/networknt/schema/CyclicDependencyTest.java
@@ -32,7 +32,7 @@ public void whenDependencyBetweenSchemaThenValidationSuccessful() throws Excepti
" ]\n" +
"}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = schemaFactory.getSchema(SchemaLocation.of("resource:/draft4/issue258/Master.json"), config);
assertEquals(0, schema.validate(new ObjectMapper().readTree(jsonObject)).size());
}
diff --git a/src/test/java/com/networknt/schema/DefaultJsonSchemaIdValidatorTest.java b/src/test/java/com/networknt/schema/DefaultJsonSchemaIdValidatorTest.java
index f8dc64dd9..43b56ecfb 100644
--- a/src/test/java/com/networknt/schema/DefaultJsonSchemaIdValidatorTest.java
+++ b/src/test/java/com/networknt/schema/DefaultJsonSchemaIdValidatorTest.java
@@ -31,8 +31,9 @@ public class DefaultJsonSchemaIdValidatorTest {
void givenRelativeIdShouldThrowInvalidSchemaException() {
String schema = "{\r\n" + " \"$id\": \"0\",\r\n"
+ " \"$schema\": \"https://json-schema.org/draft/2020-12/schema\"\r\n" + "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setSchemaIdValidator(JsonSchemaIdValidator.DEFAULT);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .schemaIdValidator(JsonSchemaIdValidator.DEFAULT)
+ .build();
assertThrowsExactly(InvalidSchemaException.class,
() -> JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schema, config));
try {
@@ -46,8 +47,9 @@ void givenRelativeIdShouldThrowInvalidSchemaException() {
void givenFragmentWithNoContextShouldNotThrowInvalidSchemaException() {
String schema = "{\r\n" + " \"$id\": \"#0\",\r\n"
+ " \"$schema\": \"https://json-schema.org/draft/2020-12/schema\"\r\n" + "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setSchemaIdValidator(JsonSchemaIdValidator.DEFAULT);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .schemaIdValidator(JsonSchemaIdValidator.DEFAULT)
+ .build();
assertDoesNotThrow(() -> JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schema, config));
}
@@ -55,15 +57,17 @@ void givenFragmentWithNoContextShouldNotThrowInvalidSchemaException() {
void givenSlashWithNoContextShouldNotThrowInvalidSchemaException() {
String schema = "{\r\n" + " \"$id\": \"/base\",\r\n"
+ " \"$schema\": \"https://json-schema.org/draft/2020-12/schema\"\r\n" + "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setSchemaIdValidator(JsonSchemaIdValidator.DEFAULT);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .schemaIdValidator(JsonSchemaIdValidator.DEFAULT)
+ .build();
assertDoesNotThrow(() -> JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schema, config));
}
@Test
void givenRelativeIdWithClasspathBaseShouldNotThrowInvalidSchemaException() {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setSchemaIdValidator(JsonSchemaIdValidator.DEFAULT);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .schemaIdValidator(JsonSchemaIdValidator.DEFAULT)
+ .build();
assertDoesNotThrow(() -> JsonSchemaFactory.getInstance(VersionFlag.V202012)
.getSchema(SchemaLocation.of("classpath:schema/id-relative.json"), config));
}
diff --git a/src/test/java/com/networknt/schema/DiscriminatorValidatorTest.java b/src/test/java/com/networknt/schema/DiscriminatorValidatorTest.java
index eb2f92fa8..816aaf0ae 100644
--- a/src/test/java/com/networknt/schema/DiscriminatorValidatorTest.java
+++ b/src/test/java/com/networknt/schema/DiscriminatorValidatorTest.java
@@ -117,8 +117,7 @@ void discriminatorInArray() {
+ "]";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setOpenAPI3StyleDiscriminators(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().discriminatorKeywordEnabled(true).build();
JsonSchema schema = factory.getSchema(schemaData, config);
Set messages = schema.validate(inputData, InputFormat.JSON);
assertTrue(messages.isEmpty());
@@ -150,8 +149,7 @@ void anyOfWithConfigEnabledButNoDiscriminator() {
+ " }";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setOpenAPI3StyleDiscriminators(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().discriminatorKeywordEnabled(true).build();
JsonSchema schema = factory.getSchema(schemaData, config);
Set messages = schema.validate(inputData, InputFormat.JSON);
assertTrue(messages.isEmpty());
@@ -244,8 +242,7 @@ void discriminatorInArrayInvalidDiscriminatorPropertyAnyOf() {
+ "]";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setOpenAPI3StyleDiscriminators(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().discriminatorKeywordEnabled(true).build();
JsonSchema schema = factory.getSchema(schemaData, config);
Set messages = schema.validate(inputData, InputFormat.JSON);
assertEquals(1, messages.size());
@@ -338,8 +335,7 @@ void discriminatorInArrayInvalidDiscriminatorPropertyOneOf() {
+ "]";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setOpenAPI3StyleDiscriminators(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().discriminatorKeywordEnabled(true).build();
JsonSchema schema = factory.getSchema(schemaData, config);
Set messages = schema.validate(inputData, InputFormat.JSON);
assertEquals(1, messages.size());
@@ -429,8 +425,7 @@ void discriminatorInArrayOneOfShouldOnlyReportErrorsInMatchingDiscriminator() {
+ "]";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setOpenAPI3StyleDiscriminators(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().discriminatorKeywordEnabled(true).build();
JsonSchema schema = factory.getSchema(schemaData, config);
Set messages = schema.validate(inputData, InputFormat.JSON);
// Only the oneOf and the error in the BedRoom discriminator is reported
@@ -526,8 +521,7 @@ void discriminatorInOneOfShouldOnlyReportErrorsInMatchingDiscriminator() {
+ "]";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setOpenAPI3StyleDiscriminators(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().discriminatorKeywordEnabled(true).build();
JsonSchema schema = factory.getSchema(schemaData, config);
Set messages = schema.validate(inputData, InputFormat.JSON);
// Only the oneOf and the error in the BedRoom discriminator is reported
@@ -627,8 +621,7 @@ void discriminatorMappingInOneOfShouldOnlyReportErrorsInMatchingDiscriminator()
+ "]";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setOpenAPI3StyleDiscriminators(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().discriminatorKeywordEnabled(true).build();
JsonSchema schema = factory.getSchema(schemaData, config);
Set messages = schema.validate(inputData, InputFormat.JSON);
// Only the oneOf and the error in the BedRoom discriminator is reported
@@ -683,8 +676,7 @@ void oneOfMissingDiscriminatorValue() {
String inputData = "{}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setOpenAPI3StyleDiscriminators(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().discriminatorKeywordEnabled(true).build();
JsonSchema schema = factory.getSchema(schemaData, config);
Set messages = schema.validate(inputData, InputFormat.JSON);
assertEquals(3, messages.size());
@@ -780,8 +772,7 @@ void anyOfMissingDiscriminatorValue() {
+ "]";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setOpenAPI3StyleDiscriminators(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().discriminatorKeywordEnabled(true).build();
JsonSchema schema = factory.getSchema(schemaData, config);
Set messages = schema.validate(inputData, InputFormat.JSON);
List list = messages.stream().collect(Collectors.toList());
diff --git a/src/test/java/com/networknt/schema/ExampleTest.java b/src/test/java/com/networknt/schema/ExampleTest.java
index ca3650d57..17c9925e8 100644
--- a/src/test/java/com/networknt/schema/ExampleTest.java
+++ b/src/test/java/com/networknt/schema/ExampleTest.java
@@ -30,8 +30,7 @@ public void exampleSchemaLocation() throws Exception {
JsonSchemaFactory jsonSchemaFactory = JsonSchemaFactory.getInstance(VersionFlag.V202012, builder ->
builder.schemaMappers(schemaMappers -> schemaMappers.mapPrefix("https://www.example.org/", "classpath:schema/"))
);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = jsonSchemaFactory.getSchema(SchemaLocation.of("https://www.example.org/example-main.json"), config);
String input = "{\r\n"
+ " \"DriverProperties\": {\r\n"
@@ -54,8 +53,7 @@ public void exampleSchemaLocation() throws Exception {
public void exampleClasspath() throws Exception {
// This creates a schema factory that will use Draft 2012-12 as the default if $schema is not specified in the initial schema
JsonSchemaFactory jsonSchemaFactory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = jsonSchemaFactory.getSchema(SchemaLocation.of("classpath:schema/example-main.json"), config);
String input = "{\r\n"
+ " \"DriverProperties\": {\r\n"
diff --git a/src/test/java/com/networknt/schema/FormatValidatorTest.java b/src/test/java/com/networknt/schema/FormatValidatorTest.java
index 2d0ec9ba3..25e4e8856 100644
--- a/src/test/java/com/networknt/schema/FormatValidatorTest.java
+++ b/src/test/java/com/networknt/schema/FormatValidatorTest.java
@@ -53,8 +53,7 @@ void unknownFormatNoVocabStrictTrue() {
String schemaData = "{\r\n"
+ " \"format\":\"unknown\"\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setStrict("format", true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().strict("format", true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set messages = schema.validate("\"hello\"", InputFormat.JSON, executionContext -> {
executionContext.getExecutionConfig().setFormatAssertionsEnabled(true);
@@ -83,7 +82,7 @@ void unknownFormatAssertionsVocab() {
+ " \"$schema\": \"https://www.example.com/format-assertion/schema\",\r\n"
+ " \"format\":\"unknown\"\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = JsonSchemaFactory
.getInstance(VersionFlag.V202012,
builder -> builder
@@ -143,8 +142,7 @@ void formatAssertions(FormatInput formatInput) {
+ " \"format\": \""+formatInput.format+"\"\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(formatSchema, config);
Set messages = schema.validate("\"inval!i:d^(abc]\"", InputFormat.JSON, executionConfiguration -> {
executionConfiguration.getExecutionConfig().setFormatAssertionsEnabled(true);
@@ -173,8 +171,7 @@ void patternFormatDeprecated() {
+ " \"type\": \"string\",\r\n"
+ " \"format\": \"custom\"\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(formatSchema, config);
Set messages = schema.validate("\"inval!i:d^(abc]\"", InputFormat.JSON, executionConfiguration -> {
executionConfiguration.getExecutionConfig().setFormatAssertionsEnabled(true);
@@ -223,8 +220,7 @@ void shouldAllowNumberFormat() {
+ " \"type\": \"number\",\r\n"
+ " \"format\": \"custom-number\"\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(formatSchema, config);
Set messages = schema.validate("123451", InputFormat.JSON, executionConfiguration -> {
executionConfiguration.getExecutionConfig().setFormatAssertionsEnabled(true);
diff --git a/src/test/java/com/networknt/schema/IfValidatorTest.java b/src/test/java/com/networknt/schema/IfValidatorTest.java
index 511fee0fc..6b6f1dcec 100644
--- a/src/test/java/com/networknt/schema/IfValidatorTest.java
+++ b/src/test/java/com/networknt/schema/IfValidatorTest.java
@@ -49,25 +49,24 @@ void walkValidateThen() {
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addKeywordWalkListener(ValidatorTypeCode.TYPE.getValue(), new JsonSchemaWalkListener() {
-
- @Override
- public WalkFlow onWalkStart(WalkEvent walkEvent) {
- return WalkFlow.CONTINUE;
- }
-
- @Override
- public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
- @SuppressWarnings("unchecked")
- List types = (List) walkEvent.getExecutionContext()
- .getCollectorContext()
- .getCollectorMap()
- .computeIfAbsent("types", key -> new ArrayList());
- types.add(walkEvent);
- }
- });
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .keywordWalkListener(ValidatorTypeCode.TYPE.getValue(), new JsonSchemaWalkListener() {
+ @Override
+ public WalkFlow onWalkStart(WalkEvent walkEvent) {
+ return WalkFlow.CONTINUE;
+ }
+
+ @Override
+ public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
+ @SuppressWarnings("unchecked")
+ List types = (List) walkEvent.getExecutionContext()
+ .getCollectorContext()
+ .getCollectorMap()
+ .computeIfAbsent("types", key -> new ArrayList());
+ types.add(walkEvent);
+ }
+ })
+ .build();
JsonSchema schema = factory.getSchema(schemaData, config);
ValidationResult result = schema.walk("\"false\"", InputFormat.JSON, true);
assertFalse(result.getValidationMessages().isEmpty());
@@ -93,25 +92,24 @@ void walkValidateElse() {
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addKeywordWalkListener(ValidatorTypeCode.TYPE.getValue(), new JsonSchemaWalkListener() {
-
- @Override
- public WalkFlow onWalkStart(WalkEvent walkEvent) {
- return WalkFlow.CONTINUE;
- }
-
- @Override
- public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
- @SuppressWarnings("unchecked")
- List types = (List) walkEvent.getExecutionContext()
- .getCollectorContext()
- .getCollectorMap()
- .computeIfAbsent("types", key -> new ArrayList());
- types.add(walkEvent);
- }
- });
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .keywordWalkListener(ValidatorTypeCode.TYPE.getValue(), new JsonSchemaWalkListener() {
+ @Override
+ public WalkFlow onWalkStart(WalkEvent walkEvent) {
+ return WalkFlow.CONTINUE;
+ }
+
+ @Override
+ public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
+ @SuppressWarnings("unchecked")
+ List types = (List) walkEvent.getExecutionContext()
+ .getCollectorContext()
+ .getCollectorMap()
+ .computeIfAbsent("types", key -> new ArrayList());
+ types.add(walkEvent);
+ }
+ })
+ .build();
JsonSchema schema = factory.getSchema(schemaData, config);
ValidationResult result = schema.walk("\"hello\"", InputFormat.JSON, true);
assertFalse(result.getValidationMessages().isEmpty());
@@ -137,25 +135,24 @@ void walkValidateNull() {
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addKeywordWalkListener(ValidatorTypeCode.TYPE.getValue(), new JsonSchemaWalkListener() {
-
- @Override
- public WalkFlow onWalkStart(WalkEvent walkEvent) {
- return WalkFlow.CONTINUE;
- }
-
- @Override
- public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
- @SuppressWarnings("unchecked")
- List types = (List) walkEvent.getExecutionContext()
- .getCollectorContext()
- .getCollectorMap()
- .computeIfAbsent("types", key -> new ArrayList());
- types.add(walkEvent);
- }
- });
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .keywordWalkListener(ValidatorTypeCode.TYPE.getValue(), new JsonSchemaWalkListener() {
+ @Override
+ public WalkFlow onWalkStart(WalkEvent walkEvent) {
+ return WalkFlow.CONTINUE;
+ }
+
+ @Override
+ public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
+ @SuppressWarnings("unchecked")
+ List types = (List) walkEvent.getExecutionContext()
+ .getCollectorContext()
+ .getCollectorMap()
+ .computeIfAbsent("types", key -> new ArrayList());
+ types.add(walkEvent);
+ }
+ })
+ .build();
JsonSchema schema = factory.getSchema(schemaData, config);
ValidationResult result = schema.walk(null, true);
assertTrue(result.getValidationMessages().isEmpty());
@@ -179,25 +176,24 @@ void walkNoValidate() {
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addKeywordWalkListener(ValidatorTypeCode.TYPE.getValue(), new JsonSchemaWalkListener() {
-
- @Override
- public WalkFlow onWalkStart(WalkEvent walkEvent) {
- return WalkFlow.CONTINUE;
- }
-
- @Override
- public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
- @SuppressWarnings("unchecked")
- List types = (List) walkEvent.getExecutionContext()
- .getCollectorContext()
- .getCollectorMap()
- .computeIfAbsent("types", key -> new ArrayList());
- types.add(walkEvent);
- }
- });
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .keywordWalkListener(ValidatorTypeCode.TYPE.getValue(), new JsonSchemaWalkListener() {
+ @Override
+ public WalkFlow onWalkStart(WalkEvent walkEvent) {
+ return WalkFlow.CONTINUE;
+ }
+
+ @Override
+ public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
+ @SuppressWarnings("unchecked")
+ List types = (List) walkEvent.getExecutionContext()
+ .getCollectorContext()
+ .getCollectorMap()
+ .computeIfAbsent("types", key -> new ArrayList());
+ types.add(walkEvent);
+ }
+ })
+ .build();
JsonSchema schema = factory.getSchema(schemaData, config);
ValidationResult result = schema.walk("\"false\"", InputFormat.JSON, false);
assertTrue(result.getValidationMessages().isEmpty());
diff --git a/src/test/java/com/networknt/schema/Issue366FailFastTest.java b/src/test/java/com/networknt/schema/Issue366FailFastTest.java
index a863ecff9..0bd37e036 100644
--- a/src/test/java/com/networknt/schema/Issue366FailFastTest.java
+++ b/src/test/java/com/networknt/schema/Issue366FailFastTest.java
@@ -23,14 +23,12 @@ public void setup() throws IOException {
ObjectMapper objectMapper = new ObjectMapper();
private void setupSchema() throws IOException {
-
- SchemaValidatorsConfig schemaValidatorsConfig = new SchemaValidatorsConfig();
- schemaValidatorsConfig.setFailFast(true);
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder()
+ .failFast(true)
+ .typeLoose(false)
+ .build();
JsonSchemaFactory schemaFactory = JsonSchemaFactory
.builder(JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7)).build();
-
- schemaValidatorsConfig.setTypeLoose(false);
-
SchemaLocation uri = getSchema();
InputStream in = getClass().getResourceAsStream("/schema/issue366_schema.json");
diff --git a/src/test/java/com/networknt/schema/Issue366FailSlowTest.java b/src/test/java/com/networknt/schema/Issue366FailSlowTest.java
index 38f25a7cb..862591cb2 100644
--- a/src/test/java/com/networknt/schema/Issue366FailSlowTest.java
+++ b/src/test/java/com/networknt/schema/Issue366FailSlowTest.java
@@ -14,90 +14,89 @@
public class Issue366FailSlowTest {
- @BeforeEach
- public void setup() throws IOException {
- setupSchema();
- }
-
- JsonSchema jsonSchema;
- ObjectMapper objectMapper = new ObjectMapper();
- private void setupSchema() throws IOException {
-
- SchemaValidatorsConfig schemaValidatorsConfig = new SchemaValidatorsConfig();
- JsonSchemaFactory schemaFactory = JsonSchemaFactory
- .builder(JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7))
- .build();
-
- schemaValidatorsConfig.setTypeLoose(false);
-
- SchemaLocation uri = getSchema();
-
- InputStream in = getClass().getResourceAsStream("/schema/issue366_schema.json");
- JsonNode testCases = objectMapper.readValue(in, JsonNode.class);
- this.jsonSchema = schemaFactory.getSchema(uri, testCases,schemaValidatorsConfig);
- }
-
- protected JsonNode getJsonNodeFromStreamContent(InputStream content) throws Exception {
- ObjectMapper mapper = new ObjectMapper();
- JsonNode node = mapper.readTree(content);
- return node;
- }
-
- @Test
- public void firstOneValid() throws Exception {
- String dataPath = "/data/issue366.json";
-
- InputStream dataInputStream = getClass().getResourceAsStream(dataPath);
- JsonNode node = getJsonNodeFromStreamContent(dataInputStream);
- List testNodes = node.findValues("tests");
- JsonNode testNode = testNodes.get(0).get(0);
- JsonNode dataNode = testNode.get("data");
- Set errors = jsonSchema.validate(dataNode);
- assertTrue(errors.isEmpty());
- }
-
- @Test
- public void secondOneValid() throws Exception {
- String dataPath = "/data/issue366.json";
-
- InputStream dataInputStream = getClass().getResourceAsStream(dataPath);
- JsonNode node = getJsonNodeFromStreamContent(dataInputStream);
- List testNodes = node.findValues("tests");
- JsonNode testNode = testNodes.get(0).get(1);
- JsonNode dataNode = testNode.get("data");
- Set errors = jsonSchema.validate(dataNode);
- assertTrue(errors.isEmpty());
- }
-
- @Test
- public void bothValid() throws Exception {
- String dataPath = "/data/issue366.json";
-
- InputStream dataInputStream = getClass().getResourceAsStream(dataPath);
- JsonNode node = getJsonNodeFromStreamContent(dataInputStream);
- List testNodes = node.findValues("tests");
- JsonNode testNode = testNodes.get(0).get(2);
- JsonNode dataNode = testNode.get("data");
- Set errors = jsonSchema.validate(dataNode);
- assertTrue(!errors.isEmpty());
- assertEquals(errors.size(),1);
- }
-
- @Test
- public void neitherValid() throws Exception {
- String dataPath = "/data/issue366.json";
-
- InputStream dataInputStream = getClass().getResourceAsStream(dataPath);
- JsonNode node = getJsonNodeFromStreamContent(dataInputStream);
- List testNodes = node.findValues("tests");
- JsonNode testNode = testNodes.get(0).get(3);
- JsonNode dataNode = testNode.get("data");
- Set errors = jsonSchema.validate(dataNode);
- assertTrue(!errors.isEmpty());
- assertEquals(errors.size(),3);
- }
-
- private SchemaLocation getSchema() {
- return SchemaLocation.of("classpath:" + "/draft7/issue366_schema.json");
- }
+ @BeforeEach
+ public void setup() throws IOException {
+ setupSchema();
+ }
+
+ JsonSchema jsonSchema;
+ ObjectMapper objectMapper = new ObjectMapper();
+
+ private void setupSchema() throws IOException {
+
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder().typeLoose(false).build();
+ JsonSchemaFactory schemaFactory = JsonSchemaFactory
+ .builder(JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7))
+ .build();
+
+ SchemaLocation uri = getSchema();
+
+ InputStream in = getClass().getResourceAsStream("/schema/issue366_schema.json");
+ JsonNode testCases = objectMapper.readValue(in, JsonNode.class);
+ this.jsonSchema = schemaFactory.getSchema(uri, testCases, schemaValidatorsConfig);
+ }
+
+ protected JsonNode getJsonNodeFromStreamContent(InputStream content) throws Exception {
+ ObjectMapper mapper = new ObjectMapper();
+ JsonNode node = mapper.readTree(content);
+ return node;
+ }
+
+ @Test
+ public void firstOneValid() throws Exception {
+ String dataPath = "/data/issue366.json";
+
+ InputStream dataInputStream = getClass().getResourceAsStream(dataPath);
+ JsonNode node = getJsonNodeFromStreamContent(dataInputStream);
+ List testNodes = node.findValues("tests");
+ JsonNode testNode = testNodes.get(0).get(0);
+ JsonNode dataNode = testNode.get("data");
+ Set errors = jsonSchema.validate(dataNode);
+ assertTrue(errors.isEmpty());
+ }
+
+ @Test
+ public void secondOneValid() throws Exception {
+ String dataPath = "/data/issue366.json";
+
+ InputStream dataInputStream = getClass().getResourceAsStream(dataPath);
+ JsonNode node = getJsonNodeFromStreamContent(dataInputStream);
+ List testNodes = node.findValues("tests");
+ JsonNode testNode = testNodes.get(0).get(1);
+ JsonNode dataNode = testNode.get("data");
+ Set errors = jsonSchema.validate(dataNode);
+ assertTrue(errors.isEmpty());
+ }
+
+ @Test
+ public void bothValid() throws Exception {
+ String dataPath = "/data/issue366.json";
+
+ InputStream dataInputStream = getClass().getResourceAsStream(dataPath);
+ JsonNode node = getJsonNodeFromStreamContent(dataInputStream);
+ List testNodes = node.findValues("tests");
+ JsonNode testNode = testNodes.get(0).get(2);
+ JsonNode dataNode = testNode.get("data");
+ Set errors = jsonSchema.validate(dataNode);
+ assertTrue(!errors.isEmpty());
+ assertEquals(errors.size(), 1);
+ }
+
+ @Test
+ public void neitherValid() throws Exception {
+ String dataPath = "/data/issue366.json";
+
+ InputStream dataInputStream = getClass().getResourceAsStream(dataPath);
+ JsonNode node = getJsonNodeFromStreamContent(dataInputStream);
+ List testNodes = node.findValues("tests");
+ JsonNode testNode = testNodes.get(0).get(3);
+ JsonNode dataNode = testNode.get("data");
+ Set errors = jsonSchema.validate(dataNode);
+ assertTrue(!errors.isEmpty());
+ assertEquals(errors.size(), 3);
+ }
+
+ private SchemaLocation getSchema() {
+ return SchemaLocation.of("classpath:" + "/draft7/issue366_schema.json");
+ }
}
diff --git a/src/test/java/com/networknt/schema/Issue428Test.java b/src/test/java/com/networknt/schema/Issue428Test.java
index 5785cec79..03f2eac00 100644
--- a/src/test/java/com/networknt/schema/Issue428Test.java
+++ b/src/test/java/com/networknt/schema/Issue428Test.java
@@ -26,7 +26,6 @@ private void runTestFile(String testCaseFile) throws Exception {
for (int j = 0; j < testCases.size(); j++) {
try {
JsonNode testCase = testCases.get(j);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
ArrayNode testNodes = (ArrayNode) testCase.get("tests");
for (int i = 0; i < testNodes.size(); i++) {
@@ -36,9 +35,10 @@ private void runTestFile(String testCaseFile) throws Exception {
JsonNode typeLooseNode = test.get("isTypeLoose");
// Configure the schemaValidator to set typeLoose's value based on the test file,
// if test file do not contains typeLoose flag, use default value: true.
- config.setTypeLoose(typeLooseNode != null && typeLooseNode.asBoolean());
- config.setOpenAPI3StyleDiscriminators(false);
- JsonSchema schema = validatorFactory.getSchema(testCaseFileUri, testCase.get("schema"), config);
+ SchemaValidatorsConfig.Builder configBuilder = SchemaValidatorsConfig.builder();
+ configBuilder.typeLoose(typeLooseNode != null && typeLooseNode.asBoolean());
+ configBuilder.discriminatorKeywordEnabled(false);
+ JsonSchema schema = validatorFactory.getSchema(testCaseFileUri, testCase.get("schema"), configBuilder.build());
List errors = new ArrayList(schema.validate(node));
diff --git a/src/test/java/com/networknt/schema/Issue451Test.java b/src/test/java/com/networknt/schema/Issue451Test.java
index 53a829e50..760e51d6f 100644
--- a/src/test/java/com/networknt/schema/Issue451Test.java
+++ b/src/test/java/com/networknt/schema/Issue451Test.java
@@ -22,8 +22,9 @@ public class Issue451Test {
protected JsonSchema getJsonSchemaFromStreamContentV7(InputStream schemaContent) {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7);
- SchemaValidatorsConfig svc = new SchemaValidatorsConfig();
- svc.addPropertyWalkListener(new CountingWalker());
+ SchemaValidatorsConfig svc = SchemaValidatorsConfig.builder()
+ .propertyWalkListener(new CountingWalker())
+ .build();
return factory.getSchema(schemaContent, svc);
}
diff --git a/src/test/java/com/networknt/schema/Issue461Test.java b/src/test/java/com/networknt/schema/Issue461Test.java
index 239f61739..a3d06c550 100644
--- a/src/test/java/com/networknt/schema/Issue461Test.java
+++ b/src/test/java/com/networknt/schema/Issue461Test.java
@@ -2,6 +2,7 @@
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
+import com.networknt.schema.serialization.JsonMapperFactory;
import com.networknt.schema.walk.JsonSchemaWalkListener;
import com.networknt.schema.walk.WalkEvent;
import com.networknt.schema.walk.WalkFlow;
@@ -13,12 +14,13 @@
import java.util.Set;
public class Issue461Test {
- protected ObjectMapper mapper = new ObjectMapper();
+ protected ObjectMapper mapper = JsonMapperFactory.getInstance();
protected JsonSchema getJsonSchemaFromStreamContentV7(SchemaLocation schemaUri) {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7);
- SchemaValidatorsConfig svc = new SchemaValidatorsConfig();
- svc.addKeywordWalkListener(ValidatorTypeCode.PROPERTIES.getValue(), new Walker());
+ SchemaValidatorsConfig svc = SchemaValidatorsConfig.builder()
+ .keywordWalkListener(ValidatorTypeCode.PROPERTIES.getValue(), new Walker())
+ .build();
return factory.getSchema(schemaUri, svc);
}
diff --git a/src/test/java/com/networknt/schema/Issue467Test.java b/src/test/java/com/networknt/schema/Issue467Test.java
index ad8bb14fe..d5aa396f3 100644
--- a/src/test/java/com/networknt/schema/Issue467Test.java
+++ b/src/test/java/com/networknt/schema/Issue467Test.java
@@ -44,22 +44,23 @@ public class Issue467Test {
public void shouldWalkKeywordWithValidation() throws URISyntaxException, IOException {
InputStream schemaInputStream = Issue467Test.class.getResourceAsStream(schemaPath);
final Set properties = new LinkedHashSet<>();
- final SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.addKeywordWalkListener(ValidatorTypeCode.PROPERTIES.getValue(), new JsonSchemaWalkListener() {
- @Override
- public WalkFlow onWalkStart(WalkEvent walkEvent) {
- properties.add(walkEvent.getSchema().getEvaluationPath().append(walkEvent.getKeyword()));
- return WalkFlow.CONTINUE;
- }
+ final SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .keywordWalkListener(ValidatorTypeCode.PROPERTIES.getValue(), new JsonSchemaWalkListener() {
+ @Override
+ public WalkFlow onWalkStart(WalkEvent walkEvent) {
+ properties.add(walkEvent.getSchema().getEvaluationPath().append(walkEvent.getKeyword()));
+ return WalkFlow.CONTINUE;
+ }
- @Override
- public void onWalkEnd(WalkEvent walkEvent, Set set) {
- }
- });
+ @Override
+ public void onWalkEnd(WalkEvent walkEvent, Set set) {
+ }
+ })
+ .build();
JsonSchema schema = factory.getSchema(schemaInputStream, config);
JsonNode data = mapper.readTree(Issue467Test.class.getResource("/data/issue467.json"));
ValidationResult result = schema.walk(data, true);
- assertEquals(new HashSet<>(Arrays.asList("$.properties", "$.properties.tags.items[0].properties")),
+ assertEquals(new HashSet<>(Arrays.asList("/properties", "/properties/tags/items/0/properties")),
properties.stream().map(Object::toString).collect(Collectors.toSet()));
assertEquals(1, result.getValidationMessages().size());
}
@@ -68,23 +69,24 @@ public void onWalkEnd(WalkEvent walkEvent, Set set) {
public void shouldWalkPropertiesWithValidation() throws URISyntaxException, IOException {
InputStream schemaInputStream = Issue467Test.class.getResourceAsStream(schemaPath);
final Set properties = new LinkedHashSet<>();
- final SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.addPropertyWalkListener(new JsonSchemaWalkListener() {
- @Override
- public WalkFlow onWalkStart(WalkEvent walkEvent) {
- properties.add(walkEvent.getSchema().getEvaluationPath());
- return WalkFlow.CONTINUE;
- }
+ final SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .propertyWalkListener(new JsonSchemaWalkListener() {
+ @Override
+ public WalkFlow onWalkStart(WalkEvent walkEvent) {
+ properties.add(walkEvent.getSchema().getEvaluationPath());
+ return WalkFlow.CONTINUE;
+ }
- @Override
- public void onWalkEnd(WalkEvent walkEvent, Set set) {
- }
- });
+ @Override
+ public void onWalkEnd(WalkEvent walkEvent, Set set) {
+ }
+ })
+ .build();
JsonSchema schema = factory.getSchema(schemaInputStream, config);
JsonNode data = mapper.readTree(Issue467Test.class.getResource("/data/issue467.json"));
ValidationResult result = schema.walk(data, true);
assertEquals(
- new HashSet<>(Arrays.asList("$.properties.tags", "$.properties.tags.items[0].properties.category", "$.properties.tags.items[0].properties.value")),
+ new HashSet<>(Arrays.asList("/properties/tags", "/properties/tags/items/0/properties/category", "/properties/tags/items/0/properties/value")),
properties.stream().map(Object::toString).collect(Collectors.toSet()));
assertEquals(1, result.getValidationMessages().size());
}
diff --git a/src/test/java/com/networknt/schema/Issue475Test.java b/src/test/java/com/networknt/schema/Issue475Test.java
index e9944cbd6..0f3d59f63 100644
--- a/src/test/java/com/networknt/schema/Issue475Test.java
+++ b/src/test/java/com/networknt/schema/Issue475Test.java
@@ -52,8 +52,7 @@ public class Issue475Test {
public void draft4() throws Exception {
JsonSchemaFactory jsonSchemaFactory = JsonSchemaFactory.getInstance(VersionFlag.V4, builder -> builder
.schemaMappers(schemaMappers -> schemaMappers.mapPrefix("http://json-schema.org", "classpath:")));
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = jsonSchemaFactory.getSchema(SchemaLocation.of(SchemaId.V4), config);
Set assertions = schema.validate(JsonMapperFactory.getInstance().readTree(INVALID_INPUT));
@@ -67,8 +66,7 @@ public void draft4() throws Exception {
public void draft6() throws Exception {
JsonSchemaFactory jsonSchemaFactory = JsonSchemaFactory.getInstance(VersionFlag.V6, builder -> builder
.schemaMappers(schemaMappers -> schemaMappers.mapPrefix("http://json-schema.org", "classpath:")));
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = jsonSchemaFactory.getSchema(SchemaLocation.of(SchemaId.V6), config);
Set assertions = schema.validate(JsonMapperFactory.getInstance().readTree(INVALID_INPUT));
@@ -82,8 +80,7 @@ public void draft6() throws Exception {
public void draft7() throws Exception {
JsonSchemaFactory jsonSchemaFactory = JsonSchemaFactory.getInstance(VersionFlag.V7, builder -> builder
.schemaMappers(schemaMappers -> schemaMappers.mapPrefix("http://json-schema.org", "classpath:")));
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = jsonSchemaFactory.getSchema(SchemaLocation.of(SchemaId.V7), config);
Set assertions = schema.validate(JsonMapperFactory.getInstance().readTree(INVALID_INPUT));
@@ -97,8 +94,7 @@ public void draft7() throws Exception {
public void draft201909() throws Exception {
JsonSchemaFactory jsonSchemaFactory = JsonSchemaFactory.getInstance(VersionFlag.V201909, builder -> builder
.schemaMappers(schemaMappers -> schemaMappers.mapPrefix("https://json-schema.org", "classpath:")));
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = jsonSchemaFactory.getSchema(SchemaLocation.of(SchemaId.V201909), config);
Set assertions = schema.validate(JsonMapperFactory.getInstance().readTree(INVALID_INPUT));
@@ -107,13 +103,12 @@ public void draft201909() throws Exception {
assertions = schema.validate(JsonMapperFactory.getInstance().readTree(VALID_INPUT));
assertEquals(0, assertions.size());
}
-
+
@Test
public void draft202012() throws Exception {
JsonSchemaFactory jsonSchemaFactory = JsonSchemaFactory.getInstance(VersionFlag.V202012, builder -> builder
.schemaMappers(schemaMappers -> schemaMappers.mapPrefix("https://json-schema.org", "classpath:")));
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = jsonSchemaFactory.getSchema(SchemaLocation.of(SchemaId.V202012), config);
Set assertions = schema.validate(JsonMapperFactory.getInstance().readTree(INVALID_INPUT));
diff --git a/src/test/java/com/networknt/schema/Issue604Test.java b/src/test/java/com/networknt/schema/Issue604Test.java
index 40e68d87c..183aef221 100644
--- a/src/test/java/com/networknt/schema/Issue604Test.java
+++ b/src/test/java/com/networknt/schema/Issue604Test.java
@@ -8,8 +8,9 @@
public class Issue604Test {
@Test
public void failure() {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setApplyDefaultsStrategy(new ApplyDefaultsStrategy(true, false, false));
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .applyDefaultsStrategy(new ApplyDefaultsStrategy(true, false, false))
+ .build();
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7);
JsonSchema schema = factory.getSchema("{ \"type\": \"object\", \"properties\": { \"foo\": { \"type\": \"object\", \"properties\": { \"bar\": { \"type\": \"boolean\", \"default\": false } } } } }", config);
ObjectMapper objectMapper = new ObjectMapper();
diff --git a/src/test/java/com/networknt/schema/Issue650Test.java b/src/test/java/com/networknt/schema/Issue650Test.java
index 02bffbf25..dabbd7c5e 100644
--- a/src/test/java/com/networknt/schema/Issue650Test.java
+++ b/src/test/java/com/networknt/schema/Issue650Test.java
@@ -66,6 +66,7 @@ private static class Model {
* @return the data
* @since 1.0.77
*/
+ @SuppressWarnings("unused") // called by jackson
public byte[] getData() {
return this.data;
}
diff --git a/src/test/java/com/networknt/schema/Issue686Test.java b/src/test/java/com/networknt/schema/Issue686Test.java
index 1b35f0666..0148dfac5 100644
--- a/src/test/java/com/networknt/schema/Issue686Test.java
+++ b/src/test/java/com/networknt/schema/Issue686Test.java
@@ -18,40 +18,39 @@ public class Issue686Test {
@Test
void testDefaults() {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
assertEquals(DefaultMessageSource.getInstance(), config.getMessageSource());
}
@Test
void testValidationWithDefaultBundleAndLocale() throws JsonProcessingException {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
ResourceBundle resourceBundle = ResourceBundle.getBundle(DefaultMessageSource.BUNDLE_BASE_NAME, Locale.getDefault());
- String expectedMessage = new MessageFormat(resourceBundle.getString("type")).format(new String[] {"$.foo", "integer", "string"});
+ String expectedMessage = new MessageFormat(resourceBundle.getString("type")).format(new String[] {"/foo", "integer", "string"});
verify(config, expectedMessage);
}
@Test
void testValidationWithDefaultBundleAndCustomLocale() throws JsonProcessingException {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setLocale(Locale.ITALIAN);
- verify(config, "$.foo: integer trovato, string previsto");
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().locale(Locale.ITALIAN).build();
+ verify(config, "/foo: integer trovato, string previsto");
}
@Test
void testValidationWithCustomBundle() throws JsonProcessingException {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setMessageSource(new ResourceBundleMessageSource("issue686/translations"));
- config.setLocale(Locale.FRENCH);
- verify(config, "$.foo: integer found, string expected (TEST) (FR)");
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .messageSource(new ResourceBundleMessageSource("issue686/translations"))
+ .locale(Locale.FRENCH)
+ .build();
+ verify(config, "/foo: integer found, string expected (TEST) (FR)");
}
@Test
void testLocaleSwitch() throws JsonProcessingException {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setLocale(Locale.ITALIAN);
- verify(config, "$.foo: integer trovato, string previsto");
- config.setLocale(Locale.FRENCH);
- verify(config, "$.foo: integer trouvé, string attendu");
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().locale(Locale.ITALIAN).build();
+ verify(config, "/foo: integer trovato, string previsto");
+ SchemaValidatorsConfig config2 = SchemaValidatorsConfig.builder().locale(Locale.FRENCH).build();
+ verify(config2, "/foo: integer trouvé, string attendu");
}
private JsonSchema getSchema(SchemaValidatorsConfig config) {
diff --git a/src/test/java/com/networknt/schema/Issue687Test.java b/src/test/java/com/networknt/schema/Issue687Test.java
index 962105098..fb4d6e0f4 100644
--- a/src/test/java/com/networknt/schema/Issue687Test.java
+++ b/src/test/java/com/networknt/schema/Issue687Test.java
@@ -80,8 +80,7 @@ void testAppendIndex(PathType pathType, String currentPath, Integer index, Strin
@ParameterizedTest
@MethodSource("validationMessages")
void testValidationMessage(PathType pathType, String schemaPath, String content, String[] expectedMessagePaths) throws JsonProcessingException {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(pathType);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().pathType(pathType).build();
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V201909);
JsonSchema schema = factory.getSchema(Issue687Test.class.getResourceAsStream(schemaPath), config);
Set messages = schema.validate(new ObjectMapper().readTree(content));
@@ -114,8 +113,7 @@ public static Stream specialCharacterTests() {
@MethodSource("specialCharacterTests")
void testSpecialCharacters(PathType pathType, String propertyName, String expectedPath) throws JsonProcessingException {
ObjectMapper mapper = new ObjectMapper();
- SchemaValidatorsConfig schemaValidatorsConfig = new SchemaValidatorsConfig();
- schemaValidatorsConfig.setPathType(pathType);
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder().pathType(pathType).build();
JsonSchema schema = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V201909)
.getSchema(mapper.readTree("{\n" +
" \"$schema\": \"https://json-schema.org/draft/2019-09/schema\",\n" +
diff --git a/src/test/java/com/networknt/schema/Issue724Test.java b/src/test/java/com/networknt/schema/Issue724Test.java
index 47b060cfe..b4d0c0faa 100644
--- a/src/test/java/com/networknt/schema/Issue724Test.java
+++ b/src/test/java/com/networknt/schema/Issue724Test.java
@@ -22,9 +22,8 @@ class Issue724Test {
@Test
void test() throws JsonProcessingException {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
StringCollector stringCollector = new StringCollector();
- config.addKeywordWalkListener(stringCollector);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().keywordWalkListener(stringCollector).build();
String schema =
"{\n"
diff --git a/src/test/java/com/networknt/schema/Issue792.java b/src/test/java/com/networknt/schema/Issue792.java
index 935336e6b..c76c12873 100644
--- a/src/test/java/com/networknt/schema/Issue792.java
+++ b/src/test/java/com/networknt/schema/Issue792.java
@@ -28,9 +28,7 @@ void test() throws JsonProcessingException {
" }\n" +
"}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setTypeLoose(false);
- config.setFailFast(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().typeLoose(false).failFast(true).build();
JsonSchema jsonSchema = schemaFactory.getSchema(schemaDef, config);
JsonNode jsonNode = new ObjectMapper().readTree("{\"field\": \"pattern-violation\"}");
diff --git a/src/test/java/com/networknt/schema/Issue857Test.java b/src/test/java/com/networknt/schema/Issue857Test.java
index 8d533e5ea..045ce23f7 100644
--- a/src/test/java/com/networknt/schema/Issue857Test.java
+++ b/src/test/java/com/networknt/schema/Issue857Test.java
@@ -48,8 +48,7 @@ void test() {
+ " \"id\": \"4\"\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFailFast(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().failFast(true).build();
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
Set result = factory.getSchema(schema, config).validate(input, InputFormat.JSON);
assertTrue(result.isEmpty());
diff --git a/src/test/java/com/networknt/schema/Issue898Test.java b/src/test/java/com/networknt/schema/Issue898Test.java
index 1ec5f3ed5..41bfab480 100644
--- a/src/test/java/com/networknt/schema/Issue898Test.java
+++ b/src/test/java/com/networknt/schema/Issue898Test.java
@@ -13,8 +13,7 @@ class Issue898Test extends BaseJsonSchemaValidatorTest {
@Test
void testMessagesWithSingleQuotes() throws Exception {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setLocale(Locale.FRENCH);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().locale(Locale.FRENCH).build();
JsonSchema schema = getJsonSchemaFromClasspath("schema/issue898.json", SpecVersion.VersionFlag.V202012, config);
JsonNode node = getJsonNodeFromClasspath("data/issue898.json");
@@ -24,8 +23,8 @@ void testMessagesWithSingleQuotes() throws Exception {
.collect(toList());
Assertions.assertEquals(2, messages.size());
- Assertions.assertEquals("$.foo: n'a pas de valeur dans l'énumération [foo1, foo2]", messages.get(0));
- Assertions.assertEquals("$.bar: ne correspond pas au modèle d'expression régulière (bar)+", messages.get(1));
+ Assertions.assertEquals("/foo: n'a pas de valeur dans l'énumération [foo1, foo2]", messages.get(0));
+ Assertions.assertEquals("/bar: ne correspond pas au modèle d'expression régulière (bar)+", messages.get(1));
}
}
diff --git a/src/test/java/com/networknt/schema/Issue936Test.java b/src/test/java/com/networknt/schema/Issue936Test.java
index b9be21f76..65e56c179 100644
--- a/src/test/java/com/networknt/schema/Issue936Test.java
+++ b/src/test/java/com/networknt/schema/Issue936Test.java
@@ -27,8 +27,9 @@ public class Issue936Test {
void shouldThrowInvalidSchemaException() {
String schema = "{\r\n" + " \"$id\": \"0\",\r\n"
+ " \"$schema\": \"https://json-schema.org/draft/2020-12/schema\"\r\n" + "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setSchemaIdValidator(JsonSchemaIdValidator.DEFAULT);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .schemaIdValidator(JsonSchemaIdValidator.DEFAULT)
+ .build();
assertThrowsExactly(InvalidSchemaException.class,
() -> JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schema, config));
try {
diff --git a/src/test/java/com/networknt/schema/Issue943Test.java b/src/test/java/com/networknt/schema/Issue943Test.java
index 82fbc6a92..2cf9c32b3 100644
--- a/src/test/java/com/networknt/schema/Issue943Test.java
+++ b/src/test/java/com/networknt/schema/Issue943Test.java
@@ -69,8 +69,7 @@ void test() {
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012,
builder -> builder.schemaLoaders(schemaLoaders -> schemaLoaders.schemas(external)));
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
assertTrue(schema.validate(inputData, InputFormat.JSON).isEmpty());
diff --git a/src/test/java/com/networknt/schema/ItemsValidator202012Test.java b/src/test/java/com/networknt/schema/ItemsValidator202012Test.java
index f7330f37c..24d77718b 100644
--- a/src/test/java/com/networknt/schema/ItemsValidator202012Test.java
+++ b/src/test/java/com/networknt/schema/ItemsValidator202012Test.java
@@ -46,8 +46,7 @@ void messageInvalid() {
+ " \"items\": {\"type\": \"integer\"}"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "[1, \"x\"]";
Set messages = schema.validate(inputData, InputFormat.JSON);
@@ -70,15 +69,12 @@ void walkNull() {
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addItemWalkListener(new JsonSchemaWalkListener() {
-
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().itemWalkListener(new JsonSchemaWalkListener() {
@Override
public WalkFlow onWalkStart(WalkEvent walkEvent) {
return WalkFlow.CONTINUE;
}
-
+
@Override
public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
@SuppressWarnings("unchecked")
@@ -88,7 +84,7 @@ public void onWalkEnd(WalkEvent walkEvent, Set validationMess
.computeIfAbsent("items", key -> new ArrayList());
items.add(walkEvent);
}
- });
+ }).build();
JsonSchema schema = factory.getSchema(schemaData, config);
ValidationResult result = schema.walk(null, true);
assertTrue(result.getValidationMessages().isEmpty());
@@ -112,15 +108,12 @@ void walkNullPrefixItems() {
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addItemWalkListener(new JsonSchemaWalkListener() {
-
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().itemWalkListener(new JsonSchemaWalkListener() {
@Override
public WalkFlow onWalkStart(WalkEvent walkEvent) {
return WalkFlow.CONTINUE;
}
-
+
@Override
public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
@SuppressWarnings("unchecked")
@@ -130,7 +123,7 @@ public void onWalkEnd(WalkEvent walkEvent, Set validationMess
.computeIfAbsent("items", key -> new ArrayList());
items.add(walkEvent);
}
- });
+ }).build();
JsonSchema schema = factory.getSchema(schemaData, config);
ValidationResult result = schema.walk(null, true);
assertTrue(result.getValidationMessages().isEmpty());
diff --git a/src/test/java/com/networknt/schema/ItemsValidatorTest.java b/src/test/java/com/networknt/schema/ItemsValidatorTest.java
index 901dbc002..9864f73d3 100644
--- a/src/test/java/com/networknt/schema/ItemsValidatorTest.java
+++ b/src/test/java/com/networknt/schema/ItemsValidatorTest.java
@@ -50,8 +50,7 @@ void messageInvalid() {
+ " \"items\": {\"type\": \"integer\"}"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V201909);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "[1, \"x\"]";
Set messages = schema.validate(inputData, InputFormat.JSON);
@@ -65,7 +64,7 @@ void messageInvalid() {
assertEquals("/1: string found, integer expected", message.getMessage());
assertNull(message.getProperty());
}
-
+
/**
* Tests that the message contains the correct values when there are invalid
* items.
@@ -78,8 +77,7 @@ void messageAdditionalItemsInvalid() {
+ " \"additionalItems\": {\"type\": \"integer\"}"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V201909);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "[ null, 2, 3, \"foo\" ]";
Set messages = schema.validate(inputData, InputFormat.JSON);
@@ -93,7 +91,7 @@ void messageAdditionalItemsInvalid() {
assertEquals("/3: string found, integer expected", message.getMessage());
assertNull(message.getProperty());
}
-
+
/**
* Tests that the message contains the correct values when there are invalid
* items.
@@ -106,8 +104,7 @@ void messageAdditionalItemsFalseInvalid() {
+ " \"additionalItems\": false"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V201909);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "[ null, 2, 3, \"foo\" ]";
Set messages = schema.validate(inputData, InputFormat.JSON);
@@ -130,15 +127,12 @@ void walk() {
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V201909);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addItemWalkListener(new JsonSchemaWalkListener() {
-
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().itemWalkListener(new JsonSchemaWalkListener() {
@Override
public WalkFlow onWalkStart(WalkEvent walkEvent) {
return WalkFlow.CONTINUE;
}
-
+
@Override
public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
@SuppressWarnings("unchecked")
@@ -148,7 +142,7 @@ public void onWalkEnd(WalkEvent walkEvent, Set validationMess
.computeIfAbsent("items", key -> new ArrayList());
items.add(walkEvent);
}
- });
+ }).build();
JsonSchema schema = factory.getSchema(schemaData, config);
ValidationResult result = schema.walk("[\"the\",\"quick\",\"brown\"]", InputFormat.JSON, true);
assertTrue(result.getValidationMessages().isEmpty());
@@ -169,15 +163,12 @@ void walkNull() {
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V201909);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addItemWalkListener(new JsonSchemaWalkListener() {
-
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().itemWalkListener(new JsonSchemaWalkListener() {
@Override
public WalkFlow onWalkStart(WalkEvent walkEvent) {
return WalkFlow.CONTINUE;
}
-
+
@Override
public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
@SuppressWarnings("unchecked")
@@ -187,7 +178,7 @@ public void onWalkEnd(WalkEvent walkEvent, Set validationMess
.computeIfAbsent("items", key -> new ArrayList());
items.add(walkEvent);
}
- });
+ }).build();
JsonSchema schema = factory.getSchema(schemaData, config);
ValidationResult result = schema.walk(null, true);
assertTrue(result.getValidationMessages().isEmpty());
@@ -214,15 +205,12 @@ void walkNullTupleItemsAdditional() {
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V201909);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addItemWalkListener(new JsonSchemaWalkListener() {
-
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().itemWalkListener(new JsonSchemaWalkListener() {
@Override
public WalkFlow onWalkStart(WalkEvent walkEvent) {
return WalkFlow.CONTINUE;
}
-
+
@Override
public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
@SuppressWarnings("unchecked")
@@ -232,7 +220,7 @@ public void onWalkEnd(WalkEvent walkEvent, Set validationMess
.computeIfAbsent("items", key -> new ArrayList());
items.add(walkEvent);
}
- });
+ }).build();
JsonSchema schema = factory.getSchema(schemaData, config);
ValidationResult result = schema.walk(null, true);
assertTrue(result.getValidationMessages().isEmpty());
@@ -267,15 +255,12 @@ void walkTupleItemsAdditional() throws JsonMappingException, JsonProcessingExcep
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V201909);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addItemWalkListener(new JsonSchemaWalkListener() {
-
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().itemWalkListener(new JsonSchemaWalkListener() {
@Override
public WalkFlow onWalkStart(WalkEvent walkEvent) {
return WalkFlow.CONTINUE;
}
-
+
@Override
public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
@SuppressWarnings("unchecked")
@@ -285,7 +270,7 @@ public void onWalkEnd(WalkEvent walkEvent, Set validationMess
.computeIfAbsent("items", key -> new ArrayList());
items.add(walkEvent);
}
- });
+ }).build();
JsonSchema schema = factory.getSchema(schemaData, config);
JsonNode input = JsonMapperFactory.getInstance().readTree("[\"hello\"]");
ValidationResult result = schema.walk(input, true);
@@ -324,26 +309,26 @@ void walkTupleItemsAdditionalDefaults() throws JsonMappingException, JsonProcess
+ " }\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V201909);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setApplyDefaultsStrategy(new ApplyDefaultsStrategy(true, true, true));
- config.setPathType(PathType.JSON_POINTER);
- config.addItemWalkListener(new JsonSchemaWalkListener() {
-
- @Override
- public WalkFlow onWalkStart(WalkEvent walkEvent) {
- return WalkFlow.CONTINUE;
- }
-
- @Override
- public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
- @SuppressWarnings("unchecked")
- List items = (List) walkEvent.getExecutionContext()
- .getCollectorContext()
- .getCollectorMap()
- .computeIfAbsent("items", key -> new ArrayList());
- items.add(walkEvent);
- }
- });
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .applyDefaultsStrategy(new ApplyDefaultsStrategy(true, true, true))
+ .itemWalkListener(new JsonSchemaWalkListener() {
+
+ @Override
+ public WalkFlow onWalkStart(WalkEvent walkEvent) {
+ return WalkFlow.CONTINUE;
+ }
+
+ @Override
+ public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
+ @SuppressWarnings("unchecked")
+ List items = (List) walkEvent.getExecutionContext()
+ .getCollectorContext()
+ .getCollectorMap()
+ .computeIfAbsent("items", key -> new ArrayList());
+ items.add(walkEvent);
+ }
+ })
+ .build();
JsonSchema schema = factory.getSchema(schemaData, config);
JsonNode input = JsonMapperFactory.getInstance().readTree("[null, null, null, null]");
ValidationResult result = schema.walk(input, true);
diff --git a/src/test/java/com/networknt/schema/JsonSchemaFactoryTest.java b/src/test/java/com/networknt/schema/JsonSchemaFactoryTest.java
index e68f9966d..474222049 100644
--- a/src/test/java/com/networknt/schema/JsonSchemaFactoryTest.java
+++ b/src/test/java/com/networknt/schema/JsonSchemaFactoryTest.java
@@ -56,7 +56,7 @@ void concurrency() {
for (int i = 0; i < 50; ++i) {
Runnable runner = new Runnable() {
public void run() {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
try {
latch.await();
} catch (InterruptedException e) {
diff --git a/src/test/java/com/networknt/schema/JsonSchemaFactoryUriCacheTest.java b/src/test/java/com/networknt/schema/JsonSchemaFactoryUriCacheTest.java
index 27cac9a05..31d4854b1 100644
--- a/src/test/java/com/networknt/schema/JsonSchemaFactoryUriCacheTest.java
+++ b/src/test/java/com/networknt/schema/JsonSchemaFactoryUriCacheTest.java
@@ -35,12 +35,12 @@ private void runCacheTest(boolean enableCache) throws JsonProcessingException {
SchemaLocation schemaUri = SchemaLocation.of("cache:uri_mapping/schema1.json");
String schema = "{ \"$schema\": \"https://json-schema.org/draft/2020-12/schema\", \"title\": \"json-object-with-schema\", \"type\": \"string\" }";
fetcher.addResource(schemaUri.getAbsoluteIri(), schema);
- assertEquals(objectMapper.readTree(schema), factory.getSchema(schemaUri, new SchemaValidatorsConfig()).schemaNode);
+ assertEquals(objectMapper.readTree(schema), factory.getSchema(schemaUri, SchemaValidatorsConfig.builder().build()).schemaNode);
String modifiedSchema = "{ \"$schema\": \"https://json-schema.org/draft/2020-12/schema\", \"title\": \"json-object-with-schema\", \"type\": \"object\" }";
fetcher.addResource(schemaUri.getAbsoluteIri(), modifiedSchema);
- assertEquals(objectMapper.readTree(enableCache ? schema : modifiedSchema), factory.getSchema(schemaUri, new SchemaValidatorsConfig()).schemaNode);
+ assertEquals(objectMapper.readTree(enableCache ? schema : modifiedSchema), factory.getSchema(schemaUri, SchemaValidatorsConfig.builder().build()).schemaNode);
}
private JsonSchemaFactory buildJsonSchemaFactory(CustomURIFetcher uriFetcher, boolean enableSchemaCache) {
diff --git a/src/test/java/com/networknt/schema/JsonSchemaPreloadTest.java b/src/test/java/com/networknt/schema/JsonSchemaPreloadTest.java
index 2fe9e3036..d2a467814 100644
--- a/src/test/java/com/networknt/schema/JsonSchemaPreloadTest.java
+++ b/src/test/java/com/networknt/schema/JsonSchemaPreloadTest.java
@@ -27,16 +27,16 @@ public class JsonSchemaPreloadTest {
@Test
void cacheRefsFalse() {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V7);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setCacheRefs(false);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().cacheRefs(false).build();
factory.getSchema(SchemaLocation.of("classpath:/issues/1016/schema.json"), config);
}
@Test
void preloadSchemaRefMaxNestingDepth() {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V7);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPreloadJsonSchemaRefMaxNestingDepth(20);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .preloadJsonSchemaRefMaxNestingDepth(20)
+ .build();
factory.getSchema(SchemaLocation.of("classpath:/issues/1016/schema.json"), config);
}
}
diff --git a/src/test/java/com/networknt/schema/JsonSchemaTest.java b/src/test/java/com/networknt/schema/JsonSchemaTest.java
index 506763c54..0f76ac1f6 100644
--- a/src/test/java/com/networknt/schema/JsonSchemaTest.java
+++ b/src/test/java/com/networknt/schema/JsonSchemaTest.java
@@ -58,8 +58,7 @@ void concurrency() throws Exception {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012,
builder -> builder.schemaLoaders(schemaLoaders -> schemaLoaders
.schemas(Collections.singletonMap("http://example.org/ref.json", refSchemaData))));
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPreloadJsonSchema(false);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().preloadJsonSchema(false).build();
JsonSchema schema = factory.getSchema(schemaData, config);
Exception[] instance = new Exception[1];
CountDownLatch latch = new CountDownLatch(1);
diff --git a/src/test/java/com/networknt/schema/JsonWalkApplyDefaultsTest.java b/src/test/java/com/networknt/schema/JsonWalkApplyDefaultsTest.java
index abb0b06a6..6fb41efc0 100644
--- a/src/test/java/com/networknt/schema/JsonWalkApplyDefaultsTest.java
+++ b/src/test/java/com/networknt/schema/JsonWalkApplyDefaultsTest.java
@@ -16,12 +16,6 @@
class JsonWalkApplyDefaultsTest {
-
- /* @AfterEach
- void cleanup() {
- CollectorContext.getInstance().reset();
- }*/
-
@ParameterizedTest
@ValueSource(booleans = { true, false})
void testApplyDefaults3(boolean shouldValidateSchema) throws IOException {
@@ -31,9 +25,9 @@ void testApplyDefaults3(boolean shouldValidateSchema) throws IOException {
ValidationResult result = jsonSchema.walk(inputNode, shouldValidateSchema);
if (shouldValidateSchema) {
assertThat(result.getValidationMessages().stream().map(ValidationMessage::getMessage).collect(Collectors.toList()),
- Matchers.containsInAnyOrder("$.outer.mixedObject.intValue_missingButError: string found, integer expected",
- "$.outer.badArray[1]: integer found, string expected",
- "$.outer.reference.stringValue_missing_with_default_null: null found, string expected"));
+ Matchers.containsInAnyOrder("/outer/mixedObject/intValue_missingButError: string found, integer expected",
+ "/outer/badArray/1: integer found, string expected",
+ "/outer/reference/stringValue_missing_with_default_null: null found, string expected"));
} else {
assertThat(result.getValidationMessages(), Matchers.empty());
}
@@ -51,10 +45,10 @@ void testApplyDefaults2() throws IOException {
JsonSchema jsonSchema = createSchema(new ApplyDefaultsStrategy(true, true, false));
ValidationResult result = jsonSchema.walk(inputNode, true);
assertThat(result.getValidationMessages().stream().map(ValidationMessage::getMessage).collect(Collectors.toList()),
- Matchers.containsInAnyOrder("$.outer.mixedObject.intValue_missingButError: string found, integer expected",
- "$.outer.goodArray[1]: null found, string expected",
- "$.outer.badArray[1]: null found, string expected",
- "$.outer.reference.stringValue_missing_with_default_null: null found, string expected"));
+ Matchers.containsInAnyOrder("/outer/mixedObject/intValue_missingButError: string found, integer expected",
+ "/outer/goodArray/1: null found, string expected",
+ "/outer/badArray/1: null found, string expected",
+ "/outer/reference/stringValue_missing_with_default_null: null found, string expected"));
assertEquals(
objectMapper.readTree(
"{\"outer\":{\"mixedObject\":{\"intValue_present\":8,\"intValue_null\":35,\"intValue_missingButError\":\"forty-five\",\"intValue_missing\":15,\"intValue_missing_notRequired\":25},\"goodArray\":[\"hello\",null],\"badArray\":[\"hello\",null],\"reference\":{\"stringValue_missing_with_default_null\":null,\"stringValue_missing\":\"hello\"}}}"),
@@ -68,11 +62,11 @@ void testApplyDefaults1() throws IOException {
JsonSchema jsonSchema = createSchema(new ApplyDefaultsStrategy(true, false, false));
ValidationResult result = jsonSchema.walk(inputNode, true);
assertThat(result.getValidationMessages().stream().map(ValidationMessage::getMessage).collect(Collectors.toList()),
- Matchers.containsInAnyOrder("$.outer.mixedObject.intValue_null: null found, integer expected",
- "$.outer.mixedObject.intValue_missingButError: string found, integer expected",
- "$.outer.goodArray[1]: null found, string expected",
- "$.outer.badArray[1]: null found, string expected",
- "$.outer.reference.stringValue_missing_with_default_null: null found, string expected"));
+ Matchers.containsInAnyOrder("/outer/mixedObject/intValue_null: null found, integer expected",
+ "/outer/mixedObject/intValue_missingButError: string found, integer expected",
+ "/outer/goodArray/1: null found, string expected",
+ "/outer/badArray/1: null found, string expected",
+ "/outer/reference/stringValue_missing_with_default_null: null found, string expected"));
assertEquals(
objectMapper.readTree(
"{\"outer\":{\"mixedObject\":{\"intValue_present\":8,\"intValue_null\":null,\"intValue_missingButError\":\"forty-five\",\"intValue_missing\":15,\"intValue_missing_notRequired\":25},\"goodArray\":[\"hello\",null],\"badArray\":[\"hello\",null],\"reference\":{\"stringValue_missing_with_default_null\":null,\"stringValue_missing\":\"hello\"}}}"),
@@ -107,12 +101,12 @@ void testApplyDefaults0(String method) throws IOException {
throw new UnsupportedOperationException();
}
assertThat(validationMessages.stream().map(ValidationMessage::getMessage).collect(Collectors.toList()),
- Matchers.containsInAnyOrder("$.outer.mixedObject: required property 'intValue_missing' not found",
- "$.outer.mixedObject: required property 'intValue_missingButError' not found",
- "$.outer.mixedObject.intValue_null: null found, integer expected",
- "$.outer.goodArray[1]: null found, string expected",
- "$.outer.badArray[1]: null found, string expected",
- "$.outer.reference: required property 'stringValue_missing' not found"));
+ Matchers.containsInAnyOrder("/outer/mixedObject: required property 'intValue_missing' not found",
+ "/outer/mixedObject: required property 'intValue_missingButError' not found",
+ "/outer/mixedObject/intValue_null: null found, integer expected",
+ "/outer/goodArray/1: null found, string expected",
+ "/outer/badArray/1: null found, string expected",
+ "/outer/reference: required property 'stringValue_missing' not found"));
assertEquals(inputNodeOriginal, inputNode);
}
@@ -127,8 +121,7 @@ void testIllegalArgumentException() {
private JsonSchema createSchema(ApplyDefaultsStrategy applyDefaultsStrategy) {
JsonSchemaFactory schemaFactory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V4);
- SchemaValidatorsConfig schemaValidatorsConfig = new SchemaValidatorsConfig();
- schemaValidatorsConfig.setApplyDefaultsStrategy(applyDefaultsStrategy);
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder().applyDefaultsStrategy(applyDefaultsStrategy).build();
return schemaFactory.getSchema(getClass().getClassLoader().getResourceAsStream("schema/walk-schema-default.json"), schemaValidatorsConfig);
}
}
diff --git a/src/test/java/com/networknt/schema/JsonWalkTest.java b/src/test/java/com/networknt/schema/JsonWalkTest.java
index 3ff08e11d..d8020ebc9 100644
--- a/src/test/java/com/networknt/schema/JsonWalkTest.java
+++ b/src/test/java/com/networknt/schema/JsonWalkTest.java
@@ -36,21 +36,21 @@ public void setup() {
private void setupSchema() {
final JsonMetaSchema metaSchema = getJsonMetaSchema();
// Create Schema.
- SchemaValidatorsConfig schemaValidatorsConfig = new SchemaValidatorsConfig();
- schemaValidatorsConfig.addKeywordWalkListener(new AllKeywordListener());
- schemaValidatorsConfig.addKeywordWalkListener(ValidatorTypeCode.REF.getValue(), new RefKeywordListener());
- schemaValidatorsConfig.addKeywordWalkListener(ValidatorTypeCode.PROPERTIES.getValue(),
+ SchemaValidatorsConfig.Builder schemaValidatorsConfigBuilder = SchemaValidatorsConfig.builder();
+ schemaValidatorsConfigBuilder.keywordWalkListener(new AllKeywordListener());
+ schemaValidatorsConfigBuilder.keywordWalkListener(ValidatorTypeCode.REF.getValue(), new RefKeywordListener());
+ schemaValidatorsConfigBuilder.keywordWalkListener(ValidatorTypeCode.PROPERTIES.getValue(),
new PropertiesKeywordListener());
final JsonSchemaFactory schemaFactory = JsonSchemaFactory
.builder(JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V201909)).metaSchema(metaSchema)
.build();
- this.jsonSchema = schemaFactory.getSchema(getSchema(), schemaValidatorsConfig);
+ this.jsonSchema = schemaFactory.getSchema(getSchema(), schemaValidatorsConfigBuilder.build());
// Create another Schema.
- SchemaValidatorsConfig schemaValidatorsConfig1 = new SchemaValidatorsConfig();
- schemaValidatorsConfig1.addKeywordWalkListener(ValidatorTypeCode.REF.getValue(), new RefKeywordListener());
- schemaValidatorsConfig1.addKeywordWalkListener(ValidatorTypeCode.PROPERTIES.getValue(),
+ SchemaValidatorsConfig.Builder schemaValidatorsConfig1Builder = SchemaValidatorsConfig.builder();
+ schemaValidatorsConfig1Builder.keywordWalkListener(ValidatorTypeCode.REF.getValue(), new RefKeywordListener());
+ schemaValidatorsConfig1Builder.keywordWalkListener(ValidatorTypeCode.PROPERTIES.getValue(),
new PropertiesKeywordListener());
- this.jsonSchema1 = schemaFactory.getSchema(getSchema(), schemaValidatorsConfig1);
+ this.jsonSchema1 = schemaFactory.getSchema(getSchema(), schemaValidatorsConfig1Builder.build());
}
private JsonMetaSchema getJsonMetaSchema() {
diff --git a/src/test/java/com/networknt/schema/LocaleTest.java b/src/test/java/com/networknt/schema/LocaleTest.java
index 4fc386f0e..d8783e2a9 100644
--- a/src/test/java/com/networknt/schema/LocaleTest.java
+++ b/src/test/java/com/networknt/schema/LocaleTest.java
@@ -51,7 +51,7 @@ private JsonSchema getSchema(SchemaValidatorsConfig config) {
@Test
void executionContextLocale() throws JsonMappingException, JsonProcessingException {
JsonNode rootNode = new ObjectMapper().readTree(" { \"foo\": 123 } ");
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema jsonSchema = getSchema(config);
Locale locale = Locales.findSupported("it;q=0.9,fr;q=1.0"); // fr
@@ -60,7 +60,7 @@ void executionContextLocale() throws JsonMappingException, JsonProcessingExcepti
executionContext.getExecutionConfig().setLocale(locale);
Set messages = jsonSchema.validate(executionContext, rootNode);
assertEquals(1, messages.size());
- assertEquals("$.foo: integer trouvé, string attendu", messages.iterator().next().getMessage());
+ assertEquals("/foo: integer trouvé, string attendu", messages.iterator().next().getMessage());
locale = Locales.findSupported("it;q=1.0,fr;q=0.9"); // it
executionContext = jsonSchema.createExecutionContext();
@@ -68,7 +68,7 @@ void executionContextLocale() throws JsonMappingException, JsonProcessingExcepti
executionContext.getExecutionConfig().setLocale(locale);
messages = jsonSchema.validate(executionContext, rootNode);
assertEquals(1, messages.size());
- assertEquals("$.foo: integer trovato, string previsto", messages.iterator().next().getMessage());
+ assertEquals("/foo: integer trovato, string previsto", messages.iterator().next().getMessage());
}
/**
@@ -96,13 +96,12 @@ void englishLocale() throws JsonMappingException, JsonProcessingException {
assertEquals(1, messages.size());
assertEquals("$: integer gefunden, object erwartet", messages.iterator().next().toString());
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setLocale(Locale.ENGLISH);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().locale(Locale.ENGLISH).build();
jsonSchema = JsonSchemaFactory.getInstance(VersionFlag.V7)
.getSchema(JsonMapperFactory.getInstance().readTree(schema), config);
messages = jsonSchema.validate(input, InputFormat.JSON);
assertEquals(1, messages.size());
- assertEquals("$: integer found, object expected", messages.iterator().next().toString());
+ assertEquals(": integer found, object expected", messages.iterator().next().toString());
} finally {
Locale.setDefault(locale);
}
diff --git a/src/test/java/com/networknt/schema/MaximumValidatorTest.java b/src/test/java/com/networknt/schema/MaximumValidatorTest.java
index d252648b3..ff65cc9d3 100644
--- a/src/test/java/com/networknt/schema/MaximumValidatorTest.java
+++ b/src/test/java/com/networknt/schema/MaximumValidatorTest.java
@@ -185,8 +185,7 @@ public void negativeDoubleOverflowTest() throws IOException {
String maximum = aTestCycle[0];
String value = aTestCycle[1];
String schema = format(NUMBER, maximum);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setTypeLoose(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().typeLoose(true).build();
// Schema and document parsed with just double
JsonSchema v = factory.getSchema(mapper.readTree(schema), config);
JsonNode doc = mapper.readTree(value);
@@ -295,8 +294,7 @@ private static void expectNoMessages(String[][] values, String schemaTemplate, O
String maximum = aTestCycle[0];
String value = aTestCycle[1];
String schema = format(schemaTemplate, maximum);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setTypeLoose(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().typeLoose(true).build();
JsonSchema v = factory.getSchema(mapper.readTree(schema), config);
JsonNode doc = mapper.readTree(value);
diff --git a/src/test/java/com/networknt/schema/MetaSchemaValidationTest.java b/src/test/java/com/networknt/schema/MetaSchemaValidationTest.java
index 4067e25f7..fa7e35f2c 100644
--- a/src/test/java/com/networknt/schema/MetaSchemaValidationTest.java
+++ b/src/test/java/com/networknt/schema/MetaSchemaValidationTest.java
@@ -40,8 +40,7 @@ public class MetaSchemaValidationTest {
void oas31() throws IOException {
try (InputStream input = MetaSchemaValidationTest.class.getResourceAsStream("/schema/oas/3.1/petstore.json")) {
JsonNode inputData = JsonMapperFactory.getInstance().readTree(input);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = JsonSchemaFactory
.getInstance(VersionFlag.V202012,
builder -> builder.schemaMappers(schemaMappers -> schemaMappers
diff --git a/src/test/java/com/networknt/schema/MinimumValidatorTest.java b/src/test/java/com/networknt/schema/MinimumValidatorTest.java
index 329b6040e..8ce5f300b 100644
--- a/src/test/java/com/networknt/schema/MinimumValidatorTest.java
+++ b/src/test/java/com/networknt/schema/MinimumValidatorTest.java
@@ -16,20 +16,21 @@
package com.networknt.schema;
-import com.fasterxml.jackson.databind.DeserializationFeature;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
+import static com.networknt.schema.MaximumValidatorTest.augmentWithQuotes;
+import static java.lang.String.format;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.Set;
-import static com.networknt.schema.MaximumValidatorTest.augmentWithQuotes;
-import static java.lang.String.format;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
public class MinimumValidatorTest {
private static final String NUMBER = "{ \"$schema\":\"http://json-schema.org/draft-04/schema#\", \"type\": \"number\", \"minimum\": %s }";
@@ -171,8 +172,7 @@ public void negativeDoubleOverflowTest() throws IOException {
String minimum = aTestCycle[0];
String value = aTestCycle[1];
String schema = format(NUMBER, minimum);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setTypeLoose(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().typeLoose(true).build();
// Schema and document parsed with just double
JsonSchema v = factory.getSchema(mapper.readTree(schema), config);
@@ -287,8 +287,7 @@ private void expectNoMessages(String[][] values, String integer, ObjectMapper ma
String minimum = aTestCycle[0];
String value = aTestCycle[1];
String schema = format(integer, minimum);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setTypeLoose(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().typeLoose(true).build();
JsonSchema v = factory.getSchema(mapper.readTree(schema), config);
JsonNode doc = bigIntegerMapper.readTree(value);
diff --git a/src/test/java/com/networknt/schema/MultipleOfValidatorTest.java b/src/test/java/com/networknt/schema/MultipleOfValidatorTest.java
index d53edf387..02ba8d439 100644
--- a/src/test/java/com/networknt/schema/MultipleOfValidatorTest.java
+++ b/src/test/java/com/networknt/schema/MultipleOfValidatorTest.java
@@ -80,8 +80,7 @@ void testTypeLoose() {
assertEquals(2, messages.stream().filter(m -> "type".equals(m.getType())).count());
// With type loose this has 3 multipleOf errors
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setTypeLoose(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().typeLoose(true).build();
JsonSchema typeLoose = factory.getSchema(schemaData, config);
messages = typeLoose.validate(inputData, InputFormat.JSON);
assertEquals(3, messages.size());
diff --git a/src/test/java/com/networknt/schema/OpenAPI30JsonSchemaTest.java b/src/test/java/com/networknt/schema/OpenAPI30JsonSchemaTest.java
index 136f637f0..e39d1f379 100644
--- a/src/test/java/com/networknt/schema/OpenAPI30JsonSchemaTest.java
+++ b/src/test/java/com/networknt/schema/OpenAPI30JsonSchemaTest.java
@@ -29,7 +29,6 @@ private void runTestFile(String testCaseFile) throws Exception {
for (int j = 0; j < testCases.size(); j++) {
try {
JsonNode testCase = testCases.get(j);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
ArrayNode testNodes = (ArrayNode) testCase.get("tests");
for (int i = 0; i < testNodes.size(); i++) {
@@ -39,9 +38,10 @@ private void runTestFile(String testCaseFile) throws Exception {
JsonNode typeLooseNode = test.get("isTypeLoose");
// Configure the schemaValidator to set typeLoose's value based on the test file,
// if test file do not contains typeLoose flag, use default value: true.
- config.setTypeLoose(typeLooseNode != null && typeLooseNode.asBoolean());
- config.setOpenAPI3StyleDiscriminators(true);
- JsonSchema schema = validatorFactory.getSchema(testCaseFileUri, testCase.get("schema"), config);
+ SchemaValidatorsConfig.Builder configBuilder = SchemaValidatorsConfig.builder();
+ configBuilder.typeLoose(typeLooseNode != null && typeLooseNode.asBoolean());
+ configBuilder.discriminatorKeywordEnabled(true);
+ JsonSchema schema = validatorFactory.getSchema(testCaseFileUri, testCase.get("schema"), configBuilder.build());
List errors = new ArrayList(schema.validate(node));
diff --git a/src/test/java/com/networknt/schema/OutputFormatTest.java b/src/test/java/com/networknt/schema/OutputFormatTest.java
index 8fbd35b36..bbd002880 100644
--- a/src/test/java/com/networknt/schema/OutputFormatTest.java
+++ b/src/test/java/com/networknt/schema/OutputFormatTest.java
@@ -1,9 +1,13 @@
package com.networknt.schema;
import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.InputStream;
+import java.util.LinkedHashSet;
+import java.util.List;
import java.util.Set;
+import java.util.function.Supplier;
import java.util.stream.Collectors;
import org.hamcrest.Matchers;
@@ -13,6 +17,8 @@
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
+import com.networknt.schema.SpecVersion.VersionFlag;
+import com.networknt.schema.utils.CachingSupplier;
class OutputFormatTest {
@@ -29,8 +35,7 @@ private JsonNode getJsonNodeFromJsonData(String jsonFilePath) throws Exception {
@DisplayName("Test Validation Messages")
void testInvalidJson() throws Exception {
InputStream schemaInputStream = OutputFormatTest.class.getResourceAsStream(schemaPath1);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaInputStream, config);
JsonNode node = getJsonNodeFromJsonData("/data/output-format-input.json");
Set errors = schema.validate(node);
@@ -47,4 +52,69 @@ void testInvalidJson() throws Exception {
"/1: property 'z' is not defined in the schema and the schema does not allow additional properties" },
new String[] { "/items/$ref/required", "https://example.com/polygon#/$defs/point/required", "/1", "/1: required property 'y' not found"}));
}
+
+ public static class Detailed implements OutputFormat> {
+ private ValidationMessage format(ValidationMessage message) {
+ Supplier messageSupplier = () -> {
+ StringBuilder builder = new StringBuilder();
+ builder.append("[");
+ builder.append(message.getInstanceLocation().toString());
+ builder.append("] ");
+ JsonNode value = message.getInstanceNode();
+ if (!value.isObject() && !value.isArray()) {
+ builder.append("with value ");
+ builder.append("'");
+ builder.append(value.asText());
+ builder.append("'");
+ builder.append(" ");
+ }
+ builder.append(message.getError());
+
+ return builder.toString();
+ };
+ return ValidationMessage.builder()
+ .messageSupplier(new CachingSupplier<>(messageSupplier))
+ .evaluationPath(message.getEvaluationPath())
+ .instanceLocation(message.getInstanceLocation())
+ .instanceNode(message.getInstanceNode())
+ .schemaLocation(message.getSchemaLocation())
+ .schemaNode(message.getSchemaNode())
+ .arguments(message.getArguments())
+ .build();
+ }
+
+ @Override
+ public Set format(JsonSchema jsonSchema, Set validationMessages,
+ ExecutionContext executionContext, ValidationContext validationContext) {
+ return validationMessages.stream().map(this::format).collect(Collectors.toCollection(LinkedHashSet::new));
+ }
+ }
+
+ public static final OutputFormat> DETAILED = new Detailed();
+
+ @Test
+ void customFormat() {
+ String schemaData = "{\n"
+ + " \"properties\": {\n"
+ + " \"type\": {\n"
+ + " \"enum\": [\n"
+ + " \"book\",\n"
+ + " \"author\"\n"
+ + " ]\n"
+ + " },\n"
+ + " \"id\": {\n"
+ + " \"type\": \"string\"\n"
+ + " }\n"
+ + " }\n"
+ + "}";
+ JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012)
+ .getSchema(schemaData, InputFormat.JSON, SchemaValidatorsConfig.builder().build());
+ String inputData = "{\n"
+ + " \"type\": \"cat\",\n"
+ + " \"id\": 1\n"
+ + "}";
+ List messages = schema.validate(inputData, InputFormat.JSON, DETAILED).stream().collect(Collectors.toList());
+ assertEquals("[/type] with value 'cat' does not have a value in the enumeration [book, author]", messages.get(0).getMessage());
+ assertEquals("[/id] with value '1' integer found, string expected", messages.get(1).getMessage());
+ }
}
diff --git a/src/test/java/com/networknt/schema/OutputUnitTest.java b/src/test/java/com/networknt/schema/OutputUnitTest.java
index 035aa7073..35d3a9717 100644
--- a/src/test/java/com/networknt/schema/OutputUnitTest.java
+++ b/src/test/java/com/networknt/schema/OutputUnitTest.java
@@ -96,8 +96,7 @@ public class OutputUnitTest {
@Test
void annotationCollectionList() throws JsonProcessingException {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = inputData1;
@@ -114,8 +113,7 @@ void annotationCollectionList() throws JsonProcessingException {
@Test
void annotationCollectionHierarchical() throws JsonProcessingException {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = inputData1;
@@ -132,8 +130,7 @@ void annotationCollectionHierarchical() throws JsonProcessingException {
@Test
void annotationCollectionHierarchical2() throws JsonProcessingException {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = inputData2;
@@ -182,8 +179,7 @@ void formatAnnotation(FormatInput formatInput) {
+ " \"format\": \""+formatInput.format+"\"\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(formatSchema, config);
OutputUnit outputUnit = schema.validate("\"inval!i:d^(abc]\"", InputFormat.JSON, OutputFormat.LIST, executionConfiguration -> {
executionConfiguration.getExecutionConfig().setAnnotationCollectionEnabled(true);
@@ -202,8 +198,7 @@ void formatAssertion(FormatInput formatInput) {
+ " \"format\": \""+formatInput.format+"\"\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(formatSchema, config);
OutputUnit outputUnit = schema.validate("\"inval!i:d^(abc]\"", InputFormat.JSON, OutputFormat.LIST, executionConfiguration -> {
executionConfiguration.getExecutionConfig().setAnnotationCollectionEnabled(true);
@@ -222,8 +217,7 @@ void typeUnion() {
+ " \"type\": [\"string\",\"array\"]\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(typeSchema, config);
OutputUnit outputUnit = schema.validate("1", InputFormat.JSON, OutputFormat.LIST, executionConfiguration -> {
executionConfiguration.getExecutionConfig().setAnnotationCollectionEnabled(true);
@@ -273,8 +267,7 @@ void unevaluatedProperties() throws JsonProcessingException {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012,
builder -> builder.schemaLoaders(schemaLoaders -> schemaLoaders.schemas(external)));
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
// The following checks if the heirarchical output format is correct with multiple unevaluated properties
@@ -323,8 +316,7 @@ void anyOf() throws JsonProcessingException {
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "{\r\n"
@@ -346,8 +338,7 @@ void listAssertionMapper() {
+ " \"type\": \"string\"\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(formatSchema, config);
OutputUnit outputUnit = schema.validate("1234", InputFormat.JSON, new OutputFormat.List(a -> a));
assertFalse(outputUnit.isValid());
@@ -362,8 +353,7 @@ void hierarchicalAssertionMapper() {
+ " \"type\": \"string\"\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(formatSchema, config);
OutputUnit outputUnit = schema.validate("1234", InputFormat.JSON, new OutputFormat.Hierarchical(a -> a));
assertFalse(outputUnit.isValid());
diff --git a/src/test/java/com/networknt/schema/PatternPropertiesValidatorTest.java b/src/test/java/com/networknt/schema/PatternPropertiesValidatorTest.java
index c21d7ef5b..14c45cbe4 100644
--- a/src/test/java/com/networknt/schema/PatternPropertiesValidatorTest.java
+++ b/src/test/java/com/networknt/schema/PatternPropertiesValidatorTest.java
@@ -52,8 +52,9 @@ public void testInvalidPatternPropertiesValidator() throws Exception {
@Test
public void testInvalidPatternPropertiesValidatorECMA262() throws Exception {
Assertions.assertThrows(JsonSchemaException.class, () -> {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setRegularExpressionFactory(JoniRegularExpressionFactory.getInstance());
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .regularExpressionFactory(JoniRegularExpressionFactory.getInstance())
+ .build();
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V4);
JsonSchema schema = factory.getSchema("{\"patternProperties\":6}", config);
@@ -78,8 +79,7 @@ void message() {
+ " }\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "{\n"
+ " \"valid_array\": [\"array1_value\", \"array2_value\"],\n"
@@ -130,8 +130,7 @@ void annotation() {
+ " }\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "{\n"
+ " \"test\": 5\n"
diff --git a/src/test/java/com/networknt/schema/PrefixItemsValidatorTest.java b/src/test/java/com/networknt/schema/PrefixItemsValidatorTest.java
index a06eda485..9b561d6de 100644
--- a/src/test/java/com/networknt/schema/PrefixItemsValidatorTest.java
+++ b/src/test/java/com/networknt/schema/PrefixItemsValidatorTest.java
@@ -56,8 +56,7 @@ void messageInvalid() {
+ " \"prefixItems\": [{\"type\": \"string\"},{\"type\": \"integer\"}]"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "[1, \"x\"]";
Set messages = schema.validate(inputData, InputFormat.JSON);
@@ -83,8 +82,7 @@ void messageValid() {
+ " \"prefixItems\": [{\"type\": \"string\"},{\"type\": \"integer\"}]"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "[\"x\", 1, 1]";
Set messages = schema.validate(inputData, InputFormat.JSON);
@@ -103,8 +101,7 @@ void messageInvalidAdditionalItems() {
+ " \"items\": false"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "[\"x\", 1, 1, 2]";
Set messages = schema.validate(inputData, InputFormat.JSON);
@@ -135,15 +132,12 @@ void walkNull() {
+ " ]\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.addItemWalkListener(new JsonSchemaWalkListener() {
-
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().itemWalkListener(new JsonSchemaWalkListener() {
@Override
public WalkFlow onWalkStart(WalkEvent walkEvent) {
return WalkFlow.CONTINUE;
}
-
+
@Override
public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
@SuppressWarnings("unchecked")
@@ -153,7 +147,7 @@ public void onWalkEnd(WalkEvent walkEvent, Set validationMess
.computeIfAbsent("items", key -> new ArrayList());
items.add(walkEvent);
}
- });
+ }).build();
JsonSchema schema = factory.getSchema(schemaData, config);
ValidationResult result = schema.walk(null, true);
assertTrue(result.getValidationMessages().isEmpty());
@@ -191,26 +185,26 @@ void walkDefaults() throws JsonMappingException, JsonProcessingException {
+ " ]\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
- config.setApplyDefaultsStrategy(new ApplyDefaultsStrategy(true, true, true));
- config.addItemWalkListener(new JsonSchemaWalkListener() {
-
- @Override
- public WalkFlow onWalkStart(WalkEvent walkEvent) {
- return WalkFlow.CONTINUE;
- }
-
- @Override
- public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
- @SuppressWarnings("unchecked")
- List items = (List) walkEvent.getExecutionContext()
- .getCollectorContext()
- .getCollectorMap()
- .computeIfAbsent("items", key -> new ArrayList());
- items.add(walkEvent);
- }
- });
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder()
+ .applyDefaultsStrategy(new ApplyDefaultsStrategy(true, true, true))
+ .itemWalkListener(new JsonSchemaWalkListener() {
+
+ @Override
+ public WalkFlow onWalkStart(WalkEvent walkEvent) {
+ return WalkFlow.CONTINUE;
+ }
+
+ @Override
+ public void onWalkEnd(WalkEvent walkEvent, Set validationMessages) {
+ @SuppressWarnings("unchecked")
+ List items = (List) walkEvent.getExecutionContext()
+ .getCollectorContext()
+ .getCollectorMap()
+ .computeIfAbsent("items", key -> new ArrayList());
+ items.add(walkEvent);
+ }
+ })
+ .build();
JsonSchema schema = factory.getSchema(schemaData, config);
JsonNode input = JsonMapperFactory.getInstance().readTree("[null, null]");
ValidationResult result = schema.walk(input, true);
diff --git a/src/test/java/com/networknt/schema/PropertiesValidatorTest.java b/src/test/java/com/networknt/schema/PropertiesValidatorTest.java
index 887f6ca5d..9717100d5 100644
--- a/src/test/java/com/networknt/schema/PropertiesValidatorTest.java
+++ b/src/test/java/com/networknt/schema/PropertiesValidatorTest.java
@@ -14,12 +14,9 @@ public void testDoesNotThrowWhenApplyingDefaultPropertiesToNonObjects() throws E
Assertions.assertDoesNotThrow(() -> {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V4);
- SchemaValidatorsConfig schemaValidatorsConfig = new SchemaValidatorsConfig();
- schemaValidatorsConfig.setApplyDefaultsStrategy(new ApplyDefaultsStrategy(
- true,
- true,
- true
- ));
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder()
+ .applyDefaultsStrategy(new ApplyDefaultsStrategy(true, true, true))
+ .build();
JsonSchema schema = factory.getSchema("{\"type\":\"object\",\"properties\":{\"foo\":{\"type\":\"object\", \"properties\": {} },\"i-have-default\":{\"type\":\"string\",\"default\":\"foo\"}}}", schemaValidatorsConfig);
JsonNode node = getJsonNodeFromStringContent("{\"foo\": \"bar\"}");
diff --git a/src/test/java/com/networknt/schema/PropertyNamesValidatorTest.java b/src/test/java/com/networknt/schema/PropertyNamesValidatorTest.java
index 9b81d4c04..81a8837cf 100644
--- a/src/test/java/com/networknt/schema/PropertyNamesValidatorTest.java
+++ b/src/test/java/com/networknt/schema/PropertyNamesValidatorTest.java
@@ -39,8 +39,7 @@ void messageInvalid() {
+ " \"propertyNames\": {\"maxLength\": 3}\r\n"
+ "}";
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(schemaData, config);
String inputData = "{\r\n"
+ " \"foo\": {},\r\n"
diff --git a/src/test/java/com/networknt/schema/ReadOnlyValidatorTest.java b/src/test/java/com/networknt/schema/ReadOnlyValidatorTest.java
index 7ac837943..0beeb701f 100644
--- a/src/test/java/com/networknt/schema/ReadOnlyValidatorTest.java
+++ b/src/test/java/com/networknt/schema/ReadOnlyValidatorTest.java
@@ -28,7 +28,7 @@ void givenConfigWriteTrueWhenReadOnlyTrueThenDenies() throws IOException {
ObjectNode node = getJsonNode();
Set errors = loadJsonSchema(true).validate(node);
assertFalse(errors.isEmpty());
- assertEquals("$.firstName: is a readonly field, it cannot be changed",
+ assertEquals("/firstName: is a readonly field, it cannot be changed",
errors.stream().map(e -> e.getMessage()).collect(Collectors.toList()).get(0));
}
@@ -47,8 +47,7 @@ private JsonSchema getJsonSchema(Boolean write) {
}
private SchemaValidatorsConfig createSchemaConfig(Boolean write) {
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setReadOnly(write);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().readOnly(write).build();
return config;
}
diff --git a/src/test/java/com/networknt/schema/RefTest.java b/src/test/java/com/networknt/schema/RefTest.java
index 6a50457b7..f84700fcd 100644
--- a/src/test/java/com/networknt/schema/RefTest.java
+++ b/src/test/java/com/networknt/schema/RefTest.java
@@ -17,8 +17,7 @@ public class RefTest {
@Test
void shouldLoadRelativeClasspathReference() throws JsonMappingException, JsonProcessingException {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(SchemaLocation.of("classpath:///schema/ref-main.json"), config);
String input = "{\r\n"
+ " \"DriverProperties\": {\r\n"
@@ -41,8 +40,7 @@ void shouldLoadRelativeClasspathReference() throws JsonMappingException, JsonPro
@Test
void shouldLoadSchemaResource() throws JsonMappingException, JsonProcessingException {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V202012);
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setPathType(PathType.JSON_POINTER);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = factory.getSchema(SchemaLocation.of("classpath:///schema/ref-main-schema-resource.json"), config);
String input = "{\r\n"
+ " \"DriverProperties\": {\r\n"
diff --git a/src/test/java/com/networknt/schema/SampleTest.java b/src/test/java/com/networknt/schema/SampleTest.java
new file mode 100644
index 000000000..9a74b216e
--- /dev/null
+++ b/src/test/java/com/networknt/schema/SampleTest.java
@@ -0,0 +1,125 @@
+package com.networknt.schema;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Collections;
+import java.util.Set;
+
+import org.junit.jupiter.api.Test;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonMappingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.networknt.schema.SpecVersion.VersionFlag;
+import com.networknt.schema.serialization.JsonMapperFactory;
+
+/**
+ * Sample test.
+ */
+public class SampleTest {
+ @Test
+ void schemaFromSchemaLocationMapping() throws JsonMappingException, JsonProcessingException {
+ JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012, builder -> builder.schemaMappers(
+ schemaMappers -> schemaMappers.mapPrefix("https://www.example.com/schema", "classpath:schema")));
+ /*
+ * This should be cached for performance.
+ */
+ JsonSchema schemaFromSchemaLocation = factory
+ .getSchema(SchemaLocation.of("https://www.example.com/schema/example-ref.json"));
+ /*
+ * By default all schemas are preloaded eagerly but ref resolve failures are not
+ * thrown. You check if there are issues with ref resolving using
+ * initializeValidators()
+ */
+ schemaFromSchemaLocation.initializeValidators();
+ Set errors = schemaFromSchemaLocation.validate("{\"id\": \"2\"}", InputFormat.JSON,
+ executionContext -> executionContext.getExecutionConfig().setFormatAssertionsEnabled(true));
+ assertEquals(1, errors.size());
+ }
+
+ @Test
+ void schemaFromSchemaLocationContent() throws JsonMappingException, JsonProcessingException {
+ String schemaData = "{\"enum\":[1, 2, 3, 4],\"enumErrorCode\":\"Not in the list\"}";
+
+ JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012,
+ builder -> builder.schemaLoaders(schemaLoaders -> schemaLoaders.schemas(
+ Collections.singletonMap("https://www.example.com/schema/example-ref.json", schemaData))));
+ /*
+ * This should be cached for performance.
+ */
+ JsonSchema schemaFromSchemaLocation = factory
+ .getSchema(SchemaLocation.of("https://www.example.com/schema/example-ref.json"));
+ /*
+ * By default all schemas are preloaded eagerly but ref resolve failures are not
+ * thrown. You check if there are issues with ref resolving using
+ * initializeValidators()
+ */
+ schemaFromSchemaLocation.initializeValidators();
+ Set errors = schemaFromSchemaLocation.validate("{\"id\": \"2\"}", InputFormat.JSON,
+ executionContext -> executionContext.getExecutionConfig().setFormatAssertionsEnabled(true));
+ assertEquals(1, errors.size());
+ }
+
+ @Test
+ void schemaFromClasspath() throws JsonMappingException, JsonProcessingException {
+ JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
+ /*
+ * This should be cached for performance.
+ *
+ * Loading from using the retrieval IRI is not recommended as it may cause
+ * confusing when resolving relative $ref when $id is also used.
+ */
+ JsonSchema schemaFromClasspath = factory.getSchema(SchemaLocation.of("classpath:schema/example-ref.json"));
+ /*
+ * By default all schemas are preloaded eagerly but ref resolve failures are not
+ * thrown. You check if there are issues with ref resolving using
+ * initializeValidators()
+ */
+ schemaFromClasspath.initializeValidators();
+ Set errors = schemaFromClasspath.validate("{\"id\": \"2\"}", InputFormat.JSON,
+ executionContext -> executionContext.getExecutionConfig().setFormatAssertionsEnabled(true));
+ assertEquals(1, errors.size());
+ }
+
+ @Test
+ void schemaFromString() throws JsonMappingException, JsonProcessingException {
+ JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
+ /*
+ * This should be cached for performance.
+ *
+ * Loading from a String is not recommended as there is no base IRI to use for
+ * resolving relative $ref.
+ */
+ JsonSchema schemaFromString = factory
+ .getSchema("{\"enum\":[1, 2, 3, 4],\"enumErrorCode\":\"Not in the list\"}");
+ Set errors = schemaFromString.validate("7", InputFormat.JSON,
+ executionContext -> executionContext.getExecutionConfig().setFormatAssertionsEnabled(true));
+ assertEquals(1, errors.size());
+ }
+
+ @Test
+ void schemaFromJsonNode() throws JsonMappingException, JsonProcessingException {
+ JsonSchemaFactory factory = JsonSchemaFactory.getInstance(VersionFlag.V202012);
+ JsonNode schemaNode = JsonMapperFactory.getInstance().readTree(
+ "{\"$schema\": \"http://json-schema.org/draft-06/schema#\", \"properties\": { \"id\": {\"type\": \"number\"}}}");
+ /*
+ * This should be cached for performance.
+ *
+ * Loading from a JsonNode is not recommended as there is no base IRI to use for
+ * resolving relative $ref.
+ *
+ * Note that the V202012 from the factory is the default version if $schema is not
+ * specified. As $schema is specified in the data, V6 is used.
+ */
+ JsonSchema schemaFromNode = factory.getSchema(schemaNode);
+ /*
+ * By default all schemas are preloaded eagerly but ref resolve failures are not
+ * thrown. You check if there are issues with ref resolving using
+ * initializeValidators()
+ */
+ schemaFromNode.initializeValidators();
+ Set errors = schemaFromNode.validate("{\"id\": \"2\"}", InputFormat.JSON,
+ executionContext -> executionContext.getExecutionConfig().setFormatAssertionsEnabled(true));
+ assertEquals(1, errors.size());
+ }
+}
diff --git a/src/test/java/com/networknt/schema/SchemaValidatorsConfigTest.java b/src/test/java/com/networknt/schema/SchemaValidatorsConfigTest.java
index 511eac987..fcfa31304 100644
--- a/src/test/java/com/networknt/schema/SchemaValidatorsConfigTest.java
+++ b/src/test/java/com/networknt/schema/SchemaValidatorsConfigTest.java
@@ -25,6 +25,7 @@
/**
* Test for SchemaValidatorsConfig.
*/
+@SuppressWarnings("deprecation")
class SchemaValidatorsConfigTest {
@Test
void defaultEcma262Validator() {
@@ -46,4 +47,51 @@ void setEcma262Validator() {
assertFalse(config.isEcma262Validator());
}
+ @Test
+ void constructorPathType() {
+ SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ assertEquals(PathType.LEGACY, config.getPathType());
+ }
+
+ @Test
+ void builderPathType() {
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
+ assertEquals(PathType.JSON_POINTER, config.getPathType());
+ }
+
+ @Test
+ void constructorCustomMessageSupported() {
+ SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ assertEquals(true, config.isCustomMessageSupported());
+ }
+
+ @Test
+ void builderCustomMessageSupported() {
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
+ assertEquals(false, config.isCustomMessageSupported());
+ }
+
+ @Test
+ void constructorHandleNullableField() {
+ SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ assertEquals(true, config.isHandleNullableField());
+ }
+
+ @Test
+ void builderHandleNullableField() {
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
+ assertEquals(false, config.isHandleNullableField());
+ }
+
+ @Test
+ void constructorMutable() {
+ SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ assertDoesNotThrow(() -> config.setFailFast(true));
+ }
+
+ @Test
+ void builderImmutable() {
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
+ assertThrows(UnsupportedOperationException.class, () -> config.setFailFast(true));
+ }
}
diff --git a/src/test/java/com/networknt/schema/SharedConfigTest.java b/src/test/java/com/networknt/schema/SharedConfigTest.java
index 6173872ef..b22cea7d4 100644
--- a/src/test/java/com/networknt/schema/SharedConfigTest.java
+++ b/src/test/java/com/networknt/schema/SharedConfigTest.java
@@ -32,9 +32,10 @@ public void onWalkEnd(WalkEvent walkEvent, Set validationMess
public void shouldCallAllKeywordListenerOnWalkStart() throws Exception {
JsonSchemaFactory factory = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7);
- SchemaValidatorsConfig schemaValidatorsConfig = new SchemaValidatorsConfig();
AllKeywordListener allKeywordListener = new AllKeywordListener();
- schemaValidatorsConfig.addKeywordWalkListener(allKeywordListener);
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder()
+ .keywordWalkListener(allKeywordListener)
+ .build();
SchemaLocation draft07Schema = SchemaLocation.of("resource:/draft-07/schema#");
diff --git a/src/test/java/com/networknt/schema/TypeFactoryTest.java b/src/test/java/com/networknt/schema/TypeFactoryTest.java
index 74d33c463..2e5248bc8 100755
--- a/src/test/java/com/networknt/schema/TypeFactoryTest.java
+++ b/src/test/java/com/networknt/schema/TypeFactoryTest.java
@@ -41,11 +41,9 @@ public class TypeFactoryTest {
private static final String[] validNonIntegralNumberValues = { "1.1", "-1.1", "1.10" };
- private final SchemaValidatorsConfig schemaValidatorsConfig = new SchemaValidatorsConfig();
-
@Test
void testIntegralValuesWithJavaSemantics() {
- schemaValidatorsConfig.setJavaSemantics(true);
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder().javaSemantics(true).build();
for (String validValue : validIntegralValues) {
assertSame(JsonType.INTEGER,
getValueNodeType(DecimalNode.valueOf(new BigDecimal(validValue)), schemaValidatorsConfig),
@@ -60,7 +58,7 @@ void testIntegralValuesWithJavaSemantics() {
@Test
void testIntegralValuesWithoutJavaSemantics() {
- schemaValidatorsConfig.setJavaSemantics(false);
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder().javaSemantics(false).build();
for (String validValue : validIntegralValues) {
assertSame(JsonType.NUMBER,
getValueNodeType(DecimalNode.valueOf(new BigDecimal(validValue)), schemaValidatorsConfig),
@@ -75,7 +73,7 @@ void testIntegralValuesWithoutJavaSemantics() {
@Test
void testWithLosslessNarrowing() {
- schemaValidatorsConfig.setLosslessNarrowing(true);
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder().losslessNarrowing(true).build();
for (String validValue : validIntegralValues) {
assertSame(JsonType.INTEGER,
getValueNodeType(DecimalNode.valueOf(new BigDecimal("1.0")), schemaValidatorsConfig), validValue);
@@ -87,7 +85,7 @@ void testWithLosslessNarrowing() {
@Test
void testWithoutLosslessNarrowing() {
- schemaValidatorsConfig.setLosslessNarrowing(false);
+ SchemaValidatorsConfig schemaValidatorsConfig = SchemaValidatorsConfig.builder().losslessNarrowing(false).build();
for (String validValue : validIntegralValues) {
assertSame(JsonType.NUMBER,
getValueNodeType(DecimalNode.valueOf(new BigDecimal("1.0")), schemaValidatorsConfig), validValue);
@@ -101,44 +99,44 @@ void testWithoutLosslessNarrowing() {
@Test
void testObjectValue() {
assertSame(JsonType.OBJECT, getValueNodeType(JsonMapperFactory.getInstance().getNodeFactory().objectNode(),
- schemaValidatorsConfig));
+ SchemaValidatorsConfig.builder().build()));
}
@Test
void testArrayValue() {
assertSame(JsonType.ARRAY,
- getValueNodeType(JsonMapperFactory.getInstance().getNodeFactory().arrayNode(), schemaValidatorsConfig));
+ getValueNodeType(JsonMapperFactory.getInstance().getNodeFactory().arrayNode(), SchemaValidatorsConfig.builder().build()));
}
@Test
void testBooleanValue() {
assertSame(JsonType.BOOLEAN, getValueNodeType(
- JsonMapperFactory.getInstance().getNodeFactory().booleanNode(true), schemaValidatorsConfig));
+ JsonMapperFactory.getInstance().getNodeFactory().booleanNode(true), SchemaValidatorsConfig.builder().build()));
}
@Test
public void testNullValue() {
assertSame(JsonType.NULL,
- getValueNodeType(JsonMapperFactory.getInstance().getNodeFactory().nullNode(), schemaValidatorsConfig));
+ getValueNodeType(JsonMapperFactory.getInstance().getNodeFactory().nullNode(), SchemaValidatorsConfig.builder().build()));
}
@Test
void testMissingValue() {
assertSame(JsonType.UNKNOWN, getValueNodeType(JsonMapperFactory.getInstance().getNodeFactory().missingNode(),
- schemaValidatorsConfig));
+ SchemaValidatorsConfig.builder().build()));
}
@Test
void testIntegerValue() {
assertSame(JsonType.INTEGER, getValueNodeType(JsonMapperFactory.getInstance().getNodeFactory().numberNode(10),
- schemaValidatorsConfig));
+ SchemaValidatorsConfig.builder().build()));
}
@Test
void testBinaryValue() {
assertSame(JsonType.STRING, getValueNodeType(
JsonMapperFactory.getInstance().getNodeFactory().binaryNode("test".getBytes(StandardCharsets.UTF_8)),
- schemaValidatorsConfig));
+ SchemaValidatorsConfig.builder().build()));
}
@Test
diff --git a/src/test/java/com/networknt/schema/TypeValidatorTest.java b/src/test/java/com/networknt/schema/TypeValidatorTest.java
index 487b8142e..b5919f25e 100644
--- a/src/test/java/com/networknt/schema/TypeValidatorTest.java
+++ b/src/test/java/com/networknt/schema/TypeValidatorTest.java
@@ -78,8 +78,7 @@ void testTypeLoose() {
assertEquals(1, messages.stream().filter(m -> "type".equals(m.getType())).count());
// With type loose this has 0 type errors as any item can also be interpreted as an array of 1 item
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setTypeLoose(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().typeLoose(true).build();
JsonSchema typeLoose = factory.getSchema(schemaData, config);
messages = typeLoose.validate(inputData, InputFormat.JSON);
assertEquals(0, messages.size());
diff --git a/src/test/java/com/networknt/schema/UriMappingTest.java b/src/test/java/com/networknt/schema/UriMappingTest.java
index 3616704f7..332fb1c48 100644
--- a/src/test/java/com/networknt/schema/UriMappingTest.java
+++ b/src/test/java/com/networknt/schema/UriMappingTest.java
@@ -15,23 +15,21 @@
*/
package com.networknt.schema;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.networknt.schema.JsonSchemaFactory.Builder;
-import com.networknt.schema.resource.MapSchemaMapper;
-import com.networknt.schema.resource.SchemaMapper;
-
-import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
-import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.URL;
-import java.net.UnknownHostException;
import java.util.HashMap;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.fail;
+import org.junit.jupiter.api.Test;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.networknt.schema.JsonSchemaFactory.Builder;
+import com.networknt.schema.resource.MapSchemaMapper;
+import com.networknt.schema.resource.SchemaMapper;
public class UriMappingTest {
@@ -123,7 +121,7 @@ public void testValidatorConfigExampleMappings() throws IOException {
URL mappings = UriMappingTest.class.getResource("/draft4/extra/uri_mapping/invalid-schema-uri.json");
JsonSchemaFactory instance = JsonSchemaFactory
.builder(JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V4)).build();
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
SchemaLocation example = SchemaLocation.of("https://example.com/invalid/schema/url");
// first test that attempting to use example URL throws an error
try {
@@ -150,7 +148,7 @@ public void testMappingsForRef() throws IOException {
URL mappings = UriMappingTest.class.getResource("/draft4/extra/uri_mapping/schema-with-ref-mapping.json");
JsonSchemaFactory instance = JsonSchemaFactory.builder(JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V4))
.schemaMappers(schemaMappers -> schemaMappers.add(getUriMappingsFromUrl(mappings))).build();
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().build();
JsonSchema schema = instance.getSchema(SchemaLocation.of("resource:draft4/extra/uri_mapping/schema-with-ref.json"),
config);
assertEquals(0, schema.validate(mapper.readTree("[]")).size());
diff --git a/src/test/java/com/networknt/schema/V4JsonSchemaTest.java b/src/test/java/com/networknt/schema/V4JsonSchemaTest.java
index 9a71a7a6b..e8f4a4f0a 100644
--- a/src/test/java/com/networknt/schema/V4JsonSchemaTest.java
+++ b/src/test/java/com/networknt/schema/V4JsonSchemaTest.java
@@ -85,8 +85,7 @@ private Set validateFailingFastSchemaFor(final String schemaF
final ObjectMapper objectMapper = new ObjectMapper();
final JsonNode schema = getJsonNodeFromResource(objectMapper, schemaFileName);
final JsonNode dataFile = getJsonNodeFromResource(objectMapper, dataFileName);
- final SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFailFast(true);
+ final SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().failFast(true).build();
return JsonSchemaFactory
.builder(JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V4))
.build()
diff --git a/src/test/java/com/networknt/schema/ValidationMessageHandlerTest.java b/src/test/java/com/networknt/schema/ValidationMessageHandlerTest.java
new file mode 100644
index 000000000..a0b9c3cec
--- /dev/null
+++ b/src/test/java/com/networknt/schema/ValidationMessageHandlerTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.networknt.schema;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.Test;
+
+import com.networknt.schema.SpecVersion.VersionFlag;
+
+/**
+ * ValidationMessageHandlerTest.
+ */
+class ValidationMessageHandlerTest {
+ @Test
+ void errorMessage() {
+ String schemaData = "{\r\n"
+ + " \"type\": \"object\",\r\n"
+ + " \"required\": [\r\n"
+ + " \"foo\"\r\n"
+ + " ],\r\n"
+ + " \"properties\": {\r\n"
+ + " \"foo\": {\r\n"
+ + " \"type\": \"integer\"\r\n"
+ + " }\r\n"
+ + " },\r\n"
+ + " \"additionalProperties\": false,\r\n"
+ + " \"errorMessage\": {\r\n"
+ + " \"type\": \"should be an object\",\r\n"
+ + " \"required\": \"should have property foo\",\r\n"
+ + " \"additionalProperties\": \"should not have properties other than foo\"\r\n"
+ + " }\r\n"
+ + "}";
+ String inputData = "{\r\n"
+ + " \"foo\": \"a\",\r\n"
+ + " \"bar\": 2\r\n"
+ + "}";
+ JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData,
+ SchemaValidatorsConfig.builder().errorMessageKeyword("errorMessage").build());
+ List messages = schema.validate(inputData, InputFormat.JSON).stream().collect(Collectors.toList());
+ assertFalse(messages.isEmpty());
+ assertEquals("/foo", messages.get(0).getInstanceLocation().toString());
+ assertEquals("should be an object", messages.get(0).getMessage());
+ assertEquals("", messages.get(1).getInstanceLocation().toString());
+ assertEquals("should not have properties other than foo", messages.get(1).getMessage());
+ }
+
+}
diff --git a/src/test/java/com/networknt/schema/format/IriFormatTest.java b/src/test/java/com/networknt/schema/format/IriFormatTest.java
index 112f726f3..b371b1b47 100644
--- a/src/test/java/com/networknt/schema/format/IriFormatTest.java
+++ b/src/test/java/com/networknt/schema/format/IriFormatTest.java
@@ -15,7 +15,8 @@
*/
package com.networknt.schema.format;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Set;
@@ -34,9 +35,8 @@ void uriShouldPass() {
String schemaData = "{\r\n"
+ " \"format\": \"iri\"\r\n"
+ "}";
-
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFormatAssertionsEnabled(true);
+
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set messages = schema.validate("\"https://test.com/assets/product.pdf\"",
InputFormat.JSON);
@@ -48,9 +48,8 @@ void queryWithBracketsShouldFail() {
String schemaData = "{\r\n"
+ " \"format\": \"iri\"\r\n"
+ "}";
-
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFormatAssertionsEnabled(true);
+
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set messages = schema.validate("\"https://test.com/assets/product.pdf?filter[test]=1\"",
InputFormat.JSON);
@@ -63,22 +62,20 @@ void queryWithEncodedBracketsShouldPass() {
+ " \"format\": \"iri\"\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFormatAssertionsEnabled(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set messages = schema.validate("\"https://test.com/assets/product.pdf?filter%5Btest%5D=1\"",
InputFormat.JSON);
assertTrue(messages.isEmpty());
}
-
+
@Test
void iriShouldPass() {
String schemaData = "{\r\n"
+ " \"format\": \"iri\"\r\n"
+ "}";
-
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFormatAssertionsEnabled(true);
+
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set messages = schema.validate("\"https://test.com/assets/produktdatenblätter.pdf\"",
InputFormat.JSON);
diff --git a/src/test/java/com/networknt/schema/format/IriReferenceFormatTest.java b/src/test/java/com/networknt/schema/format/IriReferenceFormatTest.java
index eba077115..445937b00 100644
--- a/src/test/java/com/networknt/schema/format/IriReferenceFormatTest.java
+++ b/src/test/java/com/networknt/schema/format/IriReferenceFormatTest.java
@@ -15,7 +15,8 @@
*/
package com.networknt.schema.format;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Set;
@@ -34,9 +35,8 @@ void uriShouldPass() {
String schemaData = "{\r\n"
+ " \"format\": \"iri-reference\"\r\n"
+ "}";
-
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFormatAssertionsEnabled(true);
+
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set messages = schema.validate("\"https://test.com/assets/product.pdf\"",
InputFormat.JSON);
@@ -48,9 +48,8 @@ void queryWithBracketsShouldFail() {
String schemaData = "{\r\n"
+ " \"format\": \"iri-reference\"\r\n"
+ "}";
-
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFormatAssertionsEnabled(true);
+
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set messages = schema.validate("\"https://test.com/assets/product.pdf?filter[test]=1\"",
InputFormat.JSON);
@@ -63,8 +62,7 @@ void queryWithEncodedBracketsShouldPass() {
+ " \"format\": \"iri-reference\"\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFormatAssertionsEnabled(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set messages = schema.validate("\"https://test.com/assets/product.pdf?filter%5Btest%5D=1\"",
InputFormat.JSON);
@@ -76,9 +74,8 @@ void iriShouldPass() {
String schemaData = "{\r\n"
+ " \"format\": \"iri-reference\"\r\n"
+ "}";
-
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFormatAssertionsEnabled(true);
+
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set messages = schema.validate("\"https://test.com/assets/produktdatenblätter.pdf\"",
InputFormat.JSON);
diff --git a/src/test/java/com/networknt/schema/format/UriFormatTest.java b/src/test/java/com/networknt/schema/format/UriFormatTest.java
index 0cac5ff46..6584ef4fe 100644
--- a/src/test/java/com/networknt/schema/format/UriFormatTest.java
+++ b/src/test/java/com/networknt/schema/format/UriFormatTest.java
@@ -15,7 +15,8 @@
*/
package com.networknt.schema.format;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.Set;
@@ -35,8 +36,7 @@ void uriShouldPass() {
+ " \"format\": \"uri\"\r\n"
+ "}";
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFormatAssertionsEnabled(true);
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set messages = schema.validate("\"https://test.com/assets/product.pdf\"",
InputFormat.JSON);
@@ -48,9 +48,8 @@ void queryWithBracketsShouldFail() {
String schemaData = "{\r\n"
+ " \"format\": \"uri\"\r\n"
+ "}";
-
- SchemaValidatorsConfig config = new SchemaValidatorsConfig();
- config.setFormatAssertionsEnabled(true);
+
+ SchemaValidatorsConfig config = SchemaValidatorsConfig.builder().formatAssertionsEnabled(true).build();
JsonSchema schema = JsonSchemaFactory.getInstance(VersionFlag.V202012).getSchema(schemaData, config);
Set