1315 lines
46 KiB
Python
1315 lines
46 KiB
Python
"""Unit tests for glue-schema-registry-supported APIs."""
|
|
import boto3
|
|
import pytest
|
|
import sure # noqa # pylint: disable=unused-import
|
|
from botocore.client import ClientError
|
|
from moto.core import DEFAULT_ACCOUNT_ID as ACCOUNT_ID
|
|
|
|
from moto import mock_glue
|
|
|
|
from . import helpers
|
|
from .fixtures.schema_registry import (
|
|
TEST_REGISTRY_NAME,
|
|
TEST_REGISTRY_ARN,
|
|
TEST_DESCRIPTION,
|
|
TEST_TAGS,
|
|
TEST_SCHEMA_NAME,
|
|
TEST_SCHEMA_ARN,
|
|
TEST_AVRO_SCHEMA_DEFINITION,
|
|
TEST_NEW_AVRO_SCHEMA_DEFINITION,
|
|
TEST_JSON_SCHEMA_DEFINITION,
|
|
TEST_NEW_JSON_SCHEMA_DEFINITION,
|
|
TEST_PROTOBUF_SCHEMA_DEFINITION,
|
|
TEST_NEW_PROTOBUF_SCHEMA_DEFINITION,
|
|
TEST_AVRO_DATA_FORMAT,
|
|
TEST_JSON_DATA_FORMAT,
|
|
TEST_PROTOBUF_DATA_FORMAT,
|
|
TEST_REGISTRY_ID,
|
|
TEST_SCHEMA_ID,
|
|
TEST_BACKWARD_COMPATIBILITY,
|
|
TEST_DISABLED_COMPATIBILITY,
|
|
TEST_AVAILABLE_STATUS,
|
|
TEST_SCHEMA_VERSION_NUMBER,
|
|
TEST_SCHEMA_VERSION_NUMBER_LATEST_VERSION,
|
|
TEST_VERSION_ID,
|
|
TEST_INVALID_SCHEMA_NAME_DOES_NOT_EXIST,
|
|
TEST_INVALID_SCHEMA_ID_SCHEMA_DOES_NOT_EXIST,
|
|
TEST_INVALID_SCHEMA_ID_REGISTRY_DOES_NOT_EXIST,
|
|
TEST_METADATA_KEY_VALUE,
|
|
TEST_METADATA_KEY,
|
|
TEST_METADATA_VALUE,
|
|
TEST_DELETING_STATUS,
|
|
)
|
|
|
|
|
|
@pytest.fixture(name="client")
|
|
def fixture_client():
|
|
with mock_glue():
|
|
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
|
|
)
|
|
response.should.have.key("RegistryName").equals(TEST_REGISTRY_NAME)
|
|
response.should.have.key("Description").equals(TEST_DESCRIPTION)
|
|
response.should.have.key("Tags").equals(TEST_TAGS)
|
|
response.should.have.key("RegistryArn").equals(TEST_REGISTRY_ARN)
|
|
|
|
|
|
def test_create_registry_valid_partial_input(client):
|
|
response = client.create_registry(RegistryName=TEST_REGISTRY_NAME)
|
|
response.should.have.key("RegistryName").equals(TEST_REGISTRY_NAME)
|
|
response.should.have.key("RegistryArn").equals(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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("ResourceNumberLimitExceededException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("AlreadyExistsException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal("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,
|
|
)
|
|
response.should.have.key("RegistryName").equals(TEST_REGISTRY_NAME)
|
|
response.should.have.key("RegistryArn").equals(TEST_REGISTRY_ARN)
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("Description").equals(TEST_DESCRIPTION)
|
|
response.should.have.key("DataFormat").equals(TEST_AVRO_DATA_FORMAT)
|
|
response.should.have.key("Compatibility").equals(TEST_BACKWARD_COMPATIBILITY)
|
|
response.should.have.key("SchemaCheckpoint").equals(1)
|
|
response.should.have.key("LatestSchemaVersion").equals(1)
|
|
response.should.have.key("NextSchemaVersion").equals(2)
|
|
response.should.have.key("SchemaStatus").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("Tags").equals(TEST_TAGS)
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("SchemaVersionStatus").equals(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,
|
|
)
|
|
response.should.have.key("RegistryName").equals(TEST_REGISTRY_NAME)
|
|
response.should.have.key("RegistryArn").equals(TEST_REGISTRY_ARN)
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("Description").equals(TEST_DESCRIPTION)
|
|
response.should.have.key("DataFormat").equals(TEST_JSON_DATA_FORMAT)
|
|
response.should.have.key("Compatibility").equals(TEST_BACKWARD_COMPATIBILITY)
|
|
response.should.have.key("SchemaCheckpoint").equals(1)
|
|
response.should.have.key("LatestSchemaVersion").equals(1)
|
|
response.should.have.key("NextSchemaVersion").equals(2)
|
|
response.should.have.key("SchemaStatus").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("Tags").equals(TEST_TAGS)
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("SchemaVersionStatus").equals(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,
|
|
)
|
|
response.should.have.key("RegistryName").equals(TEST_REGISTRY_NAME)
|
|
response.should.have.key("RegistryArn").equals(TEST_REGISTRY_ARN)
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("Description").equals(TEST_DESCRIPTION)
|
|
response.should.have.key("DataFormat").equals(TEST_PROTOBUF_DATA_FORMAT)
|
|
response.should.have.key("Compatibility").equals(TEST_BACKWARD_COMPATIBILITY)
|
|
response.should.have.key("SchemaCheckpoint").equals(1)
|
|
response.should.have.key("LatestSchemaVersion").equals(1)
|
|
response.should.have.key("NextSchemaVersion").equals(2)
|
|
response.should.have.key("SchemaStatus").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("Tags").equals(TEST_TAGS)
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("SchemaVersionStatus").equals(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,
|
|
)
|
|
response.should.have.key("RegistryName").equals(TEST_REGISTRY_NAME)
|
|
response.should.have.key("RegistryArn").equals(TEST_REGISTRY_ARN)
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("Description").equals(TEST_DESCRIPTION)
|
|
response.should.have.key("DataFormat").equals(TEST_AVRO_DATA_FORMAT)
|
|
response.should.have.key("Compatibility").equals(TEST_BACKWARD_COMPATIBILITY)
|
|
response.should.have.key("SchemaCheckpoint").equals(1)
|
|
response.should.have.key("LatestSchemaVersion").equals(1)
|
|
response.should.have.key("NextSchemaVersion").equals(2)
|
|
response.should.have.key("SchemaStatus").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("Tags").equals(TEST_TAGS)
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("SchemaVersionStatus").equals(TEST_AVAILABLE_STATUS)
|
|
|
|
|
|
def test_create_schema_valid_partial_input(client):
|
|
helpers.create_registry(client)
|
|
|
|
response = helpers.create_schema(client, TEST_REGISTRY_ID)
|
|
response.should.have.key("RegistryName").equals(TEST_REGISTRY_NAME)
|
|
response.should.have.key("RegistryArn").equals(TEST_REGISTRY_ARN)
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("DataFormat").equals(TEST_AVRO_DATA_FORMAT)
|
|
response.should.have.key("Compatibility").equals(TEST_BACKWARD_COMPATIBILITY)
|
|
response.should.have.key("SchemaCheckpoint").equals(1)
|
|
response.should.have.key("LatestSchemaVersion").equals(1)
|
|
response.should.have.key("NextSchemaVersion").equals(2)
|
|
response.should.have.key("SchemaStatus").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("SchemaStatus")
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("SchemaVersionStatus").equals(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"
|
|
response.should.have.key("RegistryName").equals(default_registry_name)
|
|
response.should.have.key("RegistryArn").equals(
|
|
f"arn:aws:glue:us-east-1:{ACCOUNT_ID}:registry/{default_registry_name}"
|
|
)
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("SchemaArn").equals(
|
|
f"arn:aws:glue:us-east-1:{ACCOUNT_ID}:schema/{default_registry_name}/{TEST_SCHEMA_NAME}"
|
|
)
|
|
response.should.have.key("DataFormat").equals(TEST_AVRO_DATA_FORMAT)
|
|
response.should.have.key("Compatibility").equals(TEST_BACKWARD_COMPATIBILITY)
|
|
response.should.have.key("SchemaCheckpoint").equals(1)
|
|
response.should.have.key("LatestSchemaVersion").equals(1)
|
|
response.should.have.key("NextSchemaVersion").equals(2)
|
|
response.should.have.key("SchemaStatus").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("SchemaStatus")
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("SchemaVersionStatus").equals(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)
|
|
|
|
response.should.have.key("RegistryName").equals(default_registry_name)
|
|
response.should.have.key("RegistryArn").equals(
|
|
f"arn:aws:glue:us-east-1:{ACCOUNT_ID}:registry/{default_registry_name}"
|
|
)
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("SchemaArn").equals(
|
|
f"arn:aws:glue:us-east-1:{ACCOUNT_ID}:schema/{default_registry_name}/{TEST_SCHEMA_NAME}"
|
|
)
|
|
response.should.have.key("DataFormat").equals(TEST_AVRO_DATA_FORMAT)
|
|
response.should.have.key("Compatibility").equals(TEST_BACKWARD_COMPATIBILITY)
|
|
response.should.have.key("SchemaCheckpoint").equals(1)
|
|
response.should.have.key("LatestSchemaVersion").equals(1)
|
|
response.should.have.key("NextSchemaVersion").equals(2)
|
|
response.should.have.key("SchemaStatus").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("SchemaStatus")
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("SchemaVersionStatus").equals(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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal("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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal("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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.have(
|
|
f"Schema definition of {TEST_AVRO_DATA_FORMAT} data format is invalid"
|
|
)
|
|
|
|
|
|
# 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
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("VersionNumber").equals(2)
|
|
response.should.have.key("Status").equals(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
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("VersionNumber").equals(2)
|
|
response.should.have.key("Status").equals(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
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("VersionNumber").equals(2)
|
|
response.should.have.key("Status").equals(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
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId")
|
|
response.should.have.key("VersionNumber").equals(2)
|
|
response.should.have.key("Status").equals(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
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId").equals(version_id)
|
|
response.should.have.key("VersionNumber").equals(1)
|
|
response.should.have.key("Status").equals(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
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId").equals(version_id)
|
|
response.should.have.key("VersionNumber").equals(1)
|
|
response.should.have.key("Status").equals(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
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId").equals(version_id)
|
|
response.should.have.key("VersionNumber").equals(1)
|
|
response.should.have.key("Status").equals(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"]
|
|
err["Code"].should.equal("EntityNotFoundException")
|
|
err["Message"].should.have("Schema is not found.")
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("EntityNotFoundException")
|
|
err["Message"].should.have("Schema is not found.")
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.have("Schema definition of JSON data format is invalid:")
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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,
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId").equals(version_id)
|
|
response.should.have.key("SchemaDefinition").equals(TEST_AVRO_SCHEMA_DEFINITION)
|
|
response.should.have.key("DataFormat").equals(TEST_AVRO_DATA_FORMAT)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("VersionNumber").equals(1)
|
|
response.should.have.key("Status").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("CreatedTime")
|
|
|
|
|
|
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,
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId").equals(version_id)
|
|
response.should.have.key("SchemaDefinition").equals(TEST_AVRO_SCHEMA_DEFINITION)
|
|
response.should.have.key("DataFormat").equals(TEST_AVRO_DATA_FORMAT)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("VersionNumber").equals(1)
|
|
response.should.have.key("Status").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("CreatedTime")
|
|
|
|
|
|
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,
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId").equals(version_id)
|
|
response.should.have.key("SchemaDefinition").equals(TEST_NEW_AVRO_SCHEMA_DEFINITION)
|
|
response.should.have.key("DataFormat").equals(TEST_AVRO_DATA_FORMAT)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("VersionNumber").equals(2)
|
|
response.should.have.key("Status").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("CreatedTime")
|
|
|
|
|
|
def test_get_schema_version_empty_input(client):
|
|
|
|
with pytest.raises(ClientError) as exc:
|
|
client.get_schema_version()
|
|
|
|
err = exc.value.response["Error"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.have(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("EntityNotFoundException")
|
|
err["Message"].should.have("Schema is not found.")
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("EntityNotFoundException")
|
|
err["Message"].should.equal(
|
|
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"]
|
|
err["Code"].should.equal("EntityNotFoundException")
|
|
err["Message"].should.have("Schema is not found.")
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.equal(
|
|
"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,
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId").equals(version_id)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("DataFormat").equals(TEST_AVRO_DATA_FORMAT)
|
|
response.should.have.key("Status").equals(TEST_AVAILABLE_STATUS)
|
|
response.should.have.key("CreatedTime")
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("EntityNotFoundException")
|
|
err["Message"].should.have("Schema is not found.")
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("EntityNotFoundException")
|
|
err["Message"].should.have("Schema is not found.")
|
|
|
|
|
|
# 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,
|
|
)
|
|
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("RegistryName").equals(TEST_REGISTRY_NAME)
|
|
response.should.have.key("LatestVersion").equals(False)
|
|
response.should.have.key("VersionNumber").equals(1)
|
|
response.should.have.key("MetadataKey").equals(
|
|
TEST_METADATA_KEY_VALUE["MetadataKey"]
|
|
)
|
|
response.should.have.key("MetadataValue").equals(
|
|
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,
|
|
)
|
|
|
|
response.should.have.key("SchemaVersionId").equals(version_id)
|
|
response.should.have.key("LatestVersion").equals(False)
|
|
response.should.have.key("VersionNumber").equals(0)
|
|
response.should.have.key("MetadataKey").equals(TEST_METADATA_KEY)
|
|
response.should.have.key("MetadataValue").equals(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"]
|
|
err["Code"].should.equal("ResourceNumberLimitExceededException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("ResourceNumberLimitExceededException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("AlreadyExistsException")
|
|
err["Message"].should.equal(
|
|
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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.have(
|
|
"key contains one or more characters that are not valid."
|
|
)
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.have(
|
|
"value contains one or more characters that are not valid."
|
|
)
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("ResourceNumberLimitExceededException")
|
|
err["Message"].should.equal(
|
|
"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"]
|
|
err["Code"].should.equal("AlreadyExistsException")
|
|
err["Message"].should.equal(
|
|
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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.have(
|
|
"key contains one or more characters that are not valid."
|
|
)
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("InvalidInputException")
|
|
err["Message"].should.have(
|
|
"value contains one or more characters that are not valid."
|
|
)
|
|
|
|
|
|
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}
|
|
)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("SchemaName").equals(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}
|
|
)
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("Description").equals("updated schema")
|
|
response.should.have.key("Compatibility").equals("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,
|
|
)
|
|
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("Status").equals(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,
|
|
)
|
|
|
|
response.should.have.key("SchemaArn").equals(TEST_SCHEMA_ARN)
|
|
response.should.have.key("SchemaName").equals(TEST_SCHEMA_NAME)
|
|
response.should.have.key("Status").equals(TEST_DELETING_STATUS)
|
|
|
|
with pytest.raises(ClientError) as exc:
|
|
client.get_schema_version(
|
|
SchemaVersionId=version_id,
|
|
)
|
|
|
|
err = exc.value.response["Error"]
|
|
err["Code"].should.equal("EntityNotFoundException")
|
|
err["Message"].should.have("Schema is not found.")
|
|
|
|
|
|
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"]
|
|
err["Code"].should.equal("EntityNotFoundException")
|
|
err["Message"].should.have(
|
|
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"]
|
|
registries.should.have.length_of(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]})
|
|
r.should.have.key("RegistryName").equals(x["RegistryName"])
|
|
r.should.have.key("RegistryArn").equals(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]})
|
|
client.list_registries()["Registries"].should.have.length_of(0)
|