Expose all resources on a service resource.

boto3/resources/factory.py

@@ -188,7 +188,7 @@ def _load_has_relations(self, attrs, service_name, resource_name,
             # This is a sub-resource class you can create
             # by passing in an identifier, e.g. s3.Bucket(name).
             name = subresource.resource.type
-            attrs[name] = self._create_class_partial(
+            attrs[subresource.name] = self._create_class_partial(
                 name, subresource, service_name, resource_name, model,
                 resource_defs, service_model)
 

boto3/resources/model.py

@@ -312,6 +312,66 @@ def batch_actions(self):
 
         return actions
 
+    def _get_has_definition(self):
+        """
+        Get a ``has`` relationship definition from a model, where the
+        service resource model is treated special in that it contains
+        a relationship to every resource defined for the service. This
+        allows things like ``s3.Object('bucket-name', 'key')`` to
+        work even though the JSON doesn't define it explicitly.
+
+        @rtype: dict
+        @return: Mapping of names to subresource and reference
+                 definitions.
+        """
+        if self.name not in self._resource_defs:
+            # This is the service resource, so let us expose all of
+            # the defined resources as subresources.
+            definition = {}
+
+            for name, resource_def in self._resource_defs.items():
+                # It's possible for the service to have renamed a
+                # resource, so we need to take that into account and
+                # search for the same resource type.
+                has_items = self._definition.get('has', {}).items()
+                for has_name, has_def in has_items:
+                    if has_def.get('resource', {}).get('type') == name:
+                        definition[has_name] = has_def
+                        break
+                else:
+                    # Create a relationship definition and attach it
+                    # to the model, such that all identifiers must be
+                    # supplied by the user. It will look something like:
+                    #
+                    # {
+                    #   'resource': {
+                    #     'type': 'ResourceName',
+                    #     'identifiers': [
+                    #       {'target': 'Name1', 'source': 'input'},
+                    #       {'target': 'Name2', 'source': 'input'},
+                    #       ...
+                    #     ]
+                    #   }
+                    # }
+                    #
+                    fake_has = {
+                        'resource': {
+                            'type': name,
+                            'identifiers': []
+                        }
+                    }
+
+                    for identifier in resource_def.get('identifiers', []):
+                        fake_has['resource']['identifiers'].append({
+                            'target': identifier['name'], 'source': 'input'
+                        })
+
+                    definition[name] = fake_has
+        else:
+            definition = self._definition.get('has', {})
+
+        return definition
+
     def _get_related_resources(self, subresources):
         """
         Get a list of sub-resources or references.
@@ -323,7 +383,7 @@ def _get_related_resources(self, subresources):
         """
         resources = []
 
-        for name, definition in self._definition.get('has', {}).items():
+        for name, definition in self._get_has_definition().items():
             action = Action(name, definition, self._resource_defs)
 
             data_required = False

tests/unit/resources/test_factory.py

@@ -670,3 +670,54 @@ def test_dangling_resource_inequality(self):
 
         self.assertNotEqual(q1, q2)
         self.assertNotEqual(q1, m)
+
+
+class TestServiceResourceSubresources(TestResourceFactory):
+    def setUp(self):
+        super(TestServiceResourceSubresources, self).setUp()
+
+        self.model = {
+            'has': {
+                'QueueObject': {
+                    'resource': {
+                        'type': 'Queue',
+                        'identifiers': [
+                            {'target': 'Url', 'source': 'input'}
+                        ]
+                    }
+                }
+            }
+        }
+
+        self.defs = {
+            'Queue': {
+                'identifiers': [
+                    {'name': 'Url'}
+                ]
+            },
+            'Message': {
+                'identifiers': [
+                    {'name': 'QueueUrl'},
+                    {'name': 'ReceiptHandle'}
+                ]
+            }
+        }
+
+    def test_subresource_custom_name(self):
+        resource = self.load('test', 'test', self.model, self.defs, None)()
+
+        self.assertTrue(hasattr(resource, 'QueueObject'))
+
+    def test_contains_all_subresources(self):
+        resource = self.load('test', 'test', self.model, self.defs, None)()
+
+        self.assertIn('QueueObject', dir(resource))
+        self.assertIn('Message', dir(resource))
+
+    def test_subresource_missing_all_subresources(self):
+        resource = self.load('test', 'test', self.model, self.defs, None)()
+        message = resource.Message('url', 'handle')
+
+        self.assertNotIn('QueueObject', dir(message))
+        self.assertNotIn('Queue', dir(message))
+        self.assertNotIn('Message', dir(message))