org.everit.json.schema.loader.SchemaLoader Java Examples

/**
 * Find and analyze differences between two JSON schemas.
 *
 * @param original Original/Previous/First/Left JSON schema representation
 * @param updated  Updated/Next/Second/Right JSON schema representation
 * @return an object to access the found differences: Original -> Updated
 * @throws IllegalArgumentException if the input is not a valid representation of a JsonSchema
 */
public static DiffContext findDifferences(String original, String updated) {
    try {
        JSONObject originalJson = MAPPER.readValue(original, JSONObject.class);
        JSONObject updatedJson = MAPPER.readValue(updated, JSONObject.class);

        Schema originalSchema = SchemaLoader.builder()
            .schemaJson(originalJson)
            .build().load().build();

        Schema updatedSchema = SchemaLoader.builder()
            .schemaJson(updatedJson)
            .build().load().build();

        return findDifferences(originalSchema, updatedSchema);

    } catch (JsonProcessingException e) {
        throw new IllegalStateException(e);
    }
}
 

@Test
public void test() throws Exception {
    System.out.println(JettyWrapper.class
            .getResource("/org/everit/json/schema/relative-uri/").toExternalForm());

    JettyWrapper jetty = new JettyWrapper("/org/everit/json/schema/relative-uri");
    jetty.start();
    try {
        SchemaLoader.builder()
                .resolutionScope("http://localhost:1234/schema/")
                .schemaJson(
                        new JSONObject(new JSONTokener(IOUtils.toString(getClass().getResourceAsStream(
                                "/org/everit/json/schema/relative-uri/schema/main.json")))))
                .build().load().build();
    } finally {
        jetty.stop();
    }
}
 

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");
    }
}
 

public EventTypeValidator build(final EventType eventType) {
    final List<Function<JSONObject, Optional<ValidationError>>> validators = new ArrayList<>(2);

    // 1. We always validate schema.
    final Schema schema = SchemaLoader.builder()
            .schemaJson(loader.effectiveSchema(eventType))
            .addFormatValidator(new RFC3339DateTimeValidator())
            .build()
            .load()
            .build();
    validators.add((evt) -> validateSchemaConformance(schema, evt));

    // 2. in case of data or business event type we validate occurred_at
    if (eventType.getCategory() == EventCategory.DATA || eventType.getCategory() == EventCategory.BUSINESS) {
        validators.add(this::validateOccurredAt);
    }

    return (event) -> validators
            .stream()
            .map(validator -> validator.apply(event))
            .filter(Optional::isPresent)
            .findFirst()
            .orElse(Optional.empty());
}
 

@Test
public void checkJsonSchemaCompatibility() throws Exception {
    final JSONArray testCases = new JSONArray(
            readFile("invalid-schema-evolution-examples.json"));

    for (final Object testCaseObject : testCases) {
        final JSONObject testCase = (JSONObject) testCaseObject;
        final Schema original = SchemaLoader.load(testCase.getJSONObject("original_schema"));
        final Schema update = SchemaLoader.load(testCase.getJSONObject("update_schema"));
        final List<String> errorMessages = testCase
                .getJSONArray("errors")
                .toList()
                .stream()
                .map(Object::toString)
                .collect(toList());
        final String description = testCase.getString("description");

        assertThat(description, service.collectChanges(original, update).stream()
                .map(change -> change.getType().toString() + " " + change.getJsonPath())
                .collect(toList()), is(errorMessages));

    }
}
 

