1309 lines
43 KiB
Python
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
|