/** * A {@link DelegatingSubject} delegates work to a provided Subject. **/ protected DelegatingSubject(Subject delegate) { super(delegate.getName()); this.delegate = delegate; }
@Override public SchemaEntry register(String schema) throws SchemaValidationException { return delegate.register(schema); }
@Override public SubjectConfig getConfig() { return delegate.getConfig(); }
Assert.assertEquals( "registering a subject twice did not produce the same result", sub.getName(), sub2.getName()); Assert.assertEquals("subject lookup failed", sub.getName(), sub3.getName()); if (sub.getName().equals(s.getName())) { hasSub = true; break; SchemaEntry noLatest = sub.latest(); Assert.assertNull("latest must be null if it does not exist", noLatest); sub.registerIfLatest(FOO, new SchemaEntry("not", "there")); Assert.assertNull( "registerIfLatest must return null if there are no schemas in the " + SchemaEntry foo = sub.registerIfLatest(FOO, null); validateSchemaEntry(FOO, foo); SchemaEntry foo2 = sub.register(FOO); Assert.assertEquals("duplicate schema registration must be idempotent", foo, foo2); SchemaEntry bar = sub.registerIfLatest(BAR, foo2); validateSchemaEntry(BAR, bar); SchemaEntry none3 = sub.registerIfLatest("none", foo); Assert.assertNull(
Assert.assertEquals( "registering a subject twice did not produce the same result", sub.getName(), sub2.getName()); Assert.assertEquals("subject lookup failed", sub.getName(), readOnlySubject.getName()); if (sub.getName().equals(s.getName())) { hasSub = true; break; hasSub); SchemaEntry foo = sub.register(FOO); boolean foundfoo = false; for (SchemaEntry s : readOnlySubject.allEntries()) { if (s.equals(foo)) { foundfoo = true;
repo.register("sub1", null).register(multiLineSchema1); repo.register("sub1", null).register(multiLineSchema2); } finally { repo.close(); Assert.assertNotNull(s1); SchemaEntry schemaEntry1ById = s1.lookupById("0"); Assert.assertNotNull(schemaEntry1ById); Assert.assertEquals(multiLineSchema1, schemaEntry1ById.getSchema()); SchemaEntry schemaEntry1BySchema = s1.lookupBySchema(multiLineSchema1); Assert.assertNotNull(schemaEntry1BySchema); Assert.assertEquals(multiLineSchema1, schemaEntry1BySchema.getSchema()); SchemaEntry schemaEntry2ById = s1.lookupById("1"); Assert.assertNotNull(schemaEntry2ById); Assert.assertEquals(multiLineSchema2, schemaEntry2ById.getSchema()); SchemaEntry schemaEntry2BySchema = s1.lookupBySchema(multiLineSchema2); Assert.assertNotNull(schemaEntry2BySchema); Assert.assertEquals(multiLineSchema2, schemaEntry2BySchema.getSchema());
@Test public void testWriteCloseRead() throws Exception { try { repo.register("sub1", null).register("sc1"); repo.register("sub2", null).register("sc2"); repo.register("sub2", null).register("sc3"); } finally { repo.close(); } // Calling close() and createRepository() is like bouncing the repo, to ensure its state persists. repo = createRepository(); try { Subject s1 = repo.lookup("sub1"); Assert.assertNotNull(s1); Subject s2 = repo.lookup("sub2"); Assert.assertNotNull(s2); SchemaEntry e1 = s1.lookupBySchema("sc1"); Assert.assertNotNull(e1); Assert.assertEquals("sc1", e1.getSchema()); SchemaEntry e2 = s2.lookupBySchema("sc2"); Assert.assertNotNull(e2); Assert.assertEquals("sc2", e2.getSchema()); SchemaEntry e3 = s2.lookupBySchema("sc3"); Assert.assertNotNull(e3); Assert.assertEquals("sc3", e3.getSchema()); } finally { repo.close(); } }
latest = null; } else { latest = exists(s.lookupById(latestId)); created = s.registerIfLatest(schema, latest); if (null == created) { return Response.status(Status.CONFLICT).build();
@Override public SchemaEntry lookupBySchema(String schema) { return delegate.lookupBySchema(schema); }
@Override public SchemaEntry lookupById(String id) { return delegate.lookupById(id); }
@Override public SchemaEntry latest() { return delegate.latest(); }
@Test public void testSuccessfulValidation() throws SchemaValidationException { Subject accept = repo.register(ACCEPT, new SubjectConfig.Builder() .addValidator(ACCEPT_VALIDATOR).build()); SchemaEntry foo = accept.registerIfLatest(FOO, null); Assert.assertNotNull("failed to register schema", foo); SchemaEntry bar = accept.registerIfLatest(BAR, foo); Assert.assertNotNull("failed to register schema", bar); SchemaEntry none = accept.registerIfLatest("nothing", null); Assert.assertNull(none); SchemaEntry baz = accept.register(BAZ); Assert.assertNotNull("failed to register schema", baz); }
@Test public void testAllEntriesMultiLineSchema() throws Exception { String endOfLine = System.getProperty("line.separator"); String multiLineSchema1 = "first line" + endOfLine + "second line"; String multiLineSchema2 = "first line" + endOfLine + "second line" + endOfLine; repo.register("sub1", null).register(multiLineSchema1); repo.register("sub1", null).register(multiLineSchema2); Subject s1 = repo.lookup("sub1"); Assert.assertNotNull(s1); Iterable<SchemaEntry> allEntries = s1.allEntries(); boolean foundSub1 = false, foundSub2 = false; for (SchemaEntry entry: allEntries) { if (entry.getSchema().equals(multiLineSchema1)) { foundSub1 = true; } else if (entry.getSchema().equals(multiLineSchema2)) { foundSub2 = true; } } Assert.assertTrue("Check that allEntries() returns proper multi-line schemas", foundSub1 && foundSub2); }
@Override public SchemaEntry registerIfLatest(String schema, SchemaEntry latest) throws SchemaValidationException { return delegate.registerIfLatest(schema, latest); }
@Override public boolean integralKeys() { return delegate.integralKeys(); } }
@Override public Iterable<SchemaEntry> allEntries() { return delegate.allEntries(); }
/** * Applies validation decorator, and caches subject. * @param subject subject to cache * @return Subject the passed instance or possibly pre-existing cached instance */ protected final Subject cacheSubject(final Subject subject) { return subjectCache.add(Subject.validatingSubject(subject, validators)); }
latest = null; } else { latest = exists(s.lookupById(latestId)); created = s.registerIfLatest(schema, latest); if (null == created) { return Response.status(Status.CONFLICT).build();
@Override public SchemaEntry lookupBySchema(String schema) { return delegate.lookupBySchema(schema); }