def test_multi_register(client): """ Register two different schemas under the same subject with backwards compatibility """ version_1 = load.loads(data_gen.USER_V1) version_2 = load.loads(data_gen.USER_V2) subject = "test-user-schema" id1 = client.register(subject, version_1) latest_schema_1 = client.get_schema(subject) client.check_version(subject, version_1) id2 = client.register(subject, version_2) latest_schema_2 = client.get_schema(subject) client.check_version(subject, version_2) assert id1 != id2 assert latest_schema_1 != latest_schema_2 # ensure version is higher assert latest_schema_1.version < latest_schema_2.version client.register(subject, version_1) latest_schema_3 = client.get_schema(subject) # latest should not change with a re-reg assert latest_schema_2 == latest_schema_3
def test_delete_subject(client, user_schema_v3): subject = "subject-to-delete" versions = [load.loads(data_gen.USER_V1), load.loads(data_gen.USER_V2)] for version in versions: client.register(subject, version) assert len(client.delete_subject(subject)) == len(versions)
def test_multi_subject_register(client): parsed = load.loads(data_gen.BASIC_SCHEMA) schema_id = client.register("test-basic-schema", parsed) assert schema_id > 0 # register again under different subject dupe_id = client.register("test-basic-schema-backup", parsed) assert schema_id == dupe_id assert len(client.id_to_schema) == 1
def test_encode_record_with_schema(client, message_serializer): topic = "test" basic = load.loads(data_gen.BASIC_SCHEMA) subject = "test-value" schema_id = client.register(subject, basic) records = data_gen.BASIC_ITEMS for record in records: message = message_serializer.encode_record_with_schema(topic, basic, record) assertMessageIsSame(message, record, schema_id, message_serializer)
def test_compatibility(client, user_schema_v3): """ Test the compatibility of a new User Schema against the User schema version 2. """ subject = "test-user-schema" version_2 = load.loads(data_gen.USER_V2) client.register(subject, version_2) compatibility = client.test_compatibility(subject, user_schema_v3) assert compatibility
def test_encode_with_schema_id(client, message_serializer): adv = load.loads(data_gen.ADVANCED_SCHEMA) basic = load.loads(data_gen.BASIC_SCHEMA) subject = "test-basic-schema" schema_id = client.register(subject, basic) records = data_gen.BASIC_ITEMS for record in records: message = message_serializer.encode_record_with_schema_id(schema_id, record) assertMessageIsSame(message, record, schema_id, message_serializer) subject = "test-advance-schema" adv_schema_id = client.register(subject, adv) assert adv_schema_id != schema_id records = data_gen.ADVANCED_ITEMS for record in records: message = message_serializer.encode_record_with_schema_id(adv_schema_id, record) assertMessageIsSame(message, record, adv_schema_id, message_serializer)
def test_dupe_register(client): parsed = load.loads(data_gen.BASIC_SCHEMA) subject = "test-basic-schema" schema_id = client.register(subject, parsed) assert schema_id > 0 latest = client.get_schema(subject) # register again under same subject dupe_id = client.register(subject, parsed) assert schema_id == dupe_id dupe_latest = client.get_schema(subject) assert latest == dupe_latest
def test_getters(client): parsed = load.loads(data_gen.BASIC_SCHEMA) subject = "subject-does-not-exist" version = client.check_version(subject, parsed) assert version is None parsed_basic = load.loads(data_gen.BASIC_SCHEMA) client.register("test-basic-schema", parsed_basic) schema = client.get_by_id(1) assert schema is not None latest = client.get_schema(subject) assert latest == (None, None, None, None) # register schema_id = client.register(subject, parsed) schema = client.get_schema(subject, schema_id) assert schema is not None latest = client.get_schema(subject) version = client.check_version(subject, parsed) fetched = client.get_by_id(schema_id) assert fetched == parsed
def get_schema(self, subject, version="latest", headers=None): """ GET /subjects/(string: subject)/versions/(versionId: version) Get a specific version of the schema registered under this subject If the subject is not found a Nametupled (None,None,None) is returned. Args: subject (str): subject name version (int, optional): version id. If is None, the latest schema is returned headers (dict): Extra headers to add on the requests Returns: SchemaVersion (nametupled): (subject, schema_id, schema, version) """ url = "/".join( [self.url, "subjects", subject, "versions", str(version)]) result, code = self.request(url, headers=headers) if code == status.HTTP_404_NOT_FOUND: log.error(f"Schema not found: {code}") return utils.SchemaVersion(None, None, None, None) elif code == status.HTTP_422_UNPROCESSABLE_ENTITY: log.error(f"Invalid version: {code}") return utils.SchemaVersion(None, None, None, None) elif not status.is_success(code): return utils.SchemaVersion(None, 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 = loads(result["schema"]) except ClientError: # bad schema - should not happen raise self._cache_schema(schema, schema_id, subject, version) return utils.SchemaVersion(subject, schema_id, schema, version)
def get_by_id(self, schema_id, headers=None): """ GET /schemas/ids/{int: id} Retrieve a parsed avro schema by id or None if not found Args: schema_id (int): Schema Id headers (dict): Extra headers to add on the requests Returns: avro.schema.RecordSchema: Avro Record 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.request(url, headers=headers) if code == status.HTTP_404_NOT_FOUND: log.error(f"Schema not found: {code}") elif not status.is_success(code): log.error(f"Unable to get schema for the specific ID: {code}") else: # need to parse the schema schema_str = result.get("schema") try: result = loads(schema_str) # cache the result self._cache_schema(result, schema_id) return result except ClientError: # bad schema - should not happen raise ClientError( f"Received bad schema (id {schema_id})", http_code=code, server_traceback=result, )
def test_getters(client): parsed = load.loads(data_gen.BASIC_SCHEMA) subject = "subject-does-not-exist" version = client.check_version(subject, parsed) assert version is None # There is already a registered schema with id 1 schema = client.get_by_id(1) assert schema is not None latest = client.get_schema(subject) assert latest == (None, None, None, None) # register schema_id = client.register(subject, parsed) schema = client.get_schema(subject, schema_id) assert schema is not None latest = client.get_schema(subject) version = client.check_version(subject, parsed) fetched = client.get_by_id(schema_id) assert fetched == parsed
def test_context(client): with client as c: parsed = load.loads(data_gen.BASIC_SCHEMA) schema_id = c.register("test-basic-schema", parsed) assert schema_id > 0 assert len(c.id_to_schema) == 1
def test_register(client): parsed = load.loads(data_gen.BASIC_SCHEMA) schema_id = client.register("test-basic-schema", parsed) assert schema_id > 0 assert len(client.id_to_schema) == 1
def test_schema_from_string(): parsed = load.loads(data_gen.BASIC_SCHEMA) assert isinstance(parsed, avro.schema.Schema)