@Test
public void validateEmptyObject() throws IOException {
    JSONObject jsonSchema = new JSONObject(new JSONTokener(IOUtils.toString(
            new InputStreamReader(getClass().getResourceAsStream("/org/everit/json/schema/json-schema-draft-04.json")))));

    JSONObject jsonSubject = new JSONObject("{\n" +
            "  \"type\": \"object\",\n" +
            "  \"properties\": {}\n" +
            "}");

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

/** get schema-builder preloaded with JSON draft V7 meta-schema */
private SchemaLoaderBuilder getSchemaLoader() {
    final SchemaLoaderBuilder builder = SchemaLoader
        .builder()
        .draftV7Support()
        .schemaClient(downloader);

    // registers the local schema with the draft-07 url
    builder.registerSchemaByURI(JSON_SCHEMA_URI_HTTP, jsonSchemaObject);

    return builder;
}
 

@Test
public void issue345() {
    JSONObject rawSchema = LOADER.readObj("issue345.json");
    Schema notSchema = SchemaLoader.builder()
        .schemaJson(rawSchema)
        .build().load().build();
    assertThat(new JSONObject(notSchema.toString()), sameJsonAs(rawSchema));
}
 

@Test
public void toStringNoFormat() {
    JSONObject rawSchemaJson = ResourceLoader.DEFAULT.readObj("tostring/stringschema.json");
    rawSchemaJson.remove("format");
    String actual = SchemaLoader.load(rawSchemaJson).toString();
    assertThat(new JSONObject(actual), sameJsonAs(rawSchemaJson));
}
 

@Test
public void toStringNoExplicitType() {
    JSONObject rawSchemaJson = ResourceLoader.DEFAULT.readObj("tostring/stringschema.json");
    rawSchemaJson.remove("type");
    String actual = SchemaLoader.load(rawSchemaJson).toString();
    assertThat(new JSONObject(actual), sameJsonAs(rawSchemaJson));
}
 

@Test
public void regexpFactoryIsUsedByLoader() {
    SchemaLoader loader = SchemaLoader.builder()
            .regexpFactory(new RE2JRegexpFactory())
            .schemaJson(ResourceLoader.DEFAULT.readObj("tostring/stringschema.json"))
            .build();

    StringSchema result = (StringSchema) loader.load().build();

    assertEquals(result.getRegexpPattern().getClass().getSimpleName(), "RE2JRegexp");
}
 

@Test
public void toStringNoExplicitType() {
    JSONObject rawSchemaJson = loader.readObj("tostring/objectschema.json");
    rawSchemaJson.remove("type");
    String actual = SchemaLoader.load(rawSchemaJson).toString();
    assertThat(new JSONObject(actual), sameJsonAs(rawSchemaJson));
}
 

@Test
public void toStringWithUnprocessedProps() {
    JSONObject rawSchemaJson = loader.readObj("tostring/objectschema-unprocessed.json");
    Schema schema = SchemaLoader.load(rawSchemaJson);
    String actual = schema.toString();
    assertThat(new JSONObject(actual), sameJsonAs(rawSchemaJson));
}
 

@Test
public void toStringNoAdditionalProperties() {
    JSONObject rawSchemaJson = loader.readObj("tostring/objectschema.json");
    rawSchemaJson.put("additionalProperties", false);
    Schema schema = SchemaLoader.load(rawSchemaJson);
    String actual = schema.toString();
    assertThat(new JSONObject(actual), sameJsonAs(rawSchemaJson));
}
 

@Test
public void toStringTest() {
    JSONObject rawSchemaJson = ResourceLoader.DEFAULT.readObj("tostring/ref.json");
    String actual = SchemaLoader.load(rawSchemaJson).toString();
    assertTrue(ObjectComparator.deepEquals(rawSchemaJson.query("/properties"),
            new JSONObject(actual).query("/properties")));
}
 

@Test
public void toStringAdditionalItems() {
    JSONObject rawSchemaJson = loader.readObj("tostring/arrayschema-list.json");
    rawSchemaJson.remove("items");
    rawSchemaJson.put("additionalItems", false);
    String actual = SchemaLoader.load(rawSchemaJson).toString();
    assertFalse(new JSONObject(actual).getBoolean("additionalItems"));
}
 

@Test
public void toStringNoExplicitType() {
    JSONObject rawSchemaJson = loader.readObj("tostring/arrayschema-list.json");
    rawSchemaJson.remove("type");
    String actual = SchemaLoader.load(rawSchemaJson).toString();
    assertThat(new JSONObject(actual), sameJsonAs(rawSchemaJson));
}
 

@Test
public void toStringContains() {
    JSONObject rawSchemaJson = loader.readObj("tostring/arrayschema-contains.json");
    String actual = SchemaLoader.builder()
            .draftV6Support()
            .schemaJson(rawSchemaJson)
            .build()
            .load()
            .build()
            .toString();
    assertThat(new JSONObject(actual), sameJsonAs(rawSchemaJson));
}
 

@Test
public void toStringNoExplicitType() {
    JSONObject rawSchemaJson = loader.readObj("numberschema.json");
    rawSchemaJson.remove("type");
    String actual = SchemaLoader.load(rawSchemaJson).toString();
    assertThat(new JSONObject(actual), sameJsonAs(rawSchemaJson));
}
 

@Test
public void toStringReqInteger() {
    JSONObject rawSchemaJson = loader.readObj("numberschema.json");
    rawSchemaJson.put("type", "integer");
    String actual = SchemaLoader.load(rawSchemaJson).toString();
    assertThat(new JSONObject(actual), sameJsonAs(rawSchemaJson));
}
 

/**
 * Check json matches schema
 *
 * @param schema schema obtained from deploy-api
 * @param json   json to be checked
 * @return boolean whether the json matches the schema or not
 */
public boolean matchJsonToSchema(JSONObject schema, JSONObject json) throws Exception {
    SchemaLoader.builder()
            .useDefaults(true)
            .schemaJson(schema)
            .build()
            .load()
            .build()
            .validate(json);
    return true;
}
 

/**
 * Loads JSON schema. The schema may contain remote references.
 *
 * @param schema String containing the JSON schema to load
 * @return loaded {@link Schema}
 * @throws InvalidJsonSchemaException if the schema fails to load
 */
public Schema loadSchema(String schema) {
  try {
    JSONObject rawSchema = new JSONObject(new JSONTokener(schema));
    return SchemaLoader.load(rawSchema);
  } catch (JSONException | SchemaException e) {
    throw new InvalidJsonSchemaException(e);
  }
}
 

@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);
}
 

