@Override public Subject register(final String subjectName, final SubjectConfig config) { return repo.register(subjectName, config); }
@Override public Subject register(final String subjectName, final SubjectConfig config) { return repo.register(subjectName, config); }
/** * This sets mutable data, hence it will always result in a call to the * underlying schema repo implementation. * * If the subject does not exist, it will be initialized with the given * config, but will not contain any ID/schema pair. * * @param subjectName to change the config for * @param subjectConfig to set for the given subject */ public void setConfig(SUBJECT subjectName, SubjectConfig subjectConfig) { repo.register(convertSubject.toString(subjectName), subjectConfig); }
/** * This sets mutable data, hence it will always result in a call to the * underlying schema repo implementation. * * If the subject does not exist, it will be initialized with the given * config, but will not contain any ID/schema pair. * * @param subjectName to change the config for * @param subjectConfig to set for the given subject */ public void setConfig(SUBJECT subjectName, SubjectConfig subjectConfig) { repo.register(convertSubject.toString(subjectName), subjectConfig); }
@Override public Subject register(String subjectName, SubjectConfig config) { Subject s = cache.lookup(subjectName); if (s == null) { return cache.add(repo.register(subjectName, config)); } return s; }
@Override public Subject register(String subjectName, SubjectConfig config) { Subject s = cache.lookup(subjectName); if (s == null) { return cache.add(repo.register(subjectName, config)); } return s; }
/** * Create a subject if it does not already exist. * * @param subject * the name of the subject * @param configParams * the configuration values for the Subject, as form parameters * @return the subject name in a 200 response if successful. * HTTP 404 if the subject does not exist, or HTTP 409 if there was a conflict creating the subject */ @PUT @Path("{subject}") @Consumes(MediaType.APPLICATION_FORM_URLENCODED) public Response createSubject(@PathParam("subject") String subject, MultivaluedMap<String, String> configParams) { if (null == subject) { return Response.status(400).build(); } SubjectConfig.Builder builder = new SubjectConfig.Builder(); for(Map.Entry<String, List<String>> entry : configParams.entrySet()) { List<String> val = entry.getValue(); if(val.size() > 0) { builder.set(entry.getKey(), val.get(0)); } } Subject created = repo.register(subject, builder.build()); return Response.ok(created.getName()).build(); }
/** * Create a subject if it does not already exist. * * @param subject * the name of the subject * @param configParams * the configuration values for the Subject, as form parameters * @return the subject name in a 200 response if successful. * HTTP 404 if the subject does not exist, or HTTP 409 if there was a conflict creating the subject */ @PUT @Path("{subject}") @Consumes(MediaType.APPLICATION_FORM_URLENCODED) public Response createSubject(@PathParam("subject") String subject, MultivaluedMap<String, String> configParams) { if (null == subject) { return Response.status(400).build(); } SubjectConfig.Builder builder = new SubjectConfig.Builder(); for(Map.Entry<String, List<String>> entry : configParams.entrySet()) { List<String> val = entry.getValue(); if(val.size() > 0) { builder.set(entry.getKey(), val.get(0)); } } Subject created = repo.register(subject, builder.build()); return Response.ok(created.getName()).build(); }
@Test public void testConfig() { Properties props = new Properties(); props.setProperty(Config.REPO_CLASS, InMemoryRepository.class.getName()); props.put(Config.VALIDATOR_PREFIX + "rejectAll", Reject.class.getName()); ConfigModule module = new ConfigModule(props); Injector injector = Guice.createInjector(module); Repository repo = injector.getInstance(Repository.class); Subject rejects = repo.register("rejects", new SubjectConfig.Builder() .addValidator("rejectAll").build()); boolean threw = false; try { rejects.register("stuff"); } catch (SchemaValidationException se) { threw = true; } Assert.assertTrue(threw); }
Subject subject = repo.lookup(convertSubject.toString(subjectName)); if (subject == null) { subject = repo.register(convertSubject.toString(subjectName), defaultSubjectConfigBuilder.build());
Subject subject = repo.lookup(convertSubject.toString(subjectName)); if (subject == null) { subject = repo.register(convertSubject.toString(subjectName), defaultSubjectConfigBuilder.build());
@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); }
@Test public void testSubjectsToFromString() { Repository r = new InMemoryRepository(new ValidatorFactory.Builder().build()); Subject s1 = r.register("s1", null); Subject s2 = r.register("s2", null); ArrayList<Subject> empty = new ArrayList<Subject>(); ArrayList<Subject> vals = new ArrayList<Subject>(); vals.add(s1); vals.add(s2); Iterable<String> emptyResult = jsonUtil .subjectNamesFromJson(jsonUtil.subjectsToJson(empty)); Iterable<String> emptyResult2 = jsonUtil.subjectNamesFromJson(null); Iterable<String> emptyResult3 = jsonUtil.subjectNamesFromJson(""); validate(emptyResult, empty); Assert.assertEquals(emptyResult, emptyResult2); Assert.assertEquals(emptyResult, emptyResult3); Iterable<String> result = jsonUtil .subjectNamesFromJson(jsonUtil.subjectsToJson(vals)); validate(result, vals); }
@Test public void testSubjectsToFromString() { Repository r = new InMemoryRepository(new ValidatorFactory.Builder().build()); Subject s1 = r.register("s1", null); Subject s2 = r.register("s2", null); ArrayList<Subject> empty = new ArrayList<Subject>(); ArrayList<Subject> vals = new ArrayList<Subject>(); vals.add(s1); vals.add(s2); Iterable<String> emptyResult = RepositoryUtil .subjectNamesFromString(RepositoryUtil.subjectsToString(empty)); Iterable<String> emptyResult2 = RepositoryUtil.subjectNamesFromString(null); Iterable<String> emptyResult3 = RepositoryUtil.subjectNamesFromString(""); validate(emptyResult, empty); Assert.assertEquals(emptyResult, emptyResult2); Assert.assertEquals(emptyResult, emptyResult3); Iterable<String> result = RepositoryUtil .subjectNamesFromString(RepositoryUtil.subjectsToString(vals)); validate(result, vals); }
@Test public void testValidation() { SubjectConfig conf = new SubjectConfig.Builder().addValidator(ValidatorFactory.REJECT_VALIDATOR).build(); // lookup a subject that does not exist, when none do Subject none = repo.lookup(VALIDATING); Assert.assertNull("non-existent subject lookup should return null", none); // register a subject that should reject all schemas Subject sub = repo.register(VALIDATING, conf); Assert.assertNotNull("failed to register subject: " + VALIDATING, sub); boolean threw = false; try { sub.register("stuff"); } catch (SchemaValidationException e) { threw = true; } Assert.assertTrue("must throw a SchemaValidationException", threw); }
@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(); } }
@Test public void testSubjectConfigs() { String testKey = "test.key"; String testVal = "test.val"; String testVal2 = "test.val2"; SubjectConfig conf = new SubjectConfig.Builder().set(testKey, testVal).build(); SubjectConfig conf2 = new SubjectConfig.Builder().set(testKey, testVal2).build(); // lookup a subject that does not exist, when none do Subject none = repo.lookup(CONF); Assert.assertNull("non-existent subject lookup should return null", none); // register a subject Subject sub = repo.register(CONF, conf); Assert.assertNotNull("failed to register subject: " + CONF, sub); // a duplicate register is idempotent; the result is the same Subject sub2 = repo.register(CONF, conf2); Assert.assertNotNull("failed to re-register subject: " + SUB, sub2); validateSubject(sub, sub2); // lookup subject that was just registered Subject sub3 = repo.lookup(CONF); validateSubject(sub, sub3); // lookup something that is not there Subject sub4 = repo.lookup(NOCONF); Assert.assertNull("subject should not exist", sub4); }