def test_get(_clean_specs_table):
"""
GIVEN user and database and storage with a single spec
WHEN get is called with the user and spec id
THEN the spec value is returned.
"""
user = "******"
spec_name = "spec name 1"
version = "1"
package_database.get().create_update_spec(
sub=user, name=spec_name, version=version, model_count=1
)
spec = {"components": {}}
storage.get_storage_facade().create_update_spec(
user=user,
name=spec_name,
version=version,
spec_str=json.dumps(spec, separators=(",", ":")),
)
response = specs.get(user=user, spec_name=spec_name)
assert response.status_code == 200
assert response.mimetype == "application/json"
response_data_json = json.loads(response.data.decode())
assert f"version: '{version}'" in response_data_json["value"]
assert "components: {}" in response_data_json["value"]
assert response_data_json["name"] == spec_name
assert response_data_json["version"] == version
def test_delete_database_error(monkeypatch, _clean_specs_table):
"""
GIVEN database that raises a DatabaseError and storage with spec and user and spec
id
WHEN put is called with the body and spec id
THEN the spec is deleted from the storage.
"""
spec_name = "id 1"
user = "******"
version = "1"
mock_database_delete_spec = mock.MagicMock()
mock_database_delete_spec.side_effect = package_database.exceptions.BaseError
monkeypatch.setattr(
package_database.get(),
"delete_spec",
mock_database_delete_spec,
)
storage.get_storage_facade().create_update_spec(
user=user, name=spec_name, version=version, spec_str="spec str 1"
)
response = specs.delete(spec_name=spec_name, user=user)
with pytest.raises(storage.exceptions.StorageError):
storage.get_storage_facade().get_spec(
user=user, name=spec_name, version=version
)
assert response.status_code == 204
def test_delete_storage_error(monkeypatch, _clean_specs_table):
"""
GIVEN database and storage that raises a StorageError with spec and user and spec
id
WHEN put is called with the body and spec id
THEN the spec is deleted from the database.
"""
spec_name = "id 1"
user = "******"
version = "1"
package_database.get().create_update_spec(
sub=user, name=spec_name, version=version, model_count=1
)
mock_storage_delete_spec = mock.MagicMock()
mock_storage_delete_spec.side_effect = storage.exceptions.StorageError
monkeypatch.setattr(
storage.get_storage_facade(),
"delete_spec",
mock_storage_delete_spec,
)
response = specs.delete(spec_name=spec_name, user=user)
assert package_database.get().count_customer_models(sub=user) == 0
assert response.status_code == 204
def test_get_spec():
"""
GIVEN user, name, version and spec str
WHEN create_update_spec is called with the user, canonically identical name, version
and spec str and
then get_spec is called with the user and name
THEN the spec str is returned or ObjectNotFoundError is raised.
"""
user = "******"
name = "name 1"
version_1 = "version 1"
spec_str_1 = "spec str 1"
storage_instance = storage.get_storage_facade()
storage_instance.create_update_spec(user=user,
name=name,
version=version_1,
spec_str=spec_str_1)
assert (storage_instance.get_spec(user=user, name=name,
version=version_1) == spec_str_1)
# Retry with a different name that resolves to the same canonical name
assert (storage_instance.get_spec(user=user,
name=name.upper(),
version=version_1) == spec_str_1)
spec_str_2 = "spec str 2"
storage_instance.create_update_spec(user=user,
name=name,
version=version_1,
spec_str=spec_str_2)
assert (storage_instance.get_spec(user=user, name=name,
version=version_1) == spec_str_2)
version_2 = "version 2"
with pytest.raises(storage.exceptions.ObjectNotFoundError):
storage_instance.get_spec(user=user, name=name, version=version_2)
spec_str_3 = "spec str 3"
storage_instance.create_update_spec(user=user,
name=name,
version=version_2,
spec_str=spec_str_3)
assert (storage_instance.get_spec(user=user, name=name,
version=version_2) == spec_str_3)
# Update using a a different name that resolves to the same canonical name
spec_str_4 = "spec str 4"
storage_instance.create_update_spec(user=user,
name=name.upper(),
version=version_2,
spec_str=spec_str_4)
assert (storage_instance.get_spec(user=user, name=name,
version=version_2) == spec_str_4)
def test_delete_spec():
"""
GIVEN user, name, version and spec str
WHEN create_update_spec is called with the user, canonically identical name,
version and spec str and then delete_spec is called with the user and name
THEN the spec str is returned or ObjectNotFoundError is raised.
"""
user = "******"
name = "name 1"
version_1 = "version 1"
spec_str = "spec str 1"
storage_instance = storage.get_storage_facade()
storage_instance.create_update_spec(user=user,
name=name,
version=version_1,
spec_str=spec_str)
storage_instance.delete_spec(user=user, name=name)
with pytest.raises(storage.exceptions.ObjectNotFoundError):
storage_instance.get_spec(user=user, name=name, version=version_1)
# Try again where delete is called with a different name that resolves to the same
# canonical name
storage_instance.create_update_spec(user=user,
name=name,
version=version_1,
spec_str=spec_str)
storage_instance.delete_spec(user=user, name=name.upper())
with pytest.raises(storage.exceptions.ObjectNotFoundError):
storage_instance.get_spec(user=user, name=name, version=version_1)
with pytest.raises(storage.exceptions.StorageError):
storage_instance.delete_spec(user=user, name=name)
version_2 = "version 2"
version_3 = "version 3"
storage_instance.create_update_spec(user=user,
name=name,
version=version_2,
spec_str=spec_str)
storage_instance.create_update_spec(user=user,
name=name,
version=version_3,
spec_str=spec_str)
storage_instance.delete_spec(user=user, name=name)
with pytest.raises(storage.exceptions.ObjectNotFoundError):
storage_instance.get_spec(user=user, name=name, version=version_2)
with pytest.raises(storage.exceptions.ObjectNotFoundError):
storage_instance.get_spec(user=user, name=name, version=version_3)
def test_put_database_update_error(monkeypatch, _clean_specs_table):
"""
GIVEN body and spec id
WHEN put is called with the body and spec id
THEN the spec is stored against the spec id.
"""
mock_request = mock.MagicMock()
mock_headers = {"X-LANGUAGE": "JSON"}
mock_request.headers = mock_headers
monkeypatch.setattr(server.Request, "request", mock_request)
version = "1"
spec = {
"info": {
"version": version
},
"components": {
"schemas": {
"Schema": {
"type": "object",
"x-tablename": "schema",
"properties": {
"id": {
"type": "integer"
}
},
}
}
},
}
body = json.dumps(spec)
spec_name = "id 1"
user = "******"
mock_database_create_update_spec = mock.MagicMock()
mock_database_create_update_spec.side_effect = package_database.exceptions.BaseError
monkeypatch.setattr(
package_database.get(),
"create_update_spec",
mock_database_create_update_spec,
)
response = versions.put(body=body.encode(),
spec_name=spec_name,
version=version,
user=user)
spec_str = storage.get_storage_facade().get_spec(user=user,
name=spec_name,
version=version)
assert f'"{version}"' in spec_str
assert '"Schema"' in spec_str
assert '"x-tablename"' in spec_str
assert '"schema"' in spec_str
assert package_database.get().count_customer_models(sub=user) == 0
assert response.status_code == 500
assert response.mimetype == "text/plain"
assert "database" in response.data.decode()
def test_put(monkeypatch, _clean_specs_table):
"""
GIVEN body, spec id and user
WHEN put is called with the body, spec id and user
THEN the spec is stored against the spec id.
"""
mock_request = mock.MagicMock()
mock_headers = {"X-LANGUAGE": "JSON"}
mock_request.headers = mock_headers
monkeypatch.setattr(server.Request, "request", mock_request)
version = "1"
title = "title 1"
description = "description 1"
spec = {
"info": {"version": version, "title": title, "description": description},
"components": {
"schemas": {
"Schema": {
"type": "object",
"x-tablename": "schema",
"properties": {"id": {"type": "integer"}},
}
}
},
}
body = json.dumps(spec)
spec_name = "id 1"
user = "******"
response = specs.put(body=body.encode(), spec_name=spec_name, user=user)
spec_str = storage.get_storage_facade().get_spec(
user=user, name=spec_name, version=version
)
assert f'"{version}"' in spec_str
assert '"Schema"' in spec_str
assert '"x-tablename"' in spec_str
assert '"schema"' in spec_str
assert package_database.get().count_customer_models(sub=user) == 1
spec_infos = package_database.get().list_specs(sub=user)
assert len(spec_infos) == 1
spec_info = spec_infos[0]
assert spec_info["name"] == spec_name
assert spec_info["id"] == spec_name
assert spec_info["version"] == version
assert spec_info["title"] == title
assert spec_info["description"] == description
assert spec_info["model_count"] == 1
assert "updated_at" in spec_info
assert response.status_code == 204
def test_get_database_miss():
"""
GIVEN user and version and databasewithout and storage with a single spec
WHEN get is called with the user and spec id
THEN 500 is returned.
"""
user = "******"
spec_name = "spec name 1"
version = "1"
spec = {"components": {}}
storage.get_storage_facade().create_update_spec(
user=user,
name=spec_name,
version=version,
spec_str=json.dumps(spec, separators=(",", ":")),
)
response = versions.get(user=user, spec_name=spec_name, version=version)
assert response.status_code == 500
assert response.mimetype == "text/plain"
assert "database" in response.data.decode()
def test_get_spec_versions():
"""
GIVEN user, name, version and spec str
WHEN create_update_spec is called with the user, canonically identical name, version
and spec str and then get_spec_versions is called with the user and name
THEN the version is returned or ObjectNotFoundError is raised.
"""
user = "******"
name = "name 1"
version_1 = "version 1"
spec_str = "spec str 1"
storage_instance = storage.get_storage_facade()
storage_instance.create_update_spec(user=user,
name=name,
version=version_1,
spec_str=spec_str)
assert storage_instance.get_spec_versions(user=user,
name=name) == [version_1]
assert storage_instance.get_spec_versions(
user=user, name=name.upper()) == [version_1]
storage.get_storage().set(key=f"{user}/{name}/{version_1}.gzip",
value="value 1")
assert storage_instance.get_spec_versions(user=user,
name=name) == [version_1]
version_2 = "version 2"
storage_instance.create_update_spec(user=user,
name=name,
version=version_2,
spec_str=spec_str)
assert (storage_instance.get_spec_versions(
user=user,
name=name,
) == [version_1, version_2])
with pytest.raises(storage.exceptions.ObjectNotFoundError) as exc:
storage_instance.get_spec_versions(user="******", name=name)
assert name in str(exc)
with pytest.raises(storage.exceptions.ObjectNotFoundError) as exc:
storage_instance.get_spec_versions(user=user, name="name 2")
assert "name 2" in str(exc)
def test_delete(_clean_specs_table):
"""
GIVEN database and storage with spec and user and spec id
WHEN put is called with the body and spec id
THEN the spec is deleted from the storage and database.
"""
spec_name = "id 1"
user = "******"
version = "1"
package_database.get().create_update_spec(
sub=user, name=spec_name, version=version, model_count=1
)
storage.get_storage_facade().create_update_spec(
user=user, name=spec_name, version=version, spec_str="spec str 1"
)
response = specs.delete(spec_name=spec_name, user=user)
with pytest.raises(storage.exceptions.StorageError):
storage.get_storage_facade().get_spec(
user=user, name=spec_name, version=version
)
assert package_database.get().count_customer_models(sub=user) == 0
assert response.status_code == 204
def test_put_storage_error(monkeypatch, _clean_specs_table):
"""
GIVEN body with invalid spec and spec id
WHEN put is called with the body and spec id
THEN a 400 with an invalid spec is returned.
"""
mock_request = mock.MagicMock()
mock_headers = {"X-LANGUAGE": "JSON"}
mock_request.headers = mock_headers
monkeypatch.setattr(server.Request, "request", mock_request)
version = "1"
schemas = {
"Schema": {
"type": "object",
"x-tablename": "schema",
"properties": {
"id": {
"type": "integer"
}
},
}
}
body = json.dumps({
"info": {
"version": version
},
"components": {
"schemas": schemas
}
})
spec_name = "id 1"
user = "******"
mock_storage_create_update_spec = mock.MagicMock()
mock_storage_create_update_spec.side_effect = storage.exceptions.StorageError
monkeypatch.setattr(
storage.get_storage_facade(),
"create_update_spec",
mock_storage_create_update_spec,
)
response = versions.put(body=body.encode(),
spec_name=spec_name,
version=version,
user=user)
assert response.status_code == 500
assert response.mimetype == "text/plain"
assert "storing" in response.data.decode()
def test_get_storage_facade_error(monkeypatch):
"""
GIVEN user and database with a spec but storage that raises an error
WHEN get is called with the user and spec id
THEN a 500 is returned.
"""
user = "******"
spec_name = "spec name 1"
version = "1"
mock_storage_get_spec = mock.MagicMock()
mock_storage_get_spec.side_effect = storage.exceptions.StorageError
monkeypatch.setattr(storage.get_storage_facade(), "get_spec",
mock_storage_get_spec)
response = versions.get(user=user, spec_name=spec_name, version=version)
assert response.status_code == 500
assert response.mimetype == "text/plain"
assert "reading" in response.data.decode()