private ProcessingMessage collectSyntaxErrors(final ProcessingReport report) { /* * OK, that's for issue #99 but that's ugly nevertheless. * * We want syntax error messages to appear in the exception text. */ final String msg = syntaxMessages.getMessage("core.invalidSchema"); final ArrayNode arrayNode = JacksonUtils.nodeFactory().arrayNode(); JsonNode node; for (final ProcessingMessage message: report) { node = message.asJson(); if ("syntax".equals(node.path("domain").asText())) arrayNode.add(node); } final StringBuilder sb = new StringBuilder(msg); sb.append("\nSyntax errors:\n"); sb.append(JacksonUtils.prettyPrint(arrayNode)); return new ProcessingMessage().setMessage(sb.toString()); } }
private static String buildMessage(final String key, final JsonNode params, final JsonNode data) { final ProcessingMessage message = new ProcessingMessage() .setMessage(BUNDLE.getMessage(key)); if (params != null) { String name; JsonNode value; for (final JsonNode node: params) { name = node.textValue(); value = data.get(name); message.putArgument(name, valueToArgument(value)); } } return message.getMessage(); }
for (ProcessingMessage processingMessage : validate) { String fieldPointer = ""; if (processingMessage.asJson().get("instance") != null && processingMessage.asJson().get("instance").get("pointer") != null) { fieldPointer = String.valueOf(processingMessage.asJson().get("instance").get("pointer")).replaceAll("\"", ""); " \"xpath\": \"\"" + NEW_LINE + " }"); } else if (String.valueOf(processingMessage.asJson().get("keyword")).equals("\"oneOf\"")) { StringBuilder oneOfErrorMessage = new StringBuilder("oneOf of the following must be specified "); if (fieldPointer.isEmpty()) { )); } else { for (JsonNode jsonNode : processingMessage.asJson().get("reports")) { if (jsonNode.get(0) != null && jsonNode.get(0).get("required") != null && jsonNode.get(0).get("required").get(0) != null) { oneOfErrorMessage.append(String.valueOf(jsonNode.get(0).get("required").get(0))).append(" "); oneOfErrorMessage.append(" but ").append(String.valueOf(processingMessage.asJson().get("matched"))).append(" found"); validationErrors.add(oneOfErrorMessage.toString() + (fieldPointer.isEmpty() ? "" : " for field \"" + fieldPointer + "\"")); } else if (fieldPointer.endsWith("/times") && processingMessage.toString().contains("has properties which are not allowed by the schema") && String.valueOf(processingMessage.asJson().get("schema")).contains("verificationTimes")) { validationErrors.add(processingMessage.getMessage() + " for field \"" + fieldPointer + "\", allowed fields are [\"atLeast\", \"atMost\"]"); } else { validationErrors.add(processingMessage.getMessage() + (fieldPointer.isEmpty() ? "" : " for field \"" + fieldPointer + "\""));
@Override public ProcessingMessage newMessage() { final ProcessingMessage ret = new ProcessingMessage(); if (schema != null) ret.put("schema", schema); if (instance != null) ret.put("instance", instance); return ret; } }
protected final ProcessingMessage newMsg(final FullData data, final MessageBundle bundle, final String key) { return data.newMessage().put("domain", "validation") .put("keyword", keyword).setMessage(bundle.getMessage(key)) .setExceptionProvider(EXCEPTION_PROVIDER); }
protected final ProcessingMessage newMsg(final FullData data) { return data.newMessage().put("domain", "validation") .put("keyword", keyword) .setExceptionProvider(EXCEPTION_PROVIDER); }
throws ProcessingException report.error(newMsg(tree, bundle, "common.dependencies.value.incorrectType") .putArgument("property", name) .putArgument("expected", dependencyTypes) .putArgument("found", type)); return; final int size = node.size(); report.error(newMsg(tree, bundle, "common.array.empty") .put("property", name)); return; element = node.get(index); type = NodeType.getNodeType(element); uniqueElements = set.add(EQUIVALENCE.wrap(element)); if (type == NodeType.STRING) continue; report.error(newMsg(tree, bundle, "common.array.element.incorrectType") .put("property", name).putArgument("index", index) .putArgument("expected", EnumSet.of(NodeType.STRING)) .putArgument("found", type)); report.error(newMsg(tree, bundle, "common.array.duplicateElements") .put("property", name));
throws ProcessingException final JsonNode node = tree.getNode().get(keyword); if (node.isTextual()) { final String found = node.textValue(); if (!typeIsValid(found)) report.error(newMsg(tree, bundle, "common.typeDisallow.primitiveType.unknown") .putArgument("found", found) .putArgument("valid", EnumSet.allOf(NodeType.class))); return; report.error(newMsg(tree, bundle, "common.array.element.incorrectType") .putArgument("index", index) .putArgument("expected", EnumSet.of(OBJECT, STRING)) .putArgument("found", type)); continue; if (!typeIsValid(element.textValue())) report.error(newMsg(tree, bundle, "common.typeDisallow.primitiveType.unknown") .put("index", index) .putArgument("found", element.textValue()) .putArgument("valid", EnumSet.allOf(NodeType.class)));
@Override public void validate(final Processor<FullData, FullData> processor, final ProcessingReport report, final MessageBundle bundle, final FullData data) throws ProcessingException { if (additionalOK) return; final JsonNode instance = data.getInstance().getNode(); final Set<String> fields = Sets.newHashSet(instance.fieldNames()); fields.removeAll(properties); final Set<String> tmp = Sets.newHashSet(); for (final String field: fields) for (final String regex: patternProperties) if (RhinoHelper.regMatch(regex, field)) tmp.add(field); fields.removeAll(tmp); if (fields.isEmpty()) return; /* * Display extra properties in order in the report */ final ArrayNode node = JacksonUtils.nodeFactory().arrayNode(); for (final String field: Ordering.natural().sortedCopy(fields)) node.add(field); report.error(newMsg(data, bundle, "err.common.additionalProperties.notAllowed") .putArgument("unwanted", node)); }
final int size = node.size(); report.error(newMsg(tree, bundle, "emptyArray")); return; boolean uniqueItems = true; final Set<JsonNode> set = Sets.newHashSet(); element = node.get(index); type = NodeType.getNodeType(element); if (type != NodeType.INTEGER) report.error(newMsg(tree, bundle, "incorrectElementType") .put("expected", NodeType.INTEGER) .put("found", type)); else if (element.bigIntegerValue().compareTo(BigInteger.ONE) < 0) report.error(newMsg(tree, bundle, "integerIsNegative") .put("value", element)); uniqueItems = set.add(element);
@Override public void validate(final Processor<FullData, FullData> processor, final ProcessingReport report, final MessageBundle bundle, final FullData data) throws ProcessingException { final Set<String> set = Sets.newLinkedHashSet(required); set.removeAll(Sets.newHashSet(data.getInstance().getNode() .fieldNames())); if (!set.isEmpty()) report.error(newMsg(data, bundle, "err.common.object.missingMembers") .put("required", required) .putArgument("missing", toArrayNode(set))); }
final int size = node.size(); ldo = getNode(tree).get(index); type = NodeType.getNodeType(ldo); if (type != NodeType.OBJECT) { report.error(LDOMsg(tree, bundle, "draftv4.ldo.incorrectType", index) .put("expected", NodeType.OBJECT) .putArgument("found", type)); continue; set = Sets.newHashSet(ldo.fieldNames()); list = Lists.newArrayList(REQUIRED_LDO_PROPERTIES); list.removeAll(set); final ProcessingMessage msg = LDOMsg(tree, bundle, "draftv4.ldo.missingRequired", index); report.error(msg.put("required", REQUIRED_LDO_PROPERTIES) .putArgument("missing", list)); continue; if (ldo.has("schema")) pointers.add(JsonPointer.of(keyword, index, "schema")); if (ldo.has("targetSchema")) pointers.add(JsonPointer.of(keyword, index, "targetSchema")); checkLDO(report, bundle, tree, index);
final Set<String> fields = Sets.newHashSet(instance.fieldNames()); continue; collection = propertyDeps.get(field); set = Sets.newLinkedHashSet(collection); set.removeAll(fields); if (!set.isEmpty()) report.error(newMsg(data, bundle, "err.common.dependencies.missingPropertyDeps") .putArgument("property", field) .putArgument("required", toArrayNode(collection)) .putArgument("missing", toArrayNode(set))); if (!fields.contains(field)) continue; pointer = JsonPointer.of(keyword, field); newData = data.withSchema(tree.append(pointer)); processor.process(report, newData);
@Override public ValidatorList process(final ProcessingReport report, final ValidatorList input) throws ProcessingException { final SchemaContext context = input.getContext(); final JsonNode node = context.getSchema().getNode().get("format"); if (node == null) return input; final String fmt = node.textValue(); final FormatAttribute attr = attributes.get(fmt); if (attr == null) { report.warn(input.newMessage().put("domain", "validation") .put("keyword", "format") .setMessage(bundle.getMessage("warn.format.notSupported")) .putArgument("attribute", fmt)); return input; } final NodeType type = context.getInstanceType(); if (!attr.supportedTypes().contains(type)) return input; final List<KeywordValidator> validators = Lists.newArrayList(input); validators.add(formatValidator(attr)); return new ValidatorList(context, validators); }
final JsonNode schemas = tree.getNode().get(keyword); final int size = schemas.size(); final ObjectNode fullReport = FACTORY.objectNode(); subReport = new ListProcessingReport(report.getLogLevel(), LogLevel.FATAL); ptr = schemaPointer.append(JsonPointer.of(keyword, index)); newData = data.withSchema(tree.setPointer(ptr)); processor.process(subReport, newData); fullReport.put(ptr.toString(), subReport.asJson()); if (subReport.isSuccess()) nrSuccess++; report.error(newMsg(data, bundle, "err.draftv4.allOf.fail") .putArgument("matched", nrSuccess) .putArgument("nrSchemas", size) .put("reports", fullReport));
final NodeType type = NodeType.getNodeType(instance); if (types.contains(type)) { report.error(newMsg(data, bundle, "err.draftv3.disallow.type") .putArgument("found", type) .putArgument("disallowed", toArrayNode(types))); return; final ObjectNode fullReport = FACTORY.objectNode(); subReport = new ListProcessingReport(report.getLogLevel(), LogLevel.FATAL); ptr = schemaPointer.append(JsonPointer.of(keyword, index)); newData = data.withSchema(tree.setPointer(ptr)); processor.process(subReport, newData); fullReport.put(ptr.toString(), subReport.asJson()); if (subReport.isSuccess()) nrSuccess++; report.error(newMsg(data, bundle, "err.draftv3.disallow.schema") .putArgument("matched", nrSuccess) .putArgument("nrSchemas", schemas.size()) .put("reports", fullReport));
@Override public void validate(final Processor<FullData, FullData> processor, final ProcessingReport report, final MessageBundle bundle, final FullData data) throws ProcessingException { final NodeType type = NodeType.getNodeType(data.getInstance().getNode()); if (!types.contains(type)) report.error(newMsg(data, bundle, "err.common.typeNoMatch") .putArgument("found", type) .putArgument("expected", toArrayNode(types))); }
private void validateWithSchema(JsonNode model) { createValidator(); try { ProcessingReport report = validator.validate(model); if (report != null) { List<String> msgs = Lists.newArrayList(); report.forEach(msg -> { if (msg.getLogLevel().compareTo(LogLevel.ERROR) >= 0) { String ptr = msg.asJson().at("/instance/pointer").asText(); msgs.add(String.format("At %s: %s", ptr.isEmpty() ? "/" : ptr, msg.getMessage())); } }); if (!msgs.isEmpty()) { throw new RealizationModelParseException(msgs); } } } catch (ProcessingException e) { e.printStackTrace(); } }
@Override public void validate(final ProcessingReport report, final MessageBundle bundle, final FullData data) throws ProcessingException { final String input = data.getInstance().getNode().textValue(); if (!MACADDR.matcher(input).matches()) report.error(newMsg(data, bundle, "err.format.macAddr.invalid") .putArgument("value", input)); } }
@Override protected void checkKoKo(final ProcessingReport report) throws ProcessingException { final ArgumentCaptor<ProcessingMessage> captor = ArgumentCaptor.forClass(ProcessingMessage.class); verify(report).error(captor.capture()); final ProcessingMessage message = captor.getValue(); final ObjectNode reports = FACTORY.objectNode(); final ArrayNode oneReport = FACTORY.arrayNode(); oneReport.add(MSG.asJson()); reports.put(ptr1.toString(), oneReport); reports.put(ptr2.toString(), oneReport); assertMessage(message) .isValidationError(keyword, BUNDLE.printf("err.common.schema.noMatch", 2)) .hasField("reports", reports); }