@Test
public void validateMetaSchema() throws IOException {

    JSONObject jsonSchema = new JSONObject(new JSONTokener(
            IOUtils.toString(
                    new InputStreamReader(getClass().getResourceAsStream("/org/everit/json/schema/json-schema-draft-04.json")))
    ));

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

/**
 * trivial coverage test: cannot cache a schema if it has an invalid $id
 */
@ParameterizedTest
@ValueSource(strings = { ":invalid/uri", "" })
public void registerMetaSchema_invalidRelativeRef_shouldThrow(String uri) {

    JSONObject badSchema = loadJSON(RESOURCE_DEFINITION_SCHEMA_PATH);
    badSchema.put("$id", uri);
    assertThatExceptionOfType(ValidationException.class).isThrownBy(() -> {
        validator.registerMetaSchema(SchemaLoader.builder(), badSchema);
    });
}
 

/**
 * trivial coverage test: cannot cache a schema if it has no $id
 */
@Test
public void registerMetaSchema_nullId_shouldThrow() {
    JSONObject badSchema = loadJSON(RESOURCE_DEFINITION_SCHEMA_PATH);
    badSchema.remove("$id");
    assertThatExceptionOfType(ValidationException.class).isThrownBy(() -> {
        validator.registerMetaSchema(SchemaLoader.builder(), badSchema);
    });
}
 

@BeforeEach
  public void setUp() throws Exception {
    if (sFhir == null) {
//      String path = TestUtilities.resourceNameToFile("fhir.schema.json"); // todo... what should this be?
//      String source = TextFile.fileToString(path);
//      JSONObject rawSchema = new JSONObject(new JSONTokener(source));
//      sFhir = SchemaLoader.load(rawSchema);
      JSONObject rawSchema = new JSONObject(new JSONTokener(TEST_SCHEMA));
      sTest = SchemaLoader.load(rawSchema);
    }
  }
 

private Schema getSchema(File schemaFile) {
  try (InputStream schemaStream = new FileInputStream(schemaFile)) {
    JSONObject rawSchema = new JSONObject(new JSONTokener(schemaStream));
    SchemaLoader loader = SchemaLoader.builder().schemaJson(rawSchema).httpClient(new RelativeClient()).build();
    return loader.load().build();
  } catch (Exception e) {
    throw new RuntimeException("While loading schema " + schemaFile.getAbsolutePath(), e);
  }
}
 

private void loadSchema(String key) {
  File schemaFile = new File(schemaBase, key);
  try (InputStream schemaStream = new FileInputStream(schemaFile)) {
    JSONObject rawSchema = new JSONObject(new JSONTokener(schemaStream));
    schemas.put(key, SchemaLoader.load(rawSchema, new Loader()));
  } catch (Exception e) {
    throw new RuntimeException("While loading schema " + schemaFile.getAbsolutePath(), e);
  }
}