def test_override_headers(client, deployment_schema, mocker, response_klass):
extra_headers = {"custom-serialization": "application/x-avro-json"}
client = SchemaRegistryClient("https://127.0.0.1:65534",
extra_headers=extra_headers)
assert client.session.headers.get(
"custom-serialization") == "application/x-avro-json"
subject = "test"
override_header = {"custom-serialization": "application/avro"}
request_patch = mocker.patch.object(httpx.Client,
"request",
return_value=response_klass(
200, content={"id": 1}))
client.register(subject, deployment_schema, headers=override_header)
prepare_headers = client.prepare_headers(body="1")
prepare_headers["custom-serialization"] = "application/avro"
request_patch.assert_called_once_with("POST",
mocker.ANY,
headers=prepare_headers,
json=mocker.ANY,
timeout=UNSET)
def client():
client = SchemaRegistryClient("http://my-dummy-schema.com")
client.register = MagicMock(name="register")
client.get_by_id = MagicMock(name="get_by_id")
client.register.return_value = 1
client.get_by_id.return_value = AvroSchema(UserModel._schema)
return client
def lambda_handler(event, context):
responseData = {}
print(event)
if 'SCHEMA_REEGISTRY_URI' in os.environ:
SchemaRegistryURI = os.environ['SCHEMA_REEGISTRY_URI']
print('SchemaRegistryURI is: {}'.format(SchemaRegistryURI))
else:
responseData['cause'] = "Schema registry URI not provided"
cfnresponse.send(event, context, cfnresponse.FAILED, responseData)
if 'SchemaConfig' in event['ResourceProperties']:
json_content = json.loads(event['ResourceProperties']['SchemaConfig'])
print("Loaded AVRO schema from file {}".format(json_content))
else:
responseData['status'] = "Location of Schema file not provided"
responseData['cause'] = event['ResourceProperties']
print('SchemaFile not provided')
cfnresponse.send(event, context, cfnresponse.FAILED, responseData)
if event['RequestType'] == 'Create':
if 'type' in json_content:
print("Looks like we got valide AVRO schema")
try:
client = SchemaRegistryClient(url=SchemaRegistryURI)
except Exception as e:
responseData['cause'] = "Schema registry client cannot be created {} \
".format(e.__class__.__name__)
print(responseData['cause'])
cfnresponse.send(event, context, cfnresponse.FAILED, responseData)
print('Schema registry client created')
avro_schema = schema.AvroSchema(json_content)
print('AVRO schema object created')
###Get subjects, just for debug
list_registered_subjects = requests.get(SchemaRegistryURI + "/subjects")
print("Native http rest response, list of current subjects {}, \
".format(list_registered_subjects.json()))
try:
schema_id = client.register(json_content['name'] + "-value", avro_schema, timeout=10)
responseData['cause'] = "Schema {} created successfully, schema id is {} \
".format(json_content['name'], schema_id)
print(responseData['cause'])
cfnresponse.send(event, context, cfnresponse.SUCCESS, responseData)
except Exception as e:
responseData['cause'] = "Some exception in request to schema register happened, {}\
".format(format(e.__class__.__name__))
print (responseData['cause'])
cfnresponse.send(event, context, cfnresponse.FAILED, responseData)
else:
responseData['cause'] = 'Provided file not an AVRO schema, \
there are no /"type/" field in request object'
print(responseData['cause'])
cfnresponse.send(event, context, cfnresponse.FAILED, responseData)
else:
#if event['RequestType'] == 'Delete' or event['RequestType'] == 'Update':
responseData['cause'] = 'CloudFormation Delete and Update method not implemented, \
just return cnfresponse=SUCCSESS without any job/modifications'
cfnresponse.send(event, context, cfnresponse.SUCCESS, responseData)
def test_override_headers(client, deployment_schema, mocker):
extra_headers = {"custom-serialization": "application/x-avro-json"}
client = SchemaRegistryClient(
"https://127.0.0.1:65534", extra_headers=extra_headers
)
assert (
client.prepare_headers().get("custom-serialization")
== "application/x-avro-json"
)
class Response:
def __init__(self, status_code, content=None):
self.status_code = status_code
if content is None:
content = {}
self.content = content
def json(self):
return self.content
subject = "test"
override_header = {"custom-serialization": "application/avro"}
request_patch = mocker.patch.object(
requests.sessions.Session,
"request",
return_value=Response(200, content={"id": 1}),
)
client.register(subject, deployment_schema, headers=override_header)
prepare_headers = client.prepare_headers(body="1")
prepare_headers["custom-serialization"] = "application/avro"
request_patch.assert_called_once_with(
"POST", mocker.ANY, headers=prepare_headers, json=mocker.ANY
)
## Needs testing
client = SchemaRegistryClient(url="http://127.0.0.1:8081")
deployment_schema = {
"type":
"record",
"namespace":
"com.kubertenes",
"name":
"AvroDeployment",
"fields": [
{
"name": "image",
"type": "string"
},
{
"name": "replicas",
"type": "int"
},
{
"name": "port",
"type": "int"
},
],
}
avro_schema = schema.AvroSchema(deployment_schema)
schema_id = client.register("test-deployment", avro_schema)
"akira.data",
"name":
"AvroTicker",
"fields": [{
"name": "data",
"type": "string"
}, {
"name": "symbol",
"type": "string"
}, {
"name": "index",
"type": "string",
"doc": "should be in datetime format"
}]
})
schema_id = client.register(avro_ticker_schema.name.lower(),
avro_ticker_schema)
avro_ticker_serializer = FaustSerializer(client,
avro_ticker_schema.name.lower(),
avro_ticker_schema)
avro_metadata_schema = schema.AvroSchema({
"type":
"record",
"namespace":
"akira.data",
"name":
"AvroMetadata",
"fields": [{
"name": "metadata",
"type": {
