Merge ~cjwatson/launchpadlib:fakelaunchpad-better-resource-creation into launchpadlib:main

[Colin Watson]

Allow sample data with links to other entries/collections

`FakeLaunchpad` allowed setting sample data with plain attributes of entries, but it wasn't quite smart enough to support sample entries that link to other entries or collections, which is often necessary when testing `launchpadlib` clients in practice. It can handle this now.

I had to do a bit of flailing around with `wadllib` to figure out how all this works, but I've been able to use this for real testing of an `lpcraft` branch with some moderately complex structure in its sample data, so I'm reasonably sure I've got it right.

[Jürgen Gmach (jugmac00)]

review: Approve

diff --git a/NEWS.rst b/NEWS.rst
index b3475eb..29fc779 100644
--- a/NEWS.rst
+++ b/NEWS.rst
@@ -7,6 +7,8 @@ NEWS for launchpadlib
 - Move the ``keyring`` dependency to a new ``keyring`` extra.
 - Support setting fake methods that return None on instances of
   ``launchpadlib.testing.launchpad.FakeLaunchpad``.
+- Allow setting ``FakeLaunchpad`` sample data with attributes that are links
+  to other entries or collections.
 
 1.10.18 (2022-10-28)
 ====================
diff --git a/src/launchpadlib/testing/launchpad.py b/src/launchpadlib/testing/launchpad.py
index a079da1..3b68798 100644
--- a/src/launchpadlib/testing/launchpad.py
+++ b/src/launchpadlib/testing/launchpad.py
@@ -76,8 +76,6 @@ import sys
 if sys.version_info[0] >= 3:
     basestring = str
 
-JSON_MEDIA_TYPE = "application/json"
-
 
 class IntegrityError(Exception):
     """Raised when bad sample data is used with a L{FakeLaunchpad} instance."""
@@ -185,6 +183,11 @@ def strip_suffix(string, suffix):
     return string
 
 
+def wadl_tag(tag_name):
+    """Scope a tag name with the WADL namespace."""
+    return "{http://research.sun.com/wadl/2006/10}" + tag_name
+
+
 class FakeResource(object):
     """
     Represents valid sample data on L{FakeLaunchpad} instances.
@@ -283,16 +286,17 @@ class FakeResource(object):
             this resource or if C{values} isn't a valid object for the C{name}
             attribute.
         """
-        root_resource = self._application.get_resource_by_path("")
+        xml_id = self._find_representation_id(self._resource_type, "get")
+        representation = self._application.representation_definitions[xml_id]
+        params = {
+            child.name: child
+            for child in representation.params(representation)
+        }
         is_link = False
-        param = root_resource.get_parameter(
-            name + "_collection_link", JSON_MEDIA_TYPE
-        )
+        param = params.get(name + "_collection_link")
         if param is None:
             is_link = True
-            param = root_resource.get_parameter(
-                name + "_link", JSON_MEDIA_TYPE
-            )
+            param = params.get(name + "_link")
         if param is None:
             raise IntegrityError("%s isn't a valid property." % (name,))
         resource_type = self._get_resource_type(param)
@@ -319,7 +323,7 @@ class FakeResource(object):
         @return: The resource type for the parameter, or None if one isn't
             available.
         """
-        [link] = list(param.tag)
+        link = param.tag.find(wadl_tag("link"))
         name = link.get("resource_type")
         return self._application.get_resource_type(name)
 
@@ -411,21 +415,34 @@ class FakeResource(object):
             name or if C{value}'s type is not valid for the attribute.
         """
         representation = self._application.representation_definitions[xml_id]
