/** * Return a new full data with another instance * * @param instance the new instance * @return a new full data instance */ public FullData withInstance(final JsonTree instance) { return new FullData(schema, instance, deepCheck); }
/** * Return a new full data with another schema * * @param schema the schema * @return a new full data instance */ public FullData withSchema(final SchemaTree schema) { return new FullData(schema, instance, deepCheck); }
private FullData buildData(final JsonNode schema, final JsonNode instance, final boolean deepCheck) { BUNDLE.checkNotNull(schema, "nullSchema"); BUNDLE.checkNotNull(instance, "nullInstance"); final SchemaTree schemaTree = loader.load(schema); final JsonTree tree = new SimpleJsonTree(instance); return new FullData(schemaTree, tree, deepCheck); } }
private ProcessingReport doValidateUnchecked(final JsonNode node, final boolean deepCheck) { final FullData data = new FullData(schema, new SimpleJsonTree(node), deepCheck); final ProcessingReport report = reportProvider.newReport(); final ProcessingResult<FullData> result = ProcessingResult.uncheckedResult(processor, report, data); return result.getReport(); }
private ProcessingReport doValidate(final JsonNode node, final boolean deepCheck) throws ProcessingException { final FullData data = new FullData(schema, new SimpleJsonTree(node), deepCheck); final ProcessingReport report = reportProvider.newReport(); final ProcessingResult<FullData> result = ProcessingResult.of(processor, report, data); return result.getReport(); }
@Test public void childrenAreNotExploredByDefaultIfContainerFails() throws ProcessingException { final SchemaTree schema = new CanonicalSchemaTree(SchemaKey.anonymousKey(), RAWSCHEMA); final JsonTree instance = new SimpleJsonTree(RAWINSTANCE); final FullData data = new FullData(schema, instance); final ProcessingReport report = mock(ProcessingReport.class); processor.process(report, data); assertEquals(COUNT.get(), 0); }
@Test public void childrenAreExploredOnDemandEvenIfContainerFails() throws ProcessingException { final SchemaTree schema = new CanonicalSchemaTree(SchemaKey.anonymousKey(), RAWSCHEMA); final JsonTree instance = new SimpleJsonTree(RAWINSTANCE); final FullData data = new FullData(schema, instance, true); final ProcessingReport report = mock(ProcessingReport.class); processor.process(report, data); assertEquals(COUNT.get(), 1); }
@BeforeMethod public void initEnvironment() { if (validator == null) return; final ObjectNode schema = FACTORY.objectNode(); schema.put("not", FACTORY.objectNode()); final SchemaTree tree = new CanonicalSchemaTree(SchemaKey.anonymousKey(), schema); final JsonTree instance = new SimpleJsonTree(FACTORY.nullNode()); data = new FullData(tree, instance); report = mock(ProcessingReport.class); when(report.getLogLevel()).thenReturn(LogLevel.DEBUG); }
@BeforeMethod public void initEnvironment() { if (validator == null) return; final ObjectNode schema = FACTORY.objectNode(); schema.put("extends", FACTORY.objectNode()); final SchemaTree tree = new CanonicalSchemaTree(SchemaKey.anonymousKey(), schema); final JsonTree instance = new SimpleJsonTree(FACTORY.nullNode()); data = new FullData(tree, instance); report = mock(ProcessingReport.class); msg = new ProcessingMessage().setMessage(FOO); }
@Test( dataProvider = "supported", dependsOnMethods = "attributeIsBeingAskedWhatIsSupports" ) public void supportedNodeTypesTriggerAttributeBuild(final JsonNode node) throws ProcessingException { final ObjectNode schema = FACTORY.objectNode(); schema.put("format", FMT); final SchemaTree tree = new CanonicalSchemaTree(SchemaKey.anonymousKey(), schema); final JsonTree instance = new SimpleJsonTree(node); final FullData data = new FullData(tree, instance); final SchemaContext context = new SchemaContext(data); final ValidatorList in = new ValidatorList(context, Collections.<KeywordValidator>emptyList()); final ValidatorList out = processor.process(report, in); final List<KeywordValidator> validators = Lists.newArrayList(out); assertEquals(validators.size(), 1); @SuppressWarnings("unchecked") final Processor<FullData, FullData> p = mock(Processor.class); validators.get(0).validate(p, report, BUNDLE, data); verify(attribute).validate(report, BUNDLE, data); }
@Test( dependsOnMethods = "retestAttribute", dataProvider = "negativeValues" ) public void userIsWarnedAboutNegativeEpochs(final JsonNode input) throws ProcessingException { final JsonTree tree = new SimpleJsonTree(input); final FullData data = new FullData(SCHEMA_TREE, tree); attribute.validate(report, BUNDLE, data); final ArgumentCaptor<ProcessingMessage> captor = ArgumentCaptor.forClass(ProcessingMessage.class); verify(report, only()).warn(captor.capture()); final ProcessingMessage message = captor.getValue(); assertMessage(message).isFormatMessage(fmt, BUNDLE.printf("warn.format.epoch.negative", input)); }
@Test( dataProvider = "testData", dependsOnMethods = "formatAttributeIsSupported" ) public final void instanceIsCorrectlyAnalyzed(final JsonNode instance, final boolean valid, final String msg, final ObjectNode msgData) throws ProcessingException { final JsonTree tree = new SimpleJsonTree(instance); final FullData data = new FullData(SCHEMA_TREE, tree); attribute.validate(report, BUNDLE, data); if (valid) { verifyZeroInteractions(report); return; } final ArgumentCaptor<ProcessingMessage> captor = ArgumentCaptor.forClass(ProcessingMessage.class); verify(report).error(captor.capture()); final ProcessingMessage message = captor.getValue(); assertMessage(message).isFormatMessage(fmt, msg).hasContents(msgData) .hasField("value", instance); }
@Test( dependsOnMethods = "retestAttribute", dataProvider = "overflows" ) public void userIsWarnedAboutPotentialOverflows(final JsonNode input) throws ProcessingException { final JsonTree tree = new SimpleJsonTree(input); final FullData data = new FullData(SCHEMA_TREE, tree); attribute.validate(report, BUNDLE, data); final ArgumentCaptor<ProcessingMessage> captor = ArgumentCaptor.forClass(ProcessingMessage.class); verify(report, only()).warn(captor.capture()); final ProcessingMessage message = captor.getValue(); assertMessage(message) .isFormatMessage(fmt, BUNDLE.printf("warn.format.epoch.overflow", input)); } }
@BeforeMethod protected final void initEnvironment() throws ProcessingException { if (factory == null) return; final SchemaTree tree = new CanonicalSchemaTree( SchemaKey.anonymousKey(), generateSchema()); final JsonTree instance = new SimpleJsonTree(generateInstance()); data = new FullData(tree, instance); report = mock(ProcessingReport.class); when(report.getLogLevel()).thenReturn(LogLevel.DEBUG); validator = factory.getKeywordValidator(generateDigest()); }
@Test(dataProvider = "getValueTests", dependsOnMethods = "keywordExists") public final void instancesAreValidatedCorrectly(final JsonNode digest, final JsonNode node, final String msg, final boolean valid, final ObjectNode msgData) throws IllegalAccessException, InvocationTargetException, InstantiationException, ProcessingException { // FIXME: dummy, but we have no choice final SchemaTree tree = new CanonicalSchemaTree(SchemaKey.anonymousKey(), digest); final JsonTree instance = new SimpleJsonTree(node); final FullData data = new FullData(tree, instance); final ProcessingReport report = mock(ProcessingReport.class); @SuppressWarnings("unchecked") final Processor<FullData, FullData> processor = mock(Processor.class); final KeywordValidator validator = factory.getKeywordValidator(digest); validator.validate(processor, report, BUNDLE, data); if (valid) { verify(report, never()).error(anyMessage()); return; } final ArgumentCaptor<ProcessingMessage> captor = ArgumentCaptor.forClass(ProcessingMessage.class); verify(report).error(captor.capture()); final ProcessingMessage message = captor.getValue(); assertMessage(message).isValidationError(keyword, msg) .hasContents(msgData); }
= new CanonicalSchemaTree(SchemaKey.anonymousKey(), schema); final JsonTree instance = new SimpleJsonTree(node); final FullData data = new FullData(tree, instance);
final FullData data = new FullData(newContext.getSchema(), input.getInstance(), input.isDeepCheck());