427 lines
14 KiB
Python
427 lines
14 KiB
Python
# Copyright 2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the 'License'). You
|
|
# may not use this file except in compliance with the License. A copy of
|
|
# the License is located at
|
|
#
|
|
# http://aws.amazon.com/apache2.0/
|
|
#
|
|
# or in the 'license' file accompanying this file. This file is
|
|
# distributed on an 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
|
|
# ANY KIND, either express or implied. See the License for the specific
|
|
# language governing permissions and limitations under the License.
|
|
|
|
from botocore.model import DenormalizedStructureBuilder
|
|
|
|
from boto3.resources.model import ResourceModel, Action, Collection, Waiter
|
|
from tests import BaseTestCase
|
|
|
|
|
|
class TestModels(BaseTestCase):
|
|
def test_resource_name(self):
|
|
model = ResourceModel('test', {}, {})
|
|
|
|
self.assertEqual(model.name, 'test')
|
|
|
|
def test_resource_shape(self):
|
|
model = ResourceModel('test', {
|
|
'shape': 'Frob'
|
|
}, {})
|
|
|
|
self.assertEqual(model.shape, 'Frob')
|
|
|
|
def test_resource_identifiers(self):
|
|
model = ResourceModel('test', {
|
|
'identifiers': [
|
|
{'name': 'one'},
|
|
{'name': 'two', 'memberName': 'three'}
|
|
]
|
|
}, {})
|
|
|
|
self.assertEqual(model.identifiers[0].name, 'one')
|
|
self.assertEqual(model.identifiers[1].name, 'two')
|
|
self.assertEqual(model.identifiers[1].member_name, 'three')
|
|
|
|
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_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_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_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_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': {}
|
|
})
|
|
|
|
self.assertIsInstance(model.subresources, list)
|
|
self.assertEqual(len(model.subresources), 2)
|
|
|
|
action = model.subresources[0]
|
|
resource = action.resource
|
|
|
|
self.assertIn(action.name, ['RedFrob', 'GreenFrob'])
|
|
self.assertEqual(resource.identifiers[0].target, 'Id')
|
|
self.assertEqual(resource.identifiers[0].source, 'input')
|
|
self.assertEqual(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_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].resource.path, 'FrobList[]')
|
|
|
|
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')
|
|
|
|
class TestRenaming(BaseTestCase):
|
|
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))
|
|
|
|
# The rest of the tests below ensure the correct order of precedence
|
|
# for the various categories of attributes/properties/methods on the
|
|
# resource 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_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_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_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_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_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_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))
|