org.everit.json.schema.SchemaException Java Examples

private Schema.Builder<?> loadForExplicitType(String typeString) {
    switch (typeString) {
    case "string":
        return buildStringSchema().requiresString(true);
    case "integer":
        return buildNumberSchema().requiresInteger(true);
    case "number":
        return buildNumberSchema();
    case "boolean":
        return BooleanSchema.builder();
    case "null":
        return NullSchema.builder();
    case "array":
        return buildArraySchema();
    case "object":
        return buildObjectSchema();
    default:
        throw new SchemaException(schemaJson.ls.locationOfCurrentObj(), format("unknown type: [%s]", typeString));
    }
}
 

/**
 * Queries from {@code document} based on this pointer.
 *
 * @return a DTO containing the query result and the root document containing the query result.
 * @throws IllegalArgumentException
 *         if the pointer does not start with {@code '#'}.
 */
public QueryResult query() {
    JSONObject document = documentProvider.get();
    if (fragment.isEmpty()) {
        return new QueryResult(document, document);
    }
    String[] path = fragment.split("/");
    if ((path[0] == null) || !path[0].startsWith("#")) {
        throw new IllegalArgumentException("JSON pointers must start with a '#'");
    }
    try {
        JSONObject result = queryFrom(document);
        return new QueryResult(document, result);
    } catch (JSONPointerException e) {
        throw new SchemaException(e.getMessage());
    }
}
 

@Test
public void unknownTypeException() {
    try {
        SchemaLoader.load(get("unknownType"));
        fail("did not throw exception for unknown type");
    } catch (SchemaException actual) {
        SchemaException expected = new SchemaException("#/properties/prop", "unknown type: [integgggger]");
        assertEquals(expected, actual);
    }
}
 

/**
 * Queries from {@code document} based on this pointer.
 *
 * @return a DTO containing the query result and the root document containing the query result.
 * @throws IllegalArgumentException
 *         if the pointer does not start with {@code '#'}.
 */
public QueryResult query() {
    JsonObject document = documentProvider.get();
    if (fragment.isEmpty()) {
        return new QueryResult(document, document);
    }
    JsonObject foundById = ReferenceLookup.lookupObjById(document, fragment);
    if (foundById != null) {
        return new QueryResult(document, foundById);
    }
    String[] path = fragment.split("/");
    if ((path[0] == null) || !path[0].startsWith("#")) {
        throw new IllegalArgumentException("JSON pointers must start with a '#'");
    }
    try {
        JsonValue result;
        LinkedList<String> tokens = new LinkedList<>(asList(path));
        tokens.poll();
        if (tokens.isEmpty()) {
            result = document;
        } else {
            result = queryFrom(document, tokens);
        }
        return new QueryResult(document, result);
    } catch (JSONPointerException e) {
        throw new SchemaException(e.getMessage());
    }
}
 

@Test
public void unknownMetaSchemaException() {
    try {
        SchemaLoader.load(get("unknownMetaSchema"));
        fail("did not throw exception");
    } catch (SchemaException e) {
        assertEquals("#", e.getSchemaLocation());
    }
}
 

@Test
public void multiplexerFailure() {
    exc.expect(SchemaException.class);
    exc.expectMessage("#: expected type is one of Boolean or String, found: Integer");
    INT.canBe(String.class, str -> {
    })
            .or(Boolean.class, bool -> {
            })
            .requireAny();
}
 

@Test
public void multiplexFailureForNullValue() {
    exc.expect(SchemaException.class);
    exc.expectMessage("#: expected type is one of Boolean or String, found: null");
    withLs(JsonValue.of(null)).canBe(String.class, s -> {
    })
            .or(Boolean.class, b -> {
            })
            .requireAny();
}
 

@Test
public void booleanCannotBeSchemaIfV4() {
    Consumer<JsonValue> ifSchema = spy(schemaConsumer());
    JsonValue subject = withLs(JsonValue.of(true));
    try {
        subject.canBeSchema(ifSchema).requireAny();
        fail("did not throw exception");
    } catch (SchemaException e) {
        assertEquals("#: expected type is one of JsonObject, found: Boolean", e.getMessage());
        verify(ifSchema, never()).accept(any());
    }
}
 

@Test
public void canBeSchemaWithV6hasProperExceptionMessage() {
    Consumer<JsonValue> ifSchema = spy(schemaConsumer());
    JsonValue subject = asV6Value(42);
    try {
        subject.canBeSchema(ifSchema).requireAny();
    } catch (SchemaException e) {
        assertEquals("#: expected type is one of Boolean or JsonObject, found: Integer", e.getMessage());
    }
    verify(ifSchema, never()).accept(subject);
}
 

@Test
public void testCreateSchemaException() {
    LoadingState subject = emptySubject();
    SchemaException actual = subject.createSchemaException("message");
    assertEquals("#: message", actual.getMessage());
    assertEquals(JSONPointer.builder().build().toURIFragment(), actual.getSchemaLocation());
}
 

@Test
public void testChildForFailure_NotFound() {
    LoadingState ls = helloWorldObjState();
    try {
        ls.childFor("nonexistent");
        fail("did not throw exception for nonexistent key");
    } catch (SchemaException e) {
        SchemaException expected = new SchemaException("#", "key [nonexistent] not found");
        assertEquals(expected, e);
    }
}
 

@Test
public void testChildForArrayFailure_NotFound() {
    LoadingState subject = singleElemArrayState();
    try {
        subject.childFor(1);
        fail("did not throw exception");
    } catch (SchemaException e) {
        SchemaException expected = new SchemaException("#", "array index [1] is out of bounds");
        assertEquals(expected, e);
    }
}
 

@Test
public void invalidArrayIndex() {
    try {
        singleElemArrayState().childFor("key");
        fail("did not throw exception");
    } catch (SchemaException e) {
        SchemaException expected = new SchemaException("#", "[key] is not an array index");
        assertEquals(expected, e);
    }
}
 

@Test(expected = SchemaException.class)
public void sameDocumentNotFound() {
    JsonPointerEvaluator pointer = JsonPointerEvaluator.forDocument(rootSchemaJson, "#/definitions/NotFound");
    JsonObject actual = pointer.query().getQueryResult().requireObject();
    assertEquals("dummy schema at #/definitions/Bar", actual.require("description").requireString());
    assertEquals("http://localhost:1234/folder/", actual.ls.id.toString());
    assertEquals(new SchemaLocation(asList("definitions", "Bar")), actual.ls.pointerToCurrentObj);
}
 

@Test
public void schemaExceptionForInvalidURI() {
    try {
        SchemaClient schemaClient = mock(SchemaClient.class);
        JsonPointerEvaluator subject = JsonPointerEvaluator.forURL(schemaClient, "||||",
                createLoadingState(schemaClient, "#/definitions/Foo"));
        subject.query();
        fail("did not throw exception");
    } catch (SchemaException e) {
        assertThat(e.toJSON(), sameJsonAs(LOADER.readObj("pointer-eval-non-uri-failure.json")));
    }
}
 

@Test(expected = SchemaException.class)
public void typeBasedMultiplexerFailure() {
    new TypeBasedMultiplexer("foo")
            .ifObject().then(o -> {
    })
            .ifIs(JSONArray.class).then(o -> {
    })
            .requireAny();
}
 

private void assertSchemaException(SchemaLoader.SchemaLoaderBuilder loaderBuilder) {
    try {
        loaderBuilder.build();
        fail("did not throw exception");
    } catch (SchemaException e) {
        assertEquals("#", e.getSchemaLocation());
    }
}
 

@Test
public void testRequireWithConsumerFailure() {
    expExc.expect(SchemaException.class);
    expExc.expectMessage("#: required key [aaa] not found");
    Consumer<JsonValue> consumer = mockConsumer();
    subject().require("aaa", consumer);
    verify(consumer, never()).accept(any());
}
 

/**
 * 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);
  }
}
 

/**
 * Constructor.
 *
 * @param builder
 *         the builder containing the properties. Only {@link SchemaLoaderBuilder#id} is
 *         nullable.
 * @throws NullPointerException
 *         if any of the builder properties except {@link SchemaLoaderBuilder#id id} is
 *         {@code null}.
 */
public SchemaLoader(SchemaLoaderBuilder builder) {
    Object effectiveRootSchemaJson = builder.rootSchemaJson == null
            ? builder.schemaJson
            : builder.rootSchemaJson;
    Optional<String> schemaKeywordValue = extractSchemaKeywordValue(effectiveRootSchemaJson);
    SpecificationVersion specVersion;
    if (schemaKeywordValue.isPresent()) {
        try {
            specVersion = SpecificationVersion.getByMetaSchemaUrl(schemaKeywordValue.get());
        } catch (IllegalArgumentException e) {
            if (builder.specVersionIsExplicitlySet) {
                specVersion = builder.specVersion;
            } else {
                throw new SchemaException("#", "could not determine version");
            }
        }
    } else {
        specVersion = builder.specVersion;
    }
    this.config = new LoaderConfig(builder.schemaClient,
            builder.formatValidators,
            builder.schemasByURI,
            specVersion,
            builder.useDefaults,
            builder.nullableSupport,
            builder.regexpFactory);
    this.ls = new LoadingState(config,
            builder.pointerSchemas,
            effectiveRootSchemaJson,
            builder.schemaJson,
            builder.id,
            builder.pointerToCurrentObj,
            builder.subschemaRegistries);
}
 

@Test(expected = SchemaException.class)
public void requireMappingFailsForHiddenKey() {
    createSubject().requireMapping("minimum", val -> true);
}
 

private SchemaException failureOfMissingKey(String key) {
    return ls.createSchemaException(format("required key [%s] not found", key));
}
 

@Test(expected = SchemaException.class)
public void invalidItemsArraySchema() {
    SchemaLoader.load(get("invalidItemsArraySchema"));
}
 

@Test(expected = SchemaException.class)
public void invalidArrayItemSchema() {
    SchemaLoader.load(get("invalidArrayItemSchema"));
}
 

@Test(expected = SchemaException.class)
public void invalidAdditionalItems() {
    SchemaLoader.load(get("invalidAdditionalItems"));
}
 

@Test
public void testRequireWithFunctionFailure() {
    expExc.expect(SchemaException.class);
    expExc.expectMessage("#: required key [aaa] not found");
    subject().requireMapping("aaa", val -> false);
}
 

protected SchemaException multiplexFailure() {
    return ls.createSchemaException(typeOfValue(), actions.keySet());
}
 

@Override
protected SchemaException multiplexFailure() {
    Set<Class<?>> expectedTypes = new HashSet<>(actions.keySet());
    expectedTypes.add(Boolean.class);
    return ls.createSchemaException(typeOfValue(), expectedTypes);
}
 

/**
 * Checks if the {@code obj} is an instance of any previously set classes (by {@link #ifIs(Class)}
 * or {@link #ifObject()}), performs the mapped action of found or throws with a
 * {@link SchemaException}.
 */
public void requireAny() {
    orElse(obj -> {
        throw new SchemaException(keyOfObj, new ArrayList<Class<?>>(actions.keySet()), obj);
    });
}
 

SchemaException createSchemaException(String message) {
    return new SchemaException(locationOfCurrentObj(), message);
}