moto/tests/test_glue/test_schema_registry.py

1309 lines
43 KiB
Python

import boto3
import pytest
from botocore.client import ClientError
from moto import mock_aws
from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
from . import helpers
from .fixtures.schema_registry import (
TEST_AVAILABLE_STATUS,
TEST_AVRO_DATA_FORMAT,
TEST_AVRO_SCHEMA_DEFINITION,
TEST_BACKWARD_COMPATIBILITY,
TEST_DELETING_STATUS,
TEST_DESCRIPTION,
TEST_DISABLED_COMPATIBILITY,
TEST_INVALID_SCHEMA_ID_REGISTRY_DOES_NOT_EXIST,
TEST_INVALID_SCHEMA_ID_SCHEMA_DOES_NOT_EXIST,
TEST_INVALID_SCHEMA_NAME_DOES_NOT_EXIST,
TEST_JSON_DATA_FORMAT,
TEST_JSON_SCHEMA_DEFINITION,
TEST_METADATA_KEY,
TEST_METADATA_KEY_VALUE,
TEST_METADATA_VALUE,
TEST_NEW_AVRO_SCHEMA_DEFINITION,
TEST_NEW_JSON_SCHEMA_DEFINITION,
TEST_NEW_PROTOBUF_SCHEMA_DEFINITION,
TEST_PROTOBUF_DATA_FORMAT,
TEST_PROTOBUF_SCHEMA_DEFINITION,
TEST_REGISTRY_ARN,
TEST_REGISTRY_ID,
TEST_REGISTRY_NAME,
TEST_SCHEMA_ARN,
TEST_SCHEMA_ID,
TEST_SCHEMA_NAME,
TEST_SCHEMA_VERSION_NUMBER,
TEST_SCHEMA_VERSION_NUMBER_LATEST_VERSION,
TEST_TAGS,
TEST_VERSION_ID,
)
@pytest.fixture(name="client")
def fixture_client():
with mock_aws():
yield boto3.client("glue", region_name="us-east-1")
# Test create_registry
def test_create_registry_valid_input(client):
response = client.create_registry(
RegistryName=TEST_REGISTRY_NAME, Description=TEST_DESCRIPTION, Tags=TEST_TAGS
)
assert response["RegistryName"] == TEST_REGISTRY_NAME
assert response["Description"] == TEST_DESCRIPTION
assert response["Tags"] == TEST_TAGS
assert response["RegistryArn"] == TEST_REGISTRY_ARN
def test_create_registry_valid_partial_input(client):
response = client.create_registry(RegistryName=TEST_REGISTRY_NAME)
assert response["RegistryName"] == TEST_REGISTRY_NAME
assert response["RegistryArn"] == TEST_REGISTRY_ARN
def test_create_registry_invalid_registry_name_too_long(client):
registry_name = ""
for _ in range(80):
registry_name = registry_name + "toolong"
with pytest.raises(ClientError) as exc:
client.create_registry(RegistryName=registry_name)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "The resource name contains too many or too few characters. Parameter Name: registryName"
)
def test_create_registry_more_than_allowed(client):
for i in range(10):
client.create_registry(RegistryName=TEST_REGISTRY_NAME + str(i))
with pytest.raises(ClientError) as exc:
client.create_registry(RegistryName=TEST_REGISTRY_NAME)
err = exc.value.response["Error"]
assert err["Code"] == "ResourceNumberLimitExceededException"
assert (
err["Message"]
== "More registries cannot be created. The maximum limit has been reached."
)
def test_create_registry_invalid_registry_name(client):
invalid_registry_name = "A,B,C"
with pytest.raises(ClientError) as exc:
client.create_registry(RegistryName=invalid_registry_name)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "The parameter value contains one or more characters that are not valid. Parameter Name: registryName"
)
def test_create_registry_already_exists(client):
client.create_registry(RegistryName=TEST_REGISTRY_NAME)
with pytest.raises(ClientError) as exc:
client.create_registry(RegistryName=TEST_REGISTRY_NAME)
err = exc.value.response["Error"]
assert err["Code"] == "AlreadyExistsException"
assert (
err["Message"] == "Registry already exists. RegistryName: " + TEST_REGISTRY_NAME
)
def test_create_registry_invalid_description_too_long(client):
description = ""
for _ in range(350):
description = description + "toolong"
with pytest.raises(ClientError) as exc:
client.create_registry(
RegistryName=TEST_REGISTRY_NAME,
Description=description,
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "The resource name contains too many or too few characters. Parameter Name: description"
)
def test_create_registry_invalid_number_of_tags(client):
tags = {}
for i in range(51):
key = "k" + str(i)
val = "v" + str(i)
tags[key] = val
with pytest.raises(ClientError) as exc:
client.create_registry(
RegistryName=TEST_REGISTRY_NAME,
Tags=tags,
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert err["Message"] == "New Tags cannot be empty or more than 50"
# Test create_schema
def test_create_schema_valid_input_registry_name_avro(client):
helpers.create_registry(client)
response = client.create_schema(
RegistryId=TEST_REGISTRY_ID,
SchemaName=TEST_SCHEMA_NAME,
DataFormat=TEST_AVRO_DATA_FORMAT,
Compatibility=TEST_BACKWARD_COMPATIBILITY,
SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION,
Description=TEST_DESCRIPTION,
Tags=TEST_TAGS,
)
assert response["RegistryName"] == TEST_REGISTRY_NAME
assert response["RegistryArn"] == TEST_REGISTRY_ARN
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["Description"] == TEST_DESCRIPTION
assert response["DataFormat"] == TEST_AVRO_DATA_FORMAT
assert response["Compatibility"] == TEST_BACKWARD_COMPATIBILITY
assert response["SchemaCheckpoint"] == 1
assert response["LatestSchemaVersion"] == 1
assert response["NextSchemaVersion"] == 2
assert response["SchemaStatus"] == TEST_AVAILABLE_STATUS
assert response["Tags"] == TEST_TAGS
assert "SchemaVersionId" in response
assert response["SchemaVersionStatus"] == TEST_AVAILABLE_STATUS
def test_create_schema_valid_input_registry_name_json(client):
helpers.create_registry(client)
response = client.create_schema(
RegistryId=TEST_REGISTRY_ID,
SchemaName=TEST_SCHEMA_NAME,
DataFormat=TEST_JSON_DATA_FORMAT,
Compatibility=TEST_BACKWARD_COMPATIBILITY,
SchemaDefinition=TEST_JSON_SCHEMA_DEFINITION,
Description=TEST_DESCRIPTION,
Tags=TEST_TAGS,
)
assert response["RegistryName"] == TEST_REGISTRY_NAME
assert response["RegistryArn"] == TEST_REGISTRY_ARN
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["Description"] == TEST_DESCRIPTION
assert response["DataFormat"] == TEST_JSON_DATA_FORMAT
assert response["Compatibility"] == TEST_BACKWARD_COMPATIBILITY
assert response["SchemaCheckpoint"] == 1
assert response["LatestSchemaVersion"] == 1
assert response["NextSchemaVersion"] == 2
assert response["SchemaStatus"] == TEST_AVAILABLE_STATUS
assert response["Tags"] == TEST_TAGS
assert "SchemaVersionId" in response
assert response["SchemaVersionStatus"] == TEST_AVAILABLE_STATUS
def test_create_schema_valid_input_registry_name_protobuf(client):
helpers.create_registry(client)
response = client.create_schema(
RegistryId=TEST_REGISTRY_ID,
SchemaName=TEST_SCHEMA_NAME,
DataFormat=TEST_PROTOBUF_DATA_FORMAT,
Compatibility=TEST_BACKWARD_COMPATIBILITY,
SchemaDefinition=TEST_PROTOBUF_SCHEMA_DEFINITION,
Description=TEST_DESCRIPTION,
Tags=TEST_TAGS,
)
assert response["RegistryName"] == TEST_REGISTRY_NAME
assert response["RegistryArn"] == TEST_REGISTRY_ARN
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["Description"] == TEST_DESCRIPTION
assert response["DataFormat"] == TEST_PROTOBUF_DATA_FORMAT
assert response["Compatibility"] == TEST_BACKWARD_COMPATIBILITY
assert response["SchemaCheckpoint"] == 1
assert response["LatestSchemaVersion"] == 1
assert response["NextSchemaVersion"] == 2
assert response["SchemaStatus"] == TEST_AVAILABLE_STATUS
assert response["Tags"] == TEST_TAGS
assert "SchemaVersionId" in response
assert response["SchemaVersionStatus"] == TEST_AVAILABLE_STATUS
def test_create_schema_valid_input_registry_arn(client):
helpers.create_registry(client)
registry_id = {"RegistryArn": f"{TEST_REGISTRY_ARN}"}
response = client.create_schema(
RegistryId=registry_id,
SchemaName=TEST_SCHEMA_NAME,
DataFormat=TEST_AVRO_DATA_FORMAT,
Compatibility=TEST_BACKWARD_COMPATIBILITY,
SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION,
Description=TEST_DESCRIPTION,
Tags=TEST_TAGS,
)
assert response["RegistryName"] == TEST_REGISTRY_NAME
assert response["RegistryArn"] == TEST_REGISTRY_ARN
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["Description"] == TEST_DESCRIPTION
assert response["DataFormat"] == TEST_AVRO_DATA_FORMAT
assert response["Compatibility"] == TEST_BACKWARD_COMPATIBILITY
assert response["SchemaCheckpoint"] == 1
assert response["LatestSchemaVersion"] == 1
assert response["NextSchemaVersion"] == 2
assert response["SchemaStatus"] == TEST_AVAILABLE_STATUS
assert response["Tags"] == TEST_TAGS
assert "SchemaVersionId" in response
assert response["SchemaVersionStatus"] == TEST_AVAILABLE_STATUS
def test_create_schema_valid_partial_input(client):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
assert response["RegistryName"] == TEST_REGISTRY_NAME
assert response["RegistryArn"] == TEST_REGISTRY_ARN
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["DataFormat"] == TEST_AVRO_DATA_FORMAT
assert response["Compatibility"] == TEST_BACKWARD_COMPATIBILITY
assert response["SchemaCheckpoint"] == 1
assert response["LatestSchemaVersion"] == 1
assert response["NextSchemaVersion"] == 2
assert response["SchemaStatus"] == TEST_AVAILABLE_STATUS
assert "SchemaStatus" in response
assert "SchemaVersionId" in response
assert response["SchemaVersionStatus"] == TEST_AVAILABLE_STATUS
def test_create_schema_valid_default_registry(client):
helpers.create_registry(client)
empty_registry_id = {}
response = helpers.create_schema(client, registry_id=empty_registry_id)
default_registry_name = "default-registry"
assert response["RegistryName"] == default_registry_name
assert (
response["RegistryArn"]
== f"arn:aws:glue:us-east-1:{ACCOUNT_ID}:registry/{default_registry_name}"
)
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert (
response["SchemaArn"]
== f"arn:aws:glue:us-east-1:{ACCOUNT_ID}:schema/{default_registry_name}/{TEST_SCHEMA_NAME}"
)
assert response["DataFormat"] == TEST_AVRO_DATA_FORMAT
assert response["Compatibility"] == TEST_BACKWARD_COMPATIBILITY
assert response["SchemaCheckpoint"] == 1
assert response["LatestSchemaVersion"] == 1
assert response["NextSchemaVersion"] == 2
assert response["SchemaStatus"] == TEST_AVAILABLE_STATUS
assert "SchemaStatus" in response
assert "SchemaVersionId" in response
assert response["SchemaVersionStatus"] == TEST_AVAILABLE_STATUS
def test_create_schema_valid_default_registry_in_registry_id(client):
helpers.create_registry(client)
default_registry_name = "default-registry"
registry_id_default_registry = {"RegistryName": f"{default_registry_name}"}
response = helpers.create_schema(client, registry_id=registry_id_default_registry)
assert response["RegistryName"] == default_registry_name
assert (
response["RegistryArn"]
== f"arn:aws:glue:us-east-1:{ACCOUNT_ID}:registry/{default_registry_name}"
)
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert (
response["SchemaArn"]
== f"arn:aws:glue:us-east-1:{ACCOUNT_ID}:schema/{default_registry_name}/{TEST_SCHEMA_NAME}"
)
assert response["DataFormat"] == TEST_AVRO_DATA_FORMAT
assert response["Compatibility"] == TEST_BACKWARD_COMPATIBILITY
assert response["SchemaCheckpoint"] == 1
assert response["LatestSchemaVersion"] == 1
assert response["NextSchemaVersion"] == 2
assert response["SchemaStatus"] == TEST_AVAILABLE_STATUS
assert "SchemaStatus" in response
assert "SchemaVersionId" in response
assert response["SchemaVersionStatus"] == TEST_AVAILABLE_STATUS
def test_create_schema_invalid_registry_arn(client):
helpers.create_registry(client)
invalid_registry_arn = (
f"invalid:arn:aws:glue:us-east-1:{ACCOUNT_ID}:registry/{TEST_REGISTRY_NAME}"
)
invalid_registry_id = {"RegistryArn": f"{invalid_registry_arn}"}
with pytest.raises(ClientError) as exc:
helpers.create_schema(client, registry_id=invalid_registry_id)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "The parameter value contains one or more characters that are not valid. Parameter Name: registryArn"
)
def test_create_schema_invalid_registry_id_both_params_provided(client):
helpers.create_registry(client)
invalid_registry_id = {
"RegistryName": f"{TEST_REGISTRY_NAME}",
"RegistryArn": f"{TEST_REGISTRY_ARN}",
}
with pytest.raises(ClientError) as exc:
helpers.create_schema(client, registry_id=invalid_registry_id)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "One of registryName or registryArn has to be provided, both cannot be provided."
)
def test_create_schema_invalid_schema_name(client):
helpers.create_registry(client)
invalid_schema_name = "Invalid,Schema,Name"
with pytest.raises(ClientError) as exc:
client.create_schema(
RegistryId=TEST_REGISTRY_ID,
SchemaName=invalid_schema_name,
DataFormat=TEST_AVRO_DATA_FORMAT,
Compatibility=TEST_BACKWARD_COMPATIBILITY,
SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION,
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "The parameter value contains one or more characters that are not valid. Parameter Name: schemaName"
)
def test_create_schema_invalid_schema_name_too_long(client):
helpers.create_registry(client)
invalid_schema_name = ""
for _ in range(80):
invalid_schema_name = invalid_schema_name + "toolong"
with pytest.raises(ClientError) as exc:
client.create_schema(
RegistryId=TEST_REGISTRY_ID,
SchemaName=invalid_schema_name,
DataFormat=TEST_AVRO_DATA_FORMAT,
Compatibility=TEST_BACKWARD_COMPATIBILITY,
SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION,
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "The resource name contains too many or too few characters. Parameter Name: schemaName"
)
def test_create_schema_invalid_data_format(client):
helpers.create_registry(client)
invalid_data_format = "INVALID"
with pytest.raises(ClientError) as exc:
helpers.create_schema(client, TEST_REGISTRY_ID, data_format=invalid_data_format)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert err["Message"] == "Data format is not valid."
def test_create_schema_invalid_compatibility(client):
helpers.create_registry(client)
invalid_compatibility = "INVALID"
with pytest.raises(ClientError) as exc:
helpers.create_schema(
client, TEST_REGISTRY_ID, compatibility=invalid_compatibility
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert err["Message"] == "Compatibility is not valid."
def test_create_schema_invalid_schema_definition(client):
helpers.create_registry(client)
invalid_schema_definition = """{
"type":: "record",
}"""
with pytest.raises(ClientError) as exc:
helpers.create_schema(
client, TEST_REGISTRY_ID, schema_definition=invalid_schema_definition
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
f"Schema definition of {TEST_AVRO_DATA_FORMAT} data format is invalid"
in err["Message"]
)
# test register_schema_version
def test_register_schema_version_valid_input_avro(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
response = client.register_schema_version(
SchemaId=TEST_SCHEMA_ID, SchemaDefinition=TEST_NEW_AVRO_SCHEMA_DEFINITION
)
assert "SchemaVersionId" in response
assert response["VersionNumber"] == 2
assert response["Status"] == TEST_AVAILABLE_STATUS
def test_register_schema_version_valid_input_json(client):
helpers.create_registry(client)
helpers.create_schema(
client,
TEST_REGISTRY_ID,
data_format="JSON",
schema_definition=TEST_JSON_SCHEMA_DEFINITION,
)
response = client.register_schema_version(
SchemaId=TEST_SCHEMA_ID, SchemaDefinition=TEST_NEW_JSON_SCHEMA_DEFINITION
)
assert "SchemaVersionId" in response
assert response["VersionNumber"] == 2
assert response["Status"] == TEST_AVAILABLE_STATUS
def test_register_schema_version_valid_input_protobuf(client):
helpers.create_registry(client)
helpers.create_schema(
client,
TEST_REGISTRY_ID,
data_format="PROTOBUF",
schema_definition=TEST_PROTOBUF_SCHEMA_DEFINITION,
)
response = client.register_schema_version(
SchemaId=TEST_SCHEMA_ID, SchemaDefinition=TEST_NEW_PROTOBUF_SCHEMA_DEFINITION
)
assert "SchemaVersionId" in response
assert response["VersionNumber"] == 2
assert response["Status"] == TEST_AVAILABLE_STATUS
def test_register_schema_version_valid_input_schema_arn(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
schema_id = {"SchemaArn": TEST_SCHEMA_ARN}
response = client.register_schema_version(
SchemaId=schema_id, SchemaDefinition=TEST_NEW_AVRO_SCHEMA_DEFINITION
)
assert "SchemaVersionId" in response
assert response["VersionNumber"] == 2
assert response["Status"] == TEST_AVAILABLE_STATUS
def test_register_schema_version_identical_schema_version_avro(client):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
response = client.register_schema_version(
SchemaId=TEST_SCHEMA_ID, SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION
)
assert response["SchemaVersionId"] == version_id
assert response["VersionNumber"] == 1
assert response["Status"] == TEST_AVAILABLE_STATUS
def test_register_schema_version_identical_schema_version_json(client):
helpers.create_registry(client)
response = helpers.create_schema(
client,
TEST_REGISTRY_ID,
data_format=TEST_JSON_DATA_FORMAT,
schema_definition=TEST_JSON_SCHEMA_DEFINITION,
)
version_id = response["SchemaVersionId"]
response = client.register_schema_version(
SchemaId=TEST_SCHEMA_ID, SchemaDefinition=TEST_JSON_SCHEMA_DEFINITION
)
assert response["SchemaVersionId"] == version_id
assert response["VersionNumber"] == 1
assert response["Status"] == TEST_AVAILABLE_STATUS
def test_register_schema_version_identical_schema_version_protobuf(client):
helpers.create_registry(client)
response = helpers.create_schema(
client,
TEST_REGISTRY_ID,
data_format=TEST_PROTOBUF_DATA_FORMAT,
schema_definition=TEST_PROTOBUF_SCHEMA_DEFINITION,
)
version_id = response["SchemaVersionId"]
response = client.register_schema_version(
SchemaId=TEST_SCHEMA_ID, SchemaDefinition=TEST_PROTOBUF_SCHEMA_DEFINITION
)
assert response["SchemaVersionId"] == version_id
assert response["VersionNumber"] == 1
assert response["Status"] == TEST_AVAILABLE_STATUS
def test_register_schema_version_invalid_registry_schema_does_not_exist(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
with pytest.raises(ClientError) as exc:
client.register_schema_version(
SchemaId=TEST_INVALID_SCHEMA_ID_REGISTRY_DOES_NOT_EXIST,
SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION,
)
err = exc.value.response["Error"]
assert err["Code"] == "EntityNotFoundException"
assert "Schema is not found." in err["Message"]
def test_register_schema_version_invalid_schema_schema_does_not_exist(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
with pytest.raises(ClientError) as exc:
client.register_schema_version(
SchemaId=TEST_INVALID_SCHEMA_ID_SCHEMA_DOES_NOT_EXIST,
SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION,
)
err = exc.value.response["Error"]
assert err["Code"] == "EntityNotFoundException"
assert "Schema is not found." in err["Message"]
def test_register_schema_version_invalid_compatibility_disabled(client):
helpers.create_registry(client)
helpers.create_schema(
client, TEST_REGISTRY_ID, compatibility=TEST_DISABLED_COMPATIBILITY
)
with pytest.raises(ClientError) as exc:
client.register_schema_version(
SchemaId=TEST_SCHEMA_ID, SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== f"Compatibility DISABLED does not allow versioning. SchemaId: SchemaId(schemaArn=null, schemaName={TEST_SCHEMA_NAME}, registryName={TEST_REGISTRY_NAME})"
)
def test_register_schema_version_invalid_schema_definition(client):
helpers.create_registry(client)
helpers.create_schema(
client, TEST_REGISTRY_ID, compatibility=TEST_DISABLED_COMPATIBILITY
)
with pytest.raises(ClientError) as exc:
client.register_schema_version(
SchemaId=TEST_SCHEMA_ID, SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert "Compatibility DISABLED does not allow versioning." in err["Message"]
def test_register_schema_version_invalid_schema_id(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
invalid_schema_id = {
"SchemaArn": TEST_SCHEMA_ARN,
"RegistryName": TEST_REGISTRY_NAME,
"SchemaName": TEST_INVALID_SCHEMA_NAME_DOES_NOT_EXIST,
}
with pytest.raises(ClientError) as exc:
client.register_schema_version(
SchemaId=invalid_schema_id, SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "One of (registryName and schemaName) or schemaArn has to be provided, both cannot be provided."
)
# test get_schema_version
def test_get_schema_version_valid_input_schema_version_id(client):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
response = client.get_schema_version(
SchemaVersionId=version_id,
)
assert response["SchemaVersionId"] == version_id
assert response["SchemaDefinition"] == TEST_AVRO_SCHEMA_DEFINITION
assert response["DataFormat"] == TEST_AVRO_DATA_FORMAT
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["VersionNumber"] == 1
assert response["Status"] == TEST_AVAILABLE_STATUS
assert "CreatedTime" in response
def test_get_schema_version_valid_input_version_number(client):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
response = client.get_schema_version(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER,
)
assert response["SchemaVersionId"] == version_id
assert response["SchemaDefinition"] == TEST_AVRO_SCHEMA_DEFINITION
assert response["DataFormat"] == TEST_AVRO_DATA_FORMAT
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["VersionNumber"] == 1
assert response["Status"] == TEST_AVAILABLE_STATUS
assert "CreatedTime" in response
def test_get_schema_version_valid_input_version_number_latest_version(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
response = helpers.register_schema_version(client)
version_id = response["SchemaVersionId"]
response = client.get_schema_version(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER_LATEST_VERSION,
)
assert response["SchemaVersionId"] == version_id
assert response["SchemaDefinition"] == TEST_NEW_AVRO_SCHEMA_DEFINITION
assert response["DataFormat"] == TEST_AVRO_DATA_FORMAT
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["VersionNumber"] == 2
assert response["Status"] == TEST_AVAILABLE_STATUS
assert "CreatedTime" in response
def test_get_schema_version_empty_input(client):
with pytest.raises(ClientError) as exc:
client.get_schema_version()
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "At least one of (registryName and schemaName) or schemaArn has to be provided."
)
def test_get_schema_version_invalid_schema_id_schema_version_number_both_provided(
client,
):
with pytest.raises(ClientError) as exc:
client.get_schema_version(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionId=TEST_VERSION_ID,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER_LATEST_VERSION,
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "No other input parameters can be specified when fetching by SchemaVersionId."
)
def test_get_schema_version_insufficient_params_provided(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
with pytest.raises(ClientError) as exc:
client.get_schema_version(SchemaId=TEST_SCHEMA_ID)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert err["Message"] == "One of version number (or) latest version is required."
def test_get_schema_version_invalid_schema_version_number(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
invalid_schema_version_number = {"VersionNumber": 1, "LatestVersion": True}
with pytest.raises(ClientError) as exc:
client.get_schema_version(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=invalid_schema_version_number,
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert err["Message"] == "Only one of VersionNumber or LatestVersion is required."
def test_get_schema_version_invalid_version_number(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
invalid_schema_version_number = {"VersionNumber": 2}
with pytest.raises(ClientError) as exc:
client.get_schema_version(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=invalid_schema_version_number,
)
err = exc.value.response["Error"]
assert err["Code"] == "EntityNotFoundException"
assert "Schema version is not found." in err["Message"]
def test_get_schema_version_invalid_schema_id_schema_name(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
with pytest.raises(ClientError) as exc:
client.get_schema_version(
SchemaId=TEST_INVALID_SCHEMA_ID_SCHEMA_DOES_NOT_EXIST,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER,
)
err = exc.value.response["Error"]
assert err["Code"] == "EntityNotFoundException"
assert (
err["Message"]
== f"Schema is not found. RegistryName: {TEST_REGISTRY_NAME}, SchemaName: {TEST_INVALID_SCHEMA_NAME_DOES_NOT_EXIST}, SchemaArn: null"
)
def test_get_schema_version_invalid_schema_id_registry_name(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
with pytest.raises(ClientError) as exc:
client.get_schema_version(
SchemaId=TEST_INVALID_SCHEMA_ID_REGISTRY_DOES_NOT_EXIST,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER,
)
err = exc.value.response["Error"]
assert err["Code"] == "EntityNotFoundException"
assert "Schema is not found." in err["Message"]
def test_get_schema_version_invalid_schema_version(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
invalid_schema_version_id = "00000000-0000-0000-0000-00000000000p"
with pytest.raises(ClientError) as exc:
client.get_schema_version(SchemaVersionId=invalid_schema_version_id)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "The parameter value contains one or more characters that are not valid. Parameter Name: SchemaVersionId"
)
# Test get_schema_by_definition
def test_get_schema_by_definition_valid_input(client):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
response = client.get_schema_by_definition(
SchemaId=TEST_SCHEMA_ID,
SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION,
)
assert response["SchemaVersionId"] == version_id
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["DataFormat"] == TEST_AVRO_DATA_FORMAT
assert response["Status"] == TEST_AVAILABLE_STATUS
assert "CreatedTime" in response
def test_get_schema_by_definition_invalid_schema_id_schema_does_not_exist(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
with pytest.raises(ClientError) as exc:
client.get_schema_by_definition(
SchemaId=TEST_INVALID_SCHEMA_ID_SCHEMA_DOES_NOT_EXIST,
SchemaDefinition=TEST_AVRO_SCHEMA_DEFINITION,
)
err = exc.value.response["Error"]
assert err["Code"] == "EntityNotFoundException"
assert "Schema is not found." in err["Message"]
def test_get_schema_by_definition_invalid_schema_definition_does_not_exist(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
with pytest.raises(ClientError) as exc:
client.get_schema_by_definition(
SchemaId=TEST_SCHEMA_ID,
SchemaDefinition=TEST_NEW_AVRO_SCHEMA_DEFINITION,
)
err = exc.value.response["Error"]
assert err["Code"] == "EntityNotFoundException"
assert "Schema is not found." in err["Message"]
# test put_schema_version_metadata
def test_put_schema_version_metadata_valid_input_schema_version_number(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
response = client.put_schema_version_metadata(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER,
MetadataKeyValue=TEST_METADATA_KEY_VALUE,
)
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert response["RegistryName"] == TEST_REGISTRY_NAME
assert response["LatestVersion"] is False
assert response["VersionNumber"] == 1
assert response["MetadataKey"] == TEST_METADATA_KEY_VALUE["MetadataKey"]
assert response["MetadataValue"] == TEST_METADATA_KEY_VALUE["MetadataValue"]
def test_put_schema_version_metadata_valid_input_schema_version_id(client):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
response = client.put_schema_version_metadata(
SchemaVersionId=version_id,
MetadataKeyValue=TEST_METADATA_KEY_VALUE,
)
assert response["SchemaVersionId"] == version_id
assert response["LatestVersion"] is False
assert response["VersionNumber"] == 0
assert response["MetadataKey"] == TEST_METADATA_KEY
assert response["MetadataValue"] == TEST_METADATA_VALUE
def test_put_schema_version_metadata_more_than_allowed_schema_version_id(client):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
for i in range(10):
client.put_schema_version_metadata(
SchemaVersionId=version_id,
MetadataKeyValue={
"MetadataKey": f"test_metadata_key{i}",
"MetadataValue": f"test_metadata_value{i}",
},
)
with pytest.raises(ClientError) as exc:
client.put_schema_version_metadata(
SchemaVersionId=version_id,
MetadataKeyValue=TEST_METADATA_KEY_VALUE,
)
err = exc.value.response["Error"]
assert err["Code"] == "ResourceNumberLimitExceededException"
assert (
err["Message"]
== "Your resource limits for Schema Version Metadata have been exceeded."
)
def test_put_schema_version_metadata_more_than_allowed_schema_version_id_same_key(
client,
):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
for i in range(10):
client.put_schema_version_metadata(
SchemaVersionId=version_id,
MetadataKeyValue={
"MetadataKey": "test_metadata_key",
"MetadataValue": f"test_metadata_value{i}",
},
)
with pytest.raises(ClientError) as exc:
client.put_schema_version_metadata(
SchemaVersionId=version_id,
MetadataKeyValue=TEST_METADATA_KEY_VALUE,
)
err = exc.value.response["Error"]
assert err["Code"] == "ResourceNumberLimitExceededException"
assert (
err["Message"]
== "Your resource limits for Schema Version Metadata have been exceeded."
)
def test_put_schema_version_metadata_already_exists_schema_version_id(client):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
client.put_schema_version_metadata(
SchemaVersionId=version_id,
MetadataKeyValue=TEST_METADATA_KEY_VALUE,
)
with pytest.raises(ClientError) as exc:
client.put_schema_version_metadata(
SchemaVersionId=version_id,
MetadataKeyValue=TEST_METADATA_KEY_VALUE,
)
err = exc.value.response["Error"]
assert err["Code"] == "AlreadyExistsException"
assert (
err["Message"]
== f"Resource already exist for schema version id: {version_id}, metadata key: {TEST_METADATA_KEY}, metadata value: {TEST_METADATA_VALUE}"
)
def test_put_schema_version_metadata_invalid_characters_metadata_key_schema_version_id(
client,
):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
invalid_metadata_key = {
"MetadataKey": "invalid~metadata~key",
"MetadataValue": TEST_METADATA_VALUE,
}
with pytest.raises(ClientError) as exc:
client.put_schema_version_metadata(
SchemaVersionId=version_id,
MetadataKeyValue=invalid_metadata_key,
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
err["Message"]
== "The parameter value contains one or more characters that are not valid. Parameter Name: key"
)
def test_put_schema_version_metadata_invalid_characters_metadata_value_schema_version_id(
client,
):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
invalid_metadata_value = {
"MetadataKey": TEST_METADATA_KEY,
"MetadataValue": "invalid~metadata~value",
}
with pytest.raises(ClientError) as exc:
client.put_schema_version_metadata(
SchemaVersionId=version_id,
MetadataKeyValue=invalid_metadata_value,
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert "value contains one or more characters that are not valid." in err["Message"]
def test_put_schema_version_metadata_more_than_allowed_schema_version_number(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
for i in range(10):
client.put_schema_version_metadata(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER,
MetadataKeyValue={
"MetadataKey": f"test_metadata_key{i}",
"MetadataValue": f"test_metadata_value{i}",
},
)
with pytest.raises(ClientError) as exc:
client.put_schema_version_metadata(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER,
MetadataKeyValue=TEST_METADATA_KEY_VALUE,
)
err = exc.value.response["Error"]
assert err["Code"] == "ResourceNumberLimitExceededException"
assert (
err["Message"]
== "Your resource limits for Schema Version Metadata have been exceeded."
)
def test_put_schema_version_metadata_already_exists_schema_version_number(client):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
client.put_schema_version_metadata(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER,
MetadataKeyValue=TEST_METADATA_KEY_VALUE,
)
with pytest.raises(ClientError) as exc:
client.put_schema_version_metadata(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER,
MetadataKeyValue=TEST_METADATA_KEY_VALUE,
)
err = exc.value.response["Error"]
assert err["Code"] == "AlreadyExistsException"
assert (
err["Message"]
== f"Resource already exist for schema version id: {version_id}, metadata key: {TEST_METADATA_KEY}, metadata value: {TEST_METADATA_VALUE}"
)
def test_put_schema_version_metadata_invalid_characters_metadata_key_schema_version_number(
client,
):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
invalid_metadata_key = {
"MetadataKey": "invalid~metadata~key",
"MetadataValue": TEST_METADATA_VALUE,
}
with pytest.raises(ClientError) as exc:
client.put_schema_version_metadata(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER,
MetadataKeyValue=invalid_metadata_key,
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert (
"The parameter value contains one or more characters that are not valid."
in err["Message"]
)
def test_put_schema_version_metadata_invalid_characters_metadata_value_schema_version_number(
client,
):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
invalid_metadata_value = {
"MetadataKey": TEST_METADATA_KEY,
"MetadataValue": "invalid~metadata~value",
}
with pytest.raises(ClientError) as exc:
client.put_schema_version_metadata(
SchemaId=TEST_SCHEMA_ID,
SchemaVersionNumber=TEST_SCHEMA_VERSION_NUMBER,
MetadataKeyValue=invalid_metadata_value,
)
err = exc.value.response["Error"]
assert err["Code"] == "InvalidInputException"
assert "value contains one or more characters that are not valid." in err["Message"]
def test_get_schema(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
response = client.get_schema(
SchemaId={"RegistryName": TEST_REGISTRY_NAME, "SchemaName": TEST_SCHEMA_NAME}
)
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["SchemaName"] == TEST_SCHEMA_NAME
def test_update_schema(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
client.update_schema(
SchemaId={"RegistryName": TEST_REGISTRY_NAME, "SchemaName": TEST_SCHEMA_NAME},
Compatibility="FORWARD",
Description="updated schema",
)
response = client.get_schema(
SchemaId={"RegistryName": TEST_REGISTRY_NAME, "SchemaName": TEST_SCHEMA_NAME}
)
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert response["Description"] == "updated schema"
assert response["Compatibility"] == "FORWARD"
# test delete_schema
def test_delete_schema_valid_input(client):
helpers.create_registry(client)
helpers.create_schema(client, TEST_REGISTRY_ID)
response = client.delete_schema(SchemaId=TEST_SCHEMA_ID)
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert response["Status"] == TEST_DELETING_STATUS
def test_delete_schema_valid_input_schema_arn(client):
helpers.create_registry(client)
response = helpers.create_schema(client, TEST_REGISTRY_ID)
version_id = response["SchemaVersionId"]
schema_id = {"SchemaArn": f"{TEST_SCHEMA_ARN}"}
response = client.delete_schema(SchemaId=schema_id)
assert response["SchemaArn"] == TEST_SCHEMA_ARN
assert response["SchemaName"] == TEST_SCHEMA_NAME
assert response["Status"] == TEST_DELETING_STATUS
with pytest.raises(ClientError) as exc:
client.get_schema_version(SchemaVersionId=version_id)
err = exc.value.response["Error"]
assert err["Code"] == "EntityNotFoundException"
assert "Schema version is not found." in err["Message"]
def test_delete_schema_schema_not_found(client):
helpers.create_registry(client)
with pytest.raises(ClientError) as exc:
client.delete_schema(SchemaId=TEST_SCHEMA_ID)
err = exc.value.response["Error"]
assert err["Code"] == "EntityNotFoundException"
assert (
err["Message"]
== f"Schema is not found. RegistryName: {TEST_REGISTRY_NAME}, SchemaName: {TEST_SCHEMA_NAME}, SchemaArn: null"
)
def test_list_registries(client):
helpers.create_registry(client)
helpers.create_registry(client, registry_name="registry2")
registries = client.list_registries()["Registries"]
assert len(registries) == 2
@pytest.mark.parametrize("name_or_arn", ["RegistryArn", "RegistryName"])
def test_get_registry(client, name_or_arn):
x = helpers.create_registry(client)
r = client.get_registry(RegistryId={name_or_arn: x[name_or_arn]})
assert r["RegistryName"] == x["RegistryName"]
assert r["RegistryArn"] == x["RegistryArn"]
@pytest.mark.parametrize("name_or_arn", ["RegistryArn", "RegistryName"])
def test_delete_registry(client, name_or_arn):
x = helpers.create_registry(client)
client.delete_registry(RegistryId={name_or_arn: x[name_or_arn]})
assert len(client.list_registries()["Registries"]) == 0