-        parameters = {child.get("name"): child for child in representation.tag}
-        if name not in parameters:
-            raise IntegrityError("%s not found" % name)
-        parameter = parameters[name]
-        data_type = parameter.get("type")
-        if data_type is None:
-            if not isinstance(value, basestring):
-                raise IntegrityError(
-                    "%s is not a str or unicode for %s" % (value, name)
-                )
-        elif data_type == "xsd:dateTime":
-            if not isinstance(value, datetime):
-                raise IntegrityError(
-                    "%s is not a datetime for %s" % (value, name)
-                )
+        params = {
+            child.name: child
+            for child in representation.params(representation)
+        }
+        if name + "_collection_link" in params:
+            resource_type = self._get_resource_type(
+                params[name + "_collection_link"]
+            )
+            child_name, child_resource_type = self._check_collection_type(
+                resource_type, value
+            )
+        elif name + "_link" in params:
+            resource_type = self._get_resource_type(params[name + "_link"])
+            self._check_resource_type(resource_type, value)
+        else:
+            param = params.get(name)
+            if param is None:
+                raise IntegrityError("%s not found" % name)
+            if param.type is None:
+                if not isinstance(value, basestring):
+                    raise IntegrityError(
+                        "%s is not a str or unicode for %s" % (value, name)
+                    )
+            elif param.type == "xsd:dateTime":
+                if not isinstance(value, datetime):
+                    raise IntegrityError(
+                        "%s is not a datetime for %s" % (value, name)
+                    )
 
     def _get_method(self, resource_type, name):
         """Get the C{name} method on C{resource_type}.
@@ -486,9 +503,23 @@ class FakeResource(object):
         if xml_id not in self._application.resource_types:
             xml_id += "-resource"
         result_resource_type = self._application.resource_types[xml_id]
-        self._check_resource_type(result_resource_type, result)
-        # XXX: Should this wrap in collection?
-        return FakeResource(self._application, result_resource_type, result)
+        if xml_id.endswith("-page-resource"):
+            name, child_resource_type = self._check_collection_type(
+                result_resource_type, result
+            )
+            return FakeCollection(
+                self._application,
+                result_resource_type,
+                result,
+                name,
+                child_resource_type,
+            )
+        else:
+            self._check_resource_type(result_resource_type, result)
+            resource = FakeEntry(self._application, result_resource_type)
+            for child_name, child_value in result.items():
+                setattr(resource, child_name, child_value)
+            return resource
 
     def _get_child_resource_type(self, resource_type):
         """Get the name and resource type for the entries in a collection.
diff --git a/src/launchpadlib/testing/testing-wadl.xml b/src/launchpadlib/testing/testing-wadl.xml
index cc33f88..650711d 100644
--- a/src/launchpadlib/testing/testing-wadl.xml
+++ b/src/launchpadlib/testing/testing-wadl.xml
@@ -187,6 +187,10 @@
     <wadl:param style="plain" required="true"
                 path="$['name']" name="name">
     </wadl:param>
+    <wadl:param style="plain" required="true" name="linked_bugs_collection_link" path="$['linked_bugs_collection_link']">
+      <wadl:doc xmlns="http://www.w3.org/1999/xhtml">The bugs linked to this branch.</wadl:doc>
+      <wadl:link resource_type="https://api.example.com/testing/#bug-page-resource"/>
+    </wadl:param>
   </wadl:representation>
 
   <wadl:resource_type id="branches">
@@ -341,6 +345,10 @@
     <wadl:param style="plain" required="true"
                 path="$['title']" name="title">
     </wadl:param>
+    <wadl:param style="plain" required="true" name="owner_link" path="$['owner_link']">
+      <wadl:doc xmlns="http://www.w3.org/1999/xhtml">The owner's IPerson</wadl:doc>
+      <wadl:link resource_type="https://api.example.com/testing/#person"/>
+    </wadl:param>
   </wadl:representation>
 
 </wadl:application>
diff --git a/src/launchpadlib/testing/tests/test_launchpad.py b/src/launchpadlib/testing/tests/test_launchpad.py
index 956fc06..cad2f10 100644
--- a/src/launchpadlib/testing/tests/test_launchpad.py
+++ b/src/launchpadlib/testing/tests/test_launchpad.py
@@ -42,14 +42,23 @@ class FakeResourceTest(ResourcedTestCase):
 
     resources = [("launchpad", FakeLaunchpadResource())]
 
-    def test_repr(self):
-        """A custom C{__repr__} is provided for L{FakeResource}s."""
+    def test_repr_entry(self):
+        """A custom C{__repr__} is provided for L{FakeEntry}s."""
+        bug = dict()
+        self.launchpad.bugs = dict(entries=[bug])
+        [bug] = list(self.launchpad.bugs)
+        self.assertEqual(
+            "<FakeEntry bug object at %s>" % hex(id(bug)), repr(bug)
+        )
+
+    def test_repr_collection(self):
+        """A custom C{__repr__} is provided for L{FakeCollection}s."""
         branches = dict(total_size="test-branch")
         self.launchpad.me = dict(getBranches=lambda statuses: branches)
         branches = self.launchpad.me.getBranches([])
         obj_id = hex(id(branches))
         self.assertEqual(
-            "<FakeResource branch-page-resource object at %s>" % obj_id,
+            "<FakeCollection branch-page-resource object at %s>" % obj_id,
             repr(branches),
         )
 
