def test_multi_register(self): basic = util.parse_schema_from_string(data_gen.BASIC_SCHEMA) adv = util.parse_schema_from_string(data_gen.ADVANCED_SCHEMA) subject = 'test' client = self.client id1 = client.register(subject, basic) latest1 = client.get_latest_schema(subject) v1 = client.get_version(subject, basic) self.assertLatest(latest1, id1, basic, v1) id2 = client.register(subject, adv) latest2 = client.get_latest_schema(subject) v2 = client.get_version(subject, adv) self.assertLatest(latest2, id2, adv, v2) self.assertNotEqual(id1, id2) self.assertNotEqual(latest1, latest2) # ensure version is higher self.assertTrue(latest1[2] < latest2[2]) client.register(subject, basic) latest3 = client.get_latest_schema(subject) # latest should not change with a re-reg self.assertEqual(latest2, latest3)
def get_by_id(self, schema_id): """ GET /schemas/ids/{int: id} Retrieve a parsed avro schema by id or None if not found @:param: schema_id: int value @:returns: Avro schema """ if schema_id in self.id_to_schema: return self.id_to_schema[schema_id] # fetch from the registry url = '/'.join([self.url, 'schemas', 'ids', str(schema_id)]) result, code = self._send_request(url) if code == 404: log.error("Schema not found:" + str(code)) return None elif code != 200: log.error("Unable to get schema for the specific ID:" + str(code)) return None else: # need to parse the schema schema_str = result.get("schema") try: result = util.parse_schema_from_string(schema_str) # cache it self._cache_schema(result, schema_id) return result except: # bad schema - should not happen log.error("Received bad schema from registry.") raise ClientError("Received bad schema from registry.")
def test_encode_record_with_schema(self): topic = 'test' basic = util.parse_schema_from_string(data_gen.BASIC_SCHEMA) subject = 'test-value' schema_id = self.client.register(subject, basic) records = data_gen.BASIC_ITEMS for record in records: message = self.ms.encode_record_with_schema(topic, basic, record) self.assertMessageIsSame(message, record, schema_id)
def test_multi_subject_register(self): parsed = util.parse_schema_from_string(data_gen.BASIC_SCHEMA) client = self.client schema_id = client.register('test', parsed) self.assertTrue(schema_id > 0) # register again under different subject dupe_id = client.register('other', parsed) self.assertEqual(schema_id, dupe_id) self.assertEqual(len(client.id_to_schema), 1)
def test_encode_with_schema_id(self): adv = util.parse_schema_from_string(data_gen.ADVANCED_SCHEMA) basic = util.parse_schema_from_string(data_gen.BASIC_SCHEMA) subject = 'test' schema_id = self.client.register(subject, basic) records = data_gen.BASIC_ITEMS for record in records: message = self.ms.encode_record_with_schema_id(schema_id, record) self.assertMessageIsSame(message, record, schema_id) subject = 'test_adv' adv_schema_id = self.client.register(subject, adv) self.assertNotEqual(adv_schema_id, schema_id) records = data_gen.ADVANCED_ITEMS for record in records: message = self.ms.encode_record_with_schema_id( adv_schema_id, record) self.assertMessageIsSame(message, record, adv_schema_id)
def _get_schema_from_body(self, req): length = int(req.headers['content-length']) data = req.rfile.read(length) data = json.loads(data.decode("utf-8")) schema = data.get("schema", None) if not schema: return None try: avro_schema = util.parse_schema_from_string(schema) return self._get_identity_schema(avro_schema) except: return None
def test_dupe_register(self): parsed = util.parse_schema_from_string(data_gen.BASIC_SCHEMA) subject = 'test' client = self.client schema_id = client.register(subject, parsed) self.assertTrue(schema_id > 0) latest = client.get_latest_schema(subject) # register again under same subject dupe_id = client.register(subject, parsed) self.assertEqual(schema_id, dupe_id) dupe_latest = client.get_latest_schema(subject) self.assertEqual(latest, dupe_latest)
def test_getters(self): parsed = util.parse_schema_from_string(data_gen.BASIC_SCHEMA) client = self.client subject = 'test' version = client.get_version(subject, parsed) self.assertEqual(version, -1) schema = client.get_by_id(1) self.assertEqual(schema, None) latest = client.get_latest_schema(subject) self.assertEqual(latest, (None, None, None)) # register schema_id = client.register(subject, parsed) latest = client.get_latest_schema(subject) version = client.get_version(subject, parsed) self.assertLatest(latest, schema_id, parsed, version) fetched = client.get_by_id(schema_id) self.assertEqual(fetched, parsed)
def get_latest_schema(self, subject): """ GET /subjects/(string: subject)/versions/(versionId: version) Return the latest 3-tuple of: (the schema id, the parsed avro schema, the schema version) for a particular subject. This call always contacts the registry. If the subject is not found, (None,None,None) is returned. @:param: subject: subject name @:returns: (schema_id, schema, version) """ url = '/'.join([self.url, 'subjects', subject, 'versions', 'latest']) result, code = self._send_request(url) if code == 404: log.error("Schema not found:" + str(code)) return (None, None, None) elif code == 422: log.error("Invalid version:" + str(code)) return (None, None, None) elif not (code >= 200 and code <= 299): return (None, None, None) schema_id = result['id'] version = result['version'] if schema_id in self.id_to_schema: schema = self.id_to_schema[schema_id] else: try: schema = util.parse_schema_from_string(result['schema']) except: # bad schema - should not happen log.error("Received bad schema from registry.") raise ClientError("Received bad schema from registry.") self._cache_schema(schema, schema_id, subject, version) return (schema_id, schema, version)
def test_register(self): parsed = util.parse_schema_from_string(data_gen.BASIC_SCHEMA) client = self.client schema_id = client.register('test', parsed) self.assertTrue(schema_id > 0) self.assertEqual(len(client.id_to_schema), 1)
def test_schema_from_string(self): parsed = util.parse_schema_from_string(data_gen.BASIC_SCHEMA) self.assertTrue(isinstance(parsed, schema.Schema))