/** * Constructor * * @param cfg the validation configuration to use */ public SyntaxValidator(final ValidationConfiguration cfg) { final MessageBundle syntaxMessages = cfg.getSyntaxMessages(); final ProcessorMap<JsonRef, ValueHolder<SchemaTree>, ValueHolder<SchemaTree>> map = new ProcessorMap<JsonRef, ValueHolder<SchemaTree>, ValueHolder<SchemaTree>>(FUNCTION); Dictionary<SyntaxChecker> dict; dict = cfg.getDefaultLibrary().getSyntaxCheckers(); final SyntaxProcessor byDefault = new SyntaxProcessor( cfg.getSyntaxMessages(), dict); map.setDefaultProcessor(byDefault); final Map<JsonRef,Library> libraries = cfg.getLibraries(); JsonRef ref; SyntaxProcessor syntaxProcessor; for (final Map.Entry<JsonRef, Library> entry: libraries.entrySet()) { ref = entry.getKey(); dict = entry.getValue().getSyntaxCheckers(); syntaxProcessor = new SyntaxProcessor(syntaxMessages, dict); map.addEntry(ref, syntaxProcessor); } processor = map.getProcessor(); }
@Override public SchemaTree rawProcess(final ProcessingReport report, final SchemaTree input) throws ProcessingException { validate(report, input); return input; }
@BeforeMethod public void initialize() { report = spy(new TestProcessingReport()); final DictionaryBuilder<SyntaxChecker> builder = Dictionary.newBuilder(); checker = mock(SyntaxChecker.class); builder.addEntry(K1, checker); builder.addEntry(K2, new SyntaxChecker() { @Override public EnumSet<NodeType> getValidTypes() { return EnumSet.noneOf(NodeType.class); } @Override public void checkSyntax(final Collection<JsonPointer> pointers, final MessageBundle bundle, final ProcessingReport report, final SchemaTree tree) throws ProcessingException { report.error(new ProcessingMessage().setMessage(ERRMSG)); } }); processor = new SyntaxProcessor(BUNDLE, builder.freeze()); }
report.error(newMsg(tree, "core.notASchema") .putArgument("found", type)); return; report.warn(newMsg(tree, "core.unknownKeywords") .putArgument("ignored", Ordering.natural().sortedCopy(fields))); checker.checkSyntax(pointers, bundle, report, tree); validate(report, tree.append(pointer));
@Test public void checkingWillNotDiveIntoUnknownKeywords() throws ProcessingException { final ObjectNode node = FACTORY.objectNode(); node.put(K1, K1); final ObjectNode schema = FACTORY.objectNode(); schema.put("foo", node); final SchemaTree tree = new CanonicalSchemaTree(SchemaKey.anonymousKey(), schema); final ValueHolder<SchemaTree> holder = ValueHolder.hold("schema", tree); processor.process(report, holder); verify(checker, never()).checkSyntax(anyCollectionOf(JsonPointer.class), any(MessageBundle.class), anyReport(), anySchema()); }
@Test public void errorsAreCorrectlyReported() throws ProcessingException { final ArgumentCaptor<ProcessingMessage> captor = ArgumentCaptor.forClass(ProcessingMessage.class); final ObjectNode schema = FACTORY.objectNode(); schema.put(K2, ""); final SchemaTree tree = new CanonicalSchemaTree(SchemaKey.anonymousKey(), schema); final ValueHolder<SchemaTree> holder = ValueHolder.hold("schema", tree); processor.process(report, holder); verify(report).log(same(LogLevel.ERROR), captor.capture()); final ProcessingMessage msg = captor.getValue(); assertMessage(msg).hasMessage(ERRMSG); }
report.error(newMsg(tree, "core.notASchema") .putArgument("found", type)); return; report.warn(newMsg(tree, "core.unknownKeywords") .putArgument("ignored", Ordering.natural().sortedCopy(fields))); checker.checkSyntax(pointers, bundle, report, tree); validate(report, tree.append(pointer));
@Override public SchemaTree rawProcess(final ProcessingReport report, final SchemaTree input) throws ProcessingException { validate(report, input); return input; }
public ValidationChain(final RefResolver refResolver, final Library library, final ValidationConfiguration cfg) { final SyntaxProcessor syntaxProcessor = new SyntaxProcessor( cfg.getSyntaxMessages(), library.getSyntaxCheckers()); final ProcessorChain<ValueHolder<SchemaTree>, ValueHolder<SchemaTree>> chain1 = ProcessorChain.startWith(refResolver).chainWith(syntaxProcessor); resolver = new CachingProcessor<ValueHolder<SchemaTree>, ValueHolder<SchemaTree>>( chain1.getProcessor(), SchemaHolderEquivalence.INSTANCE, cfg.getCacheSize() ); final SchemaDigester digester = new SchemaDigester(library); final ValidatorBuilder keywordBuilder = new ValidatorBuilder(library); ProcessorChain<SchemaContext, ValidatorList> chain2 = ProcessorChain.startWith(digester).chainWith(keywordBuilder); if (cfg.getUseFormat()) { final FormatProcessor format = new FormatProcessor(library, cfg); chain2 = chain2.chainWith(format); } builder = new CachingProcessor<SchemaContext, ValidatorList>( chain2.getProcessor(), SchemaContextEquivalence.getInstance(), cfg.getCacheSize() ); }
@Test(dataProvider = "notSchemas") public void syntaxProcessorYellsOnNonSchemas(final JsonNode node) throws ProcessingException { final ArgumentCaptor<ProcessingMessage> captor = ArgumentCaptor.forClass(ProcessingMessage.class); final SchemaTree tree = new CanonicalSchemaTree(SchemaKey.anonymousKey(), node); final ValueHolder<SchemaTree> holder = ValueHolder.hold("schema", tree); processor.process(report, holder); verify(report).log(same(LogLevel.ERROR), captor.capture()); final ProcessingMessage message = captor.getValue(); final NodeType type = NodeType.getNodeType(node); assertMessage(message) .hasMessage(BUNDLE.printf("core.notASchema", type)) .hasField("found", type); }
report.error(newMsg(tree, "core.notASchema") .putArgument("found", type)); return; report.warn(newMsg(tree, "core.unknownKeywords") .putArgument("ignored", Ordering.natural().sortedCopy(fields))); checker.checkSyntax(pointers, bundle, report, tree); validate(report, tree.append(pointer));
@Override public SchemaTree rawProcess(final ProcessingReport report, final SchemaTree input) throws ProcessingException { validate(report, input); return input; }
= ArgumentCaptor.forClass(ProcessingMessage.class); processor.process(report, holder); verify(report).log(same(LogLevel.WARNING), captor.capture());