def test_multiple_structures_list_returns_struture(self):
# This is to handle the scenario when something is modeled
# as a structure and instead a list of structures is returned.
# For this case, a single element from the list should be parsed
# For ibm_botocore, this will be the first element.
# Currently, this logic may happen in s3's GetBucketLifecycle
# operation.
headers = {}
parser = parsers.RestXMLParser()
body = (
'<?xml version="1.0" ?>'
'<OperationName xmlns="http://s3.amazonaws.com/doc/2006-03-01/">'
' <Foo><Bar>first_value</Bar></Foo>'
' <Foo><Bar>middle_value</Bar></Foo>'
' <Foo><Bar>last_value</Bar></Foo>'
'</OperationName>')
builder = model.DenormalizedStructureBuilder()
output_shape = builder.with_members({
'Foo': {
'type': 'structure',
'members': {
'Bar': {
'type': 'string',
}
}
}
}).build_model()
parsed = parser.parse(
{
'body': body,
'headers': headers,
'status_code': 200
}, output_shape)
# Ensure the first element is used out of the list.
self.assertEqual(parsed['Foo'], {'Bar': 'first_value'})
def test_unknown_shape_type(self):
b = model.DenormalizedStructureBuilder()
with self.assertRaises(model.InvalidShapeError):
b.with_members({
'A': {
'type': 'brand-new-shape-type',
},
}).build_model()
def test_documentation_on_shape_used(self):
b = model.DenormalizedStructureBuilder()
shape = b.with_members({
'A': {
'type': 'string',
'documentation': 'MyDocs',
},
}).build_model()
self.assertEqual(shape.members['A'].documentation, 'MyDocs')
def test_use_shape_name_when_provided(self):
b = model.DenormalizedStructureBuilder()
shape = b.with_members({
'A': {
'type': 'string',
'shape_name': 'MyStringShape',
},
}).build_model()
self.assertEqual(shape.members['A'].name, 'MyStringShape')
def test_structure_shape_with_list(self):
b = model.DenormalizedStructureBuilder()
shape = b.with_members({
'A': {
'type': 'list',
'member': {
'type': 'string'
}
},
}).build_model()
self.assertIsInstance(shape.members['A'], model.ListShape)
self.assertEqual(shape.members['A'].member.type_name, 'string')
def test_min_max_used_in_metadata(self):
b = model.DenormalizedStructureBuilder()
shape = b.with_members({
'A': {
'type': 'string',
'documentation': 'MyDocs',
'min': 2,
'max': 3,
},
}).build_model()
metadata = shape.members['A'].metadata
self.assertEqual(metadata.get('min'), 2)
self.assertEqual(metadata.get('max'), 3)
def test_enum_values_on_string_used(self):
b = model.DenormalizedStructureBuilder()
enum_values = ['foo', 'bar', 'baz']
shape = b.with_members({
'A': {
'type': 'string',
'enum': enum_values,
},
}).build_model()
self.assertIsInstance(shape, model.StructureShape)
string_shape = shape.members['A']
self.assertIsInstance(string_shape, model.StringShape)
self.assertEqual(string_shape.metadata['enum'], enum_values)
self.assertEqual(string_shape.enum, enum_values)
def test_structure_shape_builder_with_scalar_types(self):
b = model.DenormalizedStructureBuilder()
shape = b.with_members({
'A': {
'type': 'string'
},
'B': {
'type': 'integer'
},
}).build_model()
self.assertIsInstance(shape, model.StructureShape)
self.assertEqual(sorted(list(shape.members)), ['A', 'B'])
self.assertEqual(shape.members['A'].type_name, 'string')
self.assertEqual(shape.members['B'].type_name, 'integer')
def test_structure_shape_with_structure_type(self):
b = model.DenormalizedStructureBuilder()
shape = b.with_members({
'A': {
'type': 'structure',
'members': {
'A-1': {
'type': 'string'
},
}
},
}).build_model()
self.assertIsInstance(shape, model.StructureShape)
self.assertEqual(list(shape.members), ['A'])
self.assertEqual(shape.members['A'].type_name, 'structure')
self.assertEqual(list(shape.members['A'].members), ['A-1'])
def test_structure_shape_with_map_type(self):
b = model.DenormalizedStructureBuilder()
shape = b.with_members({
'A': {
'type': 'map',
'key': {
'type': 'string'
},
'value': {
'type': 'string'
},
}
}).build_model()
self.assertIsInstance(shape.members['A'], model.MapShape)
map_shape = shape.members['A']
self.assertEqual(map_shape.key.type_name, 'string')
self.assertEqual(map_shape.value.type_name, 'string')
def test_nested_structure(self):
b = model.DenormalizedStructureBuilder()
shape = b.with_members({
'A': {
'type': 'structure',
'members': {
'B': {
'type': 'structure',
'members': {
'C': {
'type': 'string',
}
}
}
}
}
}).build_model()
self.assertEqual(
shape.members['A'].members['B'].members['C'].type_name, 'string')
def test_ordered_shape_builder(self):
b = model.DenormalizedStructureBuilder()
shape = b.with_members(
OrderedDict([('A', {
'type': 'string'
}),
('B', {
'type':
'structure',
'members':
OrderedDict([('C', {
'type': 'string'
}), ('D', {
'type': 'string'
})])
})])).build_model()
# Members should be in order
self.assertEqual(['A', 'B'], list(shape.members.keys()))
# Nested structure members should *also* stay ordered
self.assertEqual(['C', 'D'], list(shape.members['B'].members.keys()))
