Java Code Examples for org.everit.json.schema.Schema#validate()

@Test
public void configurationPropagationTest() throws URISyntaxException {
    SchemaLoader loader = SchemaLoader.builder()
            .schemaClient(SchemaClient.classPathAwareClient())
            .nullableSupport(true)
            .useDefaults(true)
            .registerSchemaByURI(new URI("urn:uuid:85946d9c-b896-496c-a7ac-6835f4b59f63"), LOADER.readObj("schema-by-urn.json"))
            .addFormatValidator(new CustomFormatValidatorTest.EvenCharNumValidator())
            .schemaJson(LOADER.readObj("schema.json"))
            .build();
    Schema actual = loader.load().build();
    JSONObject instance = LOADER.readObj("instance.json");
    try {
        actual.validate(instance);
        fail("did not throw validation exception");
    } catch (ValidationException e) {
        assertThat(e.toJSON(), sameJsonAs(LOADER.readObj("expected-exception.json")));
    }
    assertEquals(42, instance.get("propWithDefault"));
}
 

public void validateCapabilitySchema(JSONObject capability) {
    try {
        isPlatformInEnv();
        InputStream inputStream = getClass().getResourceAsStream(getPlatform());
        JSONObject rawSchema = new JSONObject(new JSONTokener(inputStream));
        Schema schema = SchemaLoader.load(rawSchema);
        schema.validate(new JSONObject(capability.toString()));
        validateRemoteHosts();
    } catch (ValidationException e) {
        if (e.getCausingExceptions().size() > 1) {
            e.getCausingExceptions().stream()
                .map(ValidationException::getMessage)
                .forEach(System.out::println);
        } else {
            LOGGER.info(e.getErrorMessage());
        }

        throw new ValidationException("Capability json provided is missing the above schema");
    }
}
 

@Override
public void validateObject(final JSONObject modelObject, final JSONObject definitionSchemaObject) throws ValidationException {
    final SchemaLoaderBuilder loader = getSchemaLoader(definitionSchemaObject);

    try {
        final Schema schema = loader.build().load().build();
        schema.validate(modelObject); // throws a ValidationException if this object is invalid
    } catch (final org.everit.json.schema.ValidationException e) {
        throw ValidationException.newScrubbedException(e);
    }
}
 

private boolean validateJson(String source, Schema schema) throws FileNotFoundException, IOException {
    JSONObject jo = new JSONObject(source); // jo = (JsonObject) new com.google.gson.JsonParser().parse(source);
    try {
      schema.validate(jo);
      return true;
    } catch (ValidationException e) {
      System.out.println(e.getMessage());
      return false;
    }
//        e.getCausingExceptions().stream()
////            .map(ValidationException::getMessage)
////            .forEach(System.out::println);
  }
 

private void validateMessage(Schema schema, Object message) {
  final String stringMessage;
  try {
    stringMessage = OBJECT_MAPPER.writeValueAsString(message);
  } catch (Exception e) {
    throw new RuntimeException("While converting to string", e);
  }
  schema.validate(new JSONObject(new JSONTokener(stringMessage)));
}
 

private void validateFile(File targetFile, Schema schema) {
  try (InputStream targetStream = new FileInputStream(targetFile)) {
    schema.validate(new JSONObject(new JSONTokener(targetStream)));
  } catch (Exception e) {
    throw new RuntimeException("Against input " + targetFile, e);
  }
}
 

private Optional<ValidationError> validateSchemaConformance(final Schema schema, final JSONObject evt) {
    try {
        schema.validate(evt);
        return Optional.empty();
    } catch (final ValidationException e) {
        final StringBuilder builder = new StringBuilder();
        recursiveCollectErrors(e, builder);
        return Optional.of(new ValidationError(builder.toString()));
    }
}
 

/**
 * Validates that a JSON string conforms to a {@link Schema}.
 *
 * @param json the JSON string to check
 * @param schema the {@link Schema} that the JSON string should conform to
 * @throws JsonValidationException if the JSON doesn't conform to the schema, containing a {@link
 *     ConstraintViolation} for each message
 */
public void validate(String json, Schema schema) {
  try {
    schema.validate(new JSONObject(json));
  } catch (ValidationException validationException) {
    throw new JsonValidationException(
        validationException.getAllMessages().stream()
            .map(ConstraintViolation::new)
            .collect(toSet()));
  }
}
 

@Test(expected = ValidationException.class)
public void givenInvalidInput_whenValidating_thenInvalid() {

    JSONObject jsonSchema = new JSONObject(new JSONTokener(JSONSchemaUnitTest.class.getResourceAsStream("/schema.json")));
    JSONObject jsonSubject = new JSONObject(new JSONTokener(JSONSchemaUnitTest.class.getResourceAsStream("/product_invalid.json")));

    Schema schema = SchemaLoader.load(jsonSchema);
    schema.validate(jsonSubject);
}
 

@Test
public void givenValidInput_whenValidating_thenValid() {

    JSONObject jsonSchema = new JSONObject(new JSONTokener(JSONSchemaUnitTest.class.getResourceAsStream("/schema.json")));
    JSONObject jsonSubject = new JSONObject(new JSONTokener(JSONSchemaUnitTest.class.getResourceAsStream("/product_valid.json")));

    Schema schema = SchemaLoader.load(jsonSchema);
    schema.validate(jsonSubject);
}
 

private void validateJsonSchema(Object actual, String schemaJson) throws IOException {
    SchemaLoader loader = SchemaLoader.builder().schemaJson(new JSONObject(schemaJson)).build();
    Schema schema = loader.load().build();
    schema.validate(toJSONAware(actual));
}