def test_action_beats_reference(self):
model = ResourceModel(
'test', {
'actions': {
'Foo': {
'request': {
'operation': 'GetFoo'
}
}
},
'has': {
'Foo': {
'resource': {
'type':
'Frob',
'identifiers': [{
'target': 'Id',
'source': 'data',
'path': 'FrobId'
}]
}
}
}
}, {'Frob': {}})
model.load_rename_map()
assert model.actions[0].name == 'foo'
assert model.references[0].name == 'foo_reference'
def test_reference_beats_collection(self):
model = ResourceModel('test', {
'has': {
'Foo': {
'resource': {
'type': 'Frob',
'identifiers': [
{'target':'Id', 'source':'data',
'path': 'FrobId'}
]
}
}
},
'hasMany': {
'Foo': {
'resource': {
'type': 'Frob'
}
}
}
}, {'Frob': {}})
model.load_rename_map()
self.assertEqual(model.references[0].name, 'foo')
self.assertEqual(model.collections[0].name, 'foo_collection')
def test_reference_beats_collection(self):
model = ResourceModel(
'test', {
'has': {
'Foo': {
'resource': {
'type':
'Frob',
'identifiers': [{
'target': 'Id',
'source': 'data',
'path': 'FrobId'
}]
}
}
},
'hasMany': {
'Foo': {
'resource': {
'type': 'Frob'
}
}
}
}, {'Frob': {}})
model.load_rename_map()
assert model.references[0].name == 'foo'
assert model.collections[0].name == 'foo_collection'
def test_action_beats_reference(self):
model = ResourceModel('test', {
'actions': {
'Foo': {
'request': {
'operation': 'GetFoo'
}
}
},
'has': {
'Foo': {
'resource': {
'type': 'Frob',
'identifiers': [
{'target':'Id', 'source':'data',
'path': 'FrobId'}
]
}
}
}
}, {'Frob': {}})
model.load_rename_map()
self.assertEqual(model.actions[0].name, 'foo')
self.assertEqual(model.references[0].name, 'foo_reference')
def test_all_collections_have_paginators_if_needed():
# If a collection relies on an operation that is paginated, it
# will require a paginator to iterate through all of the resources
# with the all() method. If there is no paginator, it will only
# make it through the first page of results. So we need to make sure
# if a collection looks like it uses a paginated operation then there
# should be a paginator applied to it.
botocore_session = botocore.session.get_session()
session = Session(botocore_session=botocore_session)
loader = botocore_session.get_component('data_loader')
for service_name in session.get_available_resources():
client = session.client(service_name, region_name='us-east-1')
json_resource_model = loader.load_service_model(
service_name, 'resources-1')
resource_defs = json_resource_model['resources']
resource_models = []
# Get the service resource model
service_resource_model = ResourceModel(service_name,
json_resource_model['service'],
resource_defs)
resource_models.append(service_resource_model)
# Generate all of the resource models for a service
for resource_name, resource_defintion in resource_defs.items():
resource_models.append(
ResourceModel(resource_name, resource_defintion,
resource_defs))
for resource_model in resource_models:
# Iterate over all of the collections for each resource model
# and ensure that the collection has a paginator if it needs one.
for collection_model in resource_model.collections:
yield (_assert_collection_has_paginator_if_needed, client,
service_name, resource_name, collection_model)
def _collection_test_args():
botocore_session = botocore.session.get_session()
session = Session(botocore_session=botocore_session)
loader = botocore_session.get_component('data_loader')
for service_name in session.get_available_resources():
client = session.client(service_name, region_name='us-east-1')
json_resource_model = loader.load_service_model(
service_name, 'resources-1')
resource_defs = json_resource_model['resources']
resource_models = []
# Get the service resource model
service_resource_model = ResourceModel(service_name,
json_resource_model['service'],
resource_defs)
resource_models.append(service_resource_model)
# Generate all of the resource models for a service
for resource_name, resource_defintion in resource_defs.items():
resource_models.append(
ResourceModel(resource_name, resource_defintion,
resource_defs))
for resource_model in resource_models:
# Iterate over all of the collections for each resource model
# and ensure that the collection has a paginator if it needs one.
for collection_model in resource_model.collections:
yield (client, service_name, resource_name, collection_model)
def test_meta_beats_identifier(self):
model = ResourceModel('test', {
'identifiers': [{'name': 'Meta'}]
}, {})
model.load_rename_map()
self.assertEqual(model.identifiers[0].name, 'meta_identifier')
def test_waiter_beats_attribute(self):
model = ResourceModel('test', {'waiters': {'Foo': {}}}, {'Frob': {}})
shape = DenormalizedStructureBuilder().with_members({
'WaitUntilFoo': {
'type': 'string',
}
}).build_model()
model.load_rename_map(shape)
assert model.waiters[0].name == 'wait_until_foo'
assert 'wait_until_foo_attribute' in model.get_attributes(shape)
def test_multiple(self):
# This tests a bunch of different renames working together
model = ResourceModel('test', {
'identifiers': [{'name': 'Foo'}],
'actions': {
'Foo': {}
},
'has': {
'Foo': {
'resource': {
'type': 'Frob',
'identifiers': [
{'target':'Id', 'source':'data',
'path': 'FrobId'}
]
}
}
},
'hasMany': {
'Foo': {}
},
'waiters': {
'Foo': {}
}
}, {
'Frob': {}
})
shape = DenormalizedStructureBuilder().with_members({
'Foo': {
'type': 'string',
},
'Bar': {
'type': 'string'
}
}).build_model()
model.load_rename_map(shape)
self.assertEqual(model.identifiers[0].name, 'foo')
self.assertEqual(model.actions[0].name, 'foo_action')
self.assertEqual(model.references[0].name, 'foo_reference')
self.assertEqual(model.collections[0].name, 'foo_collection')
self.assertEqual(model.waiters[0].name, 'wait_until_foo')
# If an identifier and an attribute share the same name, then
# the attribute is essentially hidden.
self.assertNotIn('foo_attribute', model.get_attributes(shape))
# Other attributes need to be there, though
self.assertIn('bar', model.get_attributes(shape))
def test_load_beats_identifier(self):
model = ResourceModel('test', {
'identifiers': [{'name': 'Load'}],
'load': {
'request': {
'operation': 'GetFrobs'
}
}
}, {})
model.load_rename_map()
self.assertTrue(model.load)
self.assertEqual(model.identifiers[0].name, 'load_identifier')
def test_load_beats_identifier(self):
model = ResourceModel(
'test',
{
'identifiers': [{'name': 'Load'}],
'load': {'request': {'operation': 'GetFrobs'}},
},
{},
)
model.load_rename_map()
assert model.load
assert model.identifiers[0].name == 'load_identifier'
def test_identifier_beats_action(self):
model = ResourceModel(
'test',
{
'identifiers': [{'name': 'foo'}],
'actions': {'Foo': {'request': {'operation': 'GetFoo'}}},
},
{},
)
model.load_rename_map()
assert model.identifiers[0].name == 'foo'
assert model.actions[0].name == 'foo_action'
def test_collection_beats_waiter(self):
model = ResourceModel(
'test',
{
'hasMany': {'WaitUntilFoo': {'resource': {'type': 'Frob'}}},
'waiters': {'Foo': {}},
},
{'Frob': {}},
)
model.load_rename_map()
assert model.collections[0].name == 'wait_until_foo'
assert model.waiters[0].name == 'wait_until_foo_waiter'
def test_resource_references(self):
model_def = {
'has': {
'Frob': {
'resource': {
'type':
'Frob',
'identifiers': [{
'target': 'Id',
'source': 'data',
'path': 'FrobId'
}]
}
}
}
}
resource_defs = {'Frob': {}}
model = ResourceModel('test', model_def, resource_defs)
assert isinstance(model.references, list)
assert len(model.references) == 1
ref = model.references[0]
assert ref.name == 'frob'
assert ref.resource.type == 'Frob'
assert ref.resource.identifiers[0].target == 'Id'
assert ref.resource.identifiers[0].source == 'data'
assert ref.resource.identifiers[0].path == 'FrobId'
def test_resource_action_raw(self):
model = ResourceModel(
'test', {
'actions': {
'GetFrobs': {
'request': {
'operation':
'GetFrobsOperation',
'params': [{
'target': 'FrobId',
'source': 'identifier',
'name': 'Id'
}]
},
'path': 'Container.Frobs[]'
}
}
}, {})
self.assertIsInstance(model.actions, list)
self.assertEqual(len(model.actions), 1)
action = model.actions[0]
self.assertIsInstance(action, Action)
self.assertEqual(action.request.operation, 'GetFrobsOperation')
self.assertIsInstance(action.request.params, list)
self.assertEqual(len(action.request.params), 1)
self.assertEqual(action.request.params[0].target, 'FrobId')
self.assertEqual(action.request.params[0].source, 'identifier')
self.assertEqual(action.request.params[0].name, 'Id')
self.assertEqual(action.path, 'Container.Frobs[]')
def test_identifier_beats_action(self):
model = ResourceModel('test', {
'identifiers': [{'name': 'foo'}],
'actions': {
'Foo': {
'request': {
'operation': 'GetFoo'
}
}
}
}, {})
model.load_rename_map()
self.assertEqual(model.identifiers[0].name, 'foo')
self.assertEqual(model.actions[0].name, 'foo_action')
def test_resource_batch_action(self):
model = ResourceModel(
'test',
{
'batchActions': {
'Delete': {
'request': {
'operation': 'DeleteObjects',
'params': [
{
'target': 'Bucket',
'sourceType': 'identifier',
'source': 'BucketName',
}
],
}
}
}
},
{},
)
assert isinstance(model.batch_actions, list)
action = model.batch_actions[0]
assert isinstance(action, Action)
assert action.request.operation == 'DeleteObjects'
assert action.request.params[0].target == 'Bucket'
def test_sub_resources(self):
model = ResourceModel(
'test', {
'has': {
'Frob': {
'resource': {
'type': 'Frob',
'identifiers': [{
'target': 'Id',
'source': 'input'
}]
}
}
}
}, {'Frob': {}})
self.assertIsInstance(model.subresources, list)
action = model.subresources[0]
resource = action.resource
self.assertEqual(action.name, 'Frob')
self.assertEqual(resource.identifiers[0].target, 'Id')
self.assertEqual(resource.identifiers[0].source, 'input')
self.assertEqual(resource.type, 'Frob')
def test_waiter(self):
model = ResourceModel(
'test',
{
'waiters': {
'Exists': {
'waiterName': 'ObjectExists',
'params': [
{
'target': 'Bucket',
'sourceType': 'identifier',
'source': 'BucketName',
}
],
}
}
},
{},
)
assert isinstance(model.waiters, list)
waiter = model.waiters[0]
assert isinstance(waiter, Waiter)
assert waiter.name == 'wait_until_exists'
assert waiter.waiter_name == 'ObjectExists'
assert waiter.params[0].target == 'Bucket'
def test_resource_action_raw(self):
model = ResourceModel(
'test', {
'actions': {
'GetFrobs': {
'request': {
'operation':
'GetFrobsOperation',
'params': [{
'target': 'FrobId',
'source': 'identifier',
'name': 'Id'
}]
},
'path': 'Container.Frobs[]'
}
}
}, {})
assert isinstance(model.actions, list)
assert len(model.actions) == 1
action = model.actions[0]
assert isinstance(action, Action)
assert action.request.operation == 'GetFrobsOperation'
assert isinstance(action.request.params, list)
assert len(action.request.params) == 1
assert action.request.params[0].target == 'FrobId'
assert action.request.params[0].source == 'identifier'
assert action.request.params[0].name == 'Id'
assert action.path == 'Container.Frobs[]'
def test_sub_resources(self):
model = ResourceModel(
'test', {
'has': {
'RedFrob': {
'resource': {
'type': 'Frob',
'identifiers': [{
'target': 'Id',
'source': 'input'
}]
}
},
'GreenFrob': {
'resource': {
'type': 'Frob',
'identifiers': [{
'target': 'Id',
'source': 'input'
}]
}
}
}
}, {'Frob': {}})
assert isinstance(model.subresources, list)
assert len(model.subresources) == 2
action = model.subresources[0]
resource = action.resource
assert action.name in ['RedFrob', 'GreenFrob']
assert resource.identifiers[0].target == 'Id'
assert resource.identifiers[0].source == 'input'
assert resource.type == 'Frob'
def test_resource_references(self):
model_def = {
'has': {
'Frob': {
'resource': {
'type':
'Frob',
'identifiers': [{
'target': 'Id',
'source': 'data',
'path': 'FrobId'
}]
}
}
}
}
resource_defs = {'Frob': {}}
model = ResourceModel('test', model_def, resource_defs)
self.assertIsInstance(model.references, list)
self.assertEqual(len(model.references), 1)
ref = model.references[0]
self.assertEqual(ref.name, 'Frob')
self.assertEqual(ref.resource.type, 'Frob')
self.assertEqual(ref.resource.identifiers[0].target, 'Id')
self.assertEqual(ref.resource.identifiers[0].source, 'data')
self.assertEqual(ref.resource.identifiers[0].path, 'FrobId')
def test_waiter_beats_attribute(self):
model = ResourceModel('test', {
'waiters': {
'Foo': {}
}
}, {'Frob': {}})
shape = DenormalizedStructureBuilder().with_members({
'WaitUntilFoo': {
'type': 'string',
}
}).build_model()
model.load_rename_map(shape)
self.assertEqual(model.waiters[0].name, 'wait_until_foo')
self.assertIn('wait_until_foo_attribute', model.get_attributes(shape))
def test_collection_beats_waiter(self):
model = ResourceModel('test', {
'hasMany': {
'WaitUntilFoo': {
'resource': {
'type': 'Frob'
}
}
},
'waiters': {
'Foo': {}
}
}, {'Frob': {}})
model.load_rename_map()
self.assertEqual(model.collections[0].name, 'wait_until_foo')
self.assertEqual(model.waiters[0].name, 'wait_until_foo_waiter')
def test_resource_identifiers(self):
model = ResourceModel(
'test', {'identifiers': [{
'name': 'one'
}, {
'name': 'two'
}]}, {})
self.assertEqual(model.identifiers[0].name, 'one')
self.assertEqual(model.identifiers[1].name, 'two')
def setUpClass(cls):
ec2_service_model = boto3.session.Session()._loader.load_service_model("ec2", "resources-1", "2016-11-15")
s3_service_model = boto3.session.Session()._loader.load_service_model("s3", "resources-1", "2006-03-01")
iam_service_model = boto3.session.Session()._loader.load_service_model("iam", "resources-1", "2010-05-08")
cls.vpc_resource_model = ResourceModel(
name="Vpc",
definition=ec2_service_model["resources"]["Vpc"],
resource_defs=ec2_service_model["resources"],
)
cls.bucket_resource_model = ResourceModel(
name="Bucket",
definition=s3_service_model["resources"]["Bucket"],
resource_defs=s3_service_model["resources"],
)
cls.role_resource_model = ResourceModel(
name="Role",
definition=iam_service_model["resources"]["Role"],
resource_defs=iam_service_model["resources"],
)
def test_resource_load_action(self):
model = ResourceModel(
'test',
{'load': {'request': {'operation': 'GetFrobInfo'}, 'path': '$'}},
{},
)
assert isinstance(model.load, Action)
assert model.load.request.operation == 'GetFrobInfo'
assert model.load.path == '$'
def test_resource_load_action(self):
model = ResourceModel(
'test',
{'load': {
'request': {
'operation': 'GetFrobInfo'
},
'path': '$'
}}, {})
self.assertIsInstance(model.load, Action)
self.assertEqual(model.load.request.operation, 'GetFrobInfo')
self.assertEqual(model.load.path, '$')
def test_resource_identifiers(self):
model = ResourceModel(
'test', {
'identifiers': [{
'name': 'one'
}, {
'name': 'two',
'memberName': 'three'
}]
}, {})
assert model.identifiers[0].name == 'one'
assert model.identifiers[1].name == 'two'
assert model.identifiers[1].member_name == 'three'
def test_multiple(self):
# This tests a bunch of different renames working together
model = ResourceModel(
'test', {
'identifiers': [{
'name': 'Foo'
}],
'actions': {
'Foo': {}
},
'has': {
'Foo': {
'resource': {
'type':
'Frob',
'identifiers': [{
'target': 'Id',
'source': 'data',
'path': 'FrobId'
}]
}
}
},
'hasMany': {
'Foo': {}
},
'waiters': {
'Foo': {}
}
}, {'Frob': {}})
shape = DenormalizedStructureBuilder().with_members({
'Foo': {
'type': 'string',
},
'Bar': {
'type': 'string'
}
}).build_model()
model.load_rename_map(shape)
assert model.identifiers[0].name == 'foo'
assert model.actions[0].name == 'foo_action'
assert model.references[0].name == 'foo_reference'
assert model.collections[0].name == 'foo_collection'
assert model.waiters[0].name == 'wait_until_foo'
# If an identifier and an attribute share the same name, then
# the attribute is essentially hidden.
assert 'foo_attribute' not in model.get_attributes(shape)
# Other attributes need to be there, though
assert 'bar' in model.get_attributes(shape)
def test_resource_action_response_resource(self):
model = ResourceModel(
'test', {
'actions': {
'GetFrobs': {
'resource': {
'type': 'Frob',
'path': 'Container.Frobs[]'
}
}
}
}, {'Frob': {}})
action = model.actions[0]
self.assertEqual(action.resource.type, 'Frob')
self.assertEqual(action.resource.path, 'Container.Frobs[]')
self.assertIsInstance(action.resource.model, ResourceModel)
self.assertEqual(action.resource.model.name, 'Frob')
def test_resource_action_response_resource(self):
model = ResourceModel(
'test', {
'actions': {
'GetFrobs': {
'resource': {
'type': 'Frob',
'path': 'Container.Frobs[]'
}
}
}
}, {'Frob': {}})
action = model.actions[0]
assert action.resource.type == 'Frob'
assert action.resource.path == 'Container.Frobs[]'
assert isinstance(action.resource.model, ResourceModel)
assert action.resource.model.name == 'Frob'
def test_waiter(self):
model = ResourceModel('test', {
'waiters': {
'Exists': {
'waiterName': 'ObjectExists',
'params': [
{'target': 'Bucket', 'sourceType': 'identifier',
'source': 'BucketName'}
]
}
}
}, {})
self.assertIsInstance(model.waiters, list)
waiter = model.waiters[0]
self.assertIsInstance(waiter, Waiter)
self.assertEqual(waiter.name, 'wait_until_exists')
self.assertEqual(waiter.waiter_name, 'ObjectExists')
self.assertEqual(waiter.params[0].target, 'Bucket')
def test_resource_batch_action(self):
model = ResourceModel('test', {
'batchActions': {
'Delete': {
'request': {
'operation': 'DeleteObjects',
'params': [
{'target': 'Bucket', 'sourceType': 'identifier',
'source': 'BucketName'}
]
}
}
}
}, {})
self.assertIsInstance(model.batch_actions, list)
action = model.batch_actions[0]
self.assertIsInstance(action, Action)
self.assertEqual(action.request.operation, 'DeleteObjects')
self.assertEqual(action.request.params[0].target, 'Bucket')
def test_resource_collections(self):
model = ResourceModel(
'test',
{
'hasMany': {
'Frobs': {
'request': {'operation': 'GetFrobList'},
'resource': {'type': 'Frob', 'path': 'FrobList[]'},
}
}
},
{'Frob': {}},
)
assert isinstance(model.collections, list)
assert len(model.collections) == 1
assert isinstance(model.collections[0], Collection)
assert model.collections[0].request.operation == 'GetFrobList'
assert model.collections[0].resource.type == 'Frob'
assert model.collections[0].resource.model.name == 'Frob'
assert model.collections[0].resource.path == 'FrobList[]'
def test_resource_collections(self):
model = ResourceModel(
'test', {
'hasMany': {
'Frobs': {
'request': {
'operation': 'GetFrobList'
},
'resource': {
'type': 'Frob'
},
'path': 'FrobList[]'
}
}
}, {'Frob': {}})
self.assertIsInstance(model.collections, list)
self.assertEqual(len(model.collections), 1)
self.assertIsInstance(model.collections[0], Collection)
self.assertEqual(model.collections[0].request.operation, 'GetFrobList')
self.assertEqual(model.collections[0].resource.type, 'Frob')
self.assertEqual(model.collections[0].resource.model.name, 'Frob')
self.assertEqual(model.collections[0].path, 'FrobList[]')