@@ -72,9 +81,7 @@ class FakeResourceTest(ResourcedTestCase):
         bug = dict(id="1", title="Bug #1")
         self.launchpad.bugs = dict(entries=[bug])
         [bug] = list(self.launchpad.bugs)
-        self.assertEqual(
-            "<FakeResource bug 1 at %s>" % hex(id(bug)), repr(bug)
-        )
+        self.assertEqual("<FakeEntry bug 1 at %s>" % hex(id(bug)), repr(bug))
 
 
 class FakeLaunchpadTest(ResourcedTestCase):
@@ -254,16 +261,52 @@ class FakeLaunchpadTest(ResourcedTestCase):
         self.launchpad.branches = dict(getByUniqueName=lambda name: None)
         self.assertIsNone(self.launchpad.branches.getByUniqueName("foo"))
 
-    def test_collection_property(self):
+    def test_entry_property(self):
+        """
+        Attributes that represent links to other objects are set using a
+        dict representing the object.
+        """
+        bug = dict(owner=dict(name="test-person"))
+        self.launchpad.bugs = dict(entries=[bug])
+        bug = self.launchpad.bugs[0]
+        self.assertEqual("test-person", bug.owner.name)
+
+    def test_invalid_entry_property(self):
+        """
+        Sample data for linked entries is validated.
+        """
+        bug = dict(owner=dict(foo="bar"))
+        self.assertRaises(
+            IntegrityError,
+            setattr,
+            self.launchpad,
+            "bugs",
+            dict(entries=[bug]),
+        )
+
+    def test_top_level_collection_property(self):
         """
-        Sample collections can be set on L{FakeLaunchpad} instances.  They are
-        validated the same way other sample data is validated.
+        Sample top-level collections can be set on L{FakeLaunchpad}
+        instances.  They are validated the same way other sample data is
+        validated.
         """
         branch = dict(name="foo")
         self.launchpad.branches = dict(getByUniqueName=lambda name: branch)
         branch = self.launchpad.branches.getByUniqueName("foo")
         self.assertEqual("foo", branch.name)
 
+    def test_collection_property(self):
+        """
+        Attributes that represent links to collections of other objects are
+        set using a dict representing the collection.
+        """
+        bug = dict(id="1")
+        branch = dict(linked_bugs=dict(entries=[bug]))
+        self.launchpad.branches = dict(getByUniqueName=lambda name: branch)
+        branch = self.launchpad.branches.getByUniqueName("foo")
+        [bug] = list(branch.linked_bugs)
+        self.assertEqual("1", bug.id)
+
     def test_iterate_collection(self):
         """
         Data for a sample collection set on a L{FakeLaunchpad} instance can be
@@ -277,7 +320,7 @@ class FakeLaunchpadTest(ResourcedTestCase):
         self.assertEqual("1", bug.id)
         self.assertEqual("Bug #1", bug.title)
 
-    def test_collection_with_invalid_entries(self):
+    def test_top_level_collection_with_invalid_entries(self):
         """
         Sample data for each entry in a collection is validated when it's set
         on a L{FakeLaunchpad} instance.
@@ -291,6 +334,20 @@ class FakeLaunchpadTest(ResourcedTestCase):
             dict(entries=[bug]),
         )
 
+    def test_collection_with_invalid_entries(self):
+        """
+        Sample data for each entry in a collection is validated when it's set
+        on an attribute representing a link to a collection of objects.
+        """
+        bug = dict(foo="bar")
+        branch = dict(linked_bugs=dict(entries=[bug]))
+        self.launchpad.branches = dict(getByUniqueName=lambda name: branch)
+        self.assertRaises(
+            IntegrityError,
+            self.launchpad.branches.getByUniqueName,
+            "foo",
+        )
+
     def test_slice_collection(self):
         """
         Data for a sample collection set on a L{FakeLaunchpad} instance can be