Merge lp:~james-w/launchpad-work-items-tracker/more-launchpad into lp:~linaro-automation/launchpad-work-items-tracker/linaro

[James Westby]

Hi,

This branch improves the mock launchpadlib that we use for testing, and
adds a bunch of tests to it.

Thanks,

James

[Paul Sokolovsky (pfalcon)]

Seems like good refactors and test coverage extension.

review: Approve

=== modified file 'lpworkitems/fake_launchpad.py'
--- lpworkitems/fake_launchpad.py	2011-03-23 16:16:50 +0000
+++ lpworkitems/fake_launchpad.py	2011-06-08 02:19:22 +0000
@@ -1,12 +1,20 @@
 class LaunchpadAPIObject(object):
 
+    RESOURCE_TYPE = None
+
     def __init__(self):
         self.self_link = None
         self.web_link = None
 
+    @property
+    def resource_type_link(self):
+        return "some_url#%s" % self.RESOURCE_TYPE
+
 
 class LaunchpadMilestone(LaunchpadAPIObject):
 
+    RESOURCE_TYPE = "milestone"
+
     def __init__(self, name, date_targeted, target):
         super(LaunchpadMilestone, self).__init__()
         self.name = name
@@ -16,13 +24,27 @@
 
 class LaunchpadProject(LaunchpadAPIObject):
 
+    RESOURCE_TYPE = "project"
+
     def __init__(self, name):
         super(LaunchpadProject, self).__init__()
         self.name = name
 
 
+class LaunchpadProjectSeries(LaunchpadAPIObject):
+
+    RESOURCE_TYPE = "project_series"
+
+    def __init__(self):
+        super(LaunchpadProjectSeries, self).__init__()
+        self.name = None
+        self.project = None
+
+
 class LaunchpadBlueprint(LaunchpadAPIObject):
 
+    RESOURCE_TYPE = "blueprint"
+
     def __init__(self):
         super(LaunchpadBlueprint, self).__init__()
         self.priority = None
@@ -39,11 +61,83 @@
 
 class LaunchpadPerson(LaunchpadAPIObject):
 
+    RESOURCE_TYPE = "person"
+
     def __init__(self):
         super(LaunchpadPerson, self).__init__()
         self.name = None
 
 
+class LaunchpadBug(LaunchpadAPIObject):
+
+    RESOURCE_TYPE = "bug"
+
+    def __init__(self):
+        super(LaunchpadBug, self).__init__()
+        self.id = None
+        self.title = None
+        self.bug_tasks = []
+
+
+class LaunchpadBugTask(LaunchpadAPIObject):
+
+    RESOURCE_TYPE = "bug_task"
+
+    def __init__(self):
+        super(LaunchpadBugTask, self).__init__()
+        self.status = None
+        self.target = None
+        self.bug = None
+        self.assignee = None
+        self.milestone = None
+        self.related_tasks = []
+
+
+class LaunchpadDistribution(LaunchpadAPIObject):
+
+    RESOURCE_TYPE = "distribution"
+
+    def __init__(self):
+        super(LaunchpadDistribution, self).__init__()
+        self.name = None
+
+
+class LaunchpadDistributionSeries(LaunchpadAPIObject):
+
+    RESOURCE_TYPE = "distro_series"
+
+    def __init__(self):
+        super(LaunchpadDistributionSeries, self).__init__()
+        self.name = None
+        self.distribution = None
+
+
+class LaunchpadDistributionSourcePackage(LaunchpadAPIObject):
+    """A source package in a distribution (not series-specific.)"""
+
+    RESOURCE_TYPE = "distribution_source_package"
+
+    def __init__(self):
+        super(LaunchpadDistributionSourcePackage, self).__init__()
+        self.distribution = None
+        self.name = None
+
+
+class LaunchpadSourcePackage(LaunchpadAPIObject):
+    """A source in a particular release of a distribution."""
+
+    RESOURCE_TYPE = "source_package"
+
+    def __init__(self):
+        super(LaunchpadSourcePackage, self).__init__()
+        self.distroseries = None
+        self.name = None
+
+    @property
+    def distribution(self):
+        return self.distroseries.distribution
+
+
 class FakeLaunchpad(object):
 
     def __init__(self, factory):
@@ -52,7 +146,7 @@
         self.people = {}
 
     def load(self, url):
-        assert url in self._urls, "Loading unkonwn URL: %s" % url
+        assert url in self._urls, "Loading unknown URL: %s" % url
         return self._urls[url]
 
     def set_load_result(self, url, result):
@@ -78,9 +172,21 @@
         self.register_object(project)
         return project
 
+    def make_project_series(self, name=None, project=None):
+        if project is None:
+            project = self.make_project()
+        if name is None:
+            name = self._factory.getUniqueUnicode(
+                prefix="%s_series" % project.name)
+        project_series = LaunchpadProjectSeries()
+        project_series.name = name
+        project_series.project = project
+        self.register_object(project_series)
+        return project_series
+
     def make_milestone(self, name=None, date_targeted=None, target=None):
         if name is None:
-            name = self._factory.getUniqueUnicode(prefix="name")
+            name = self._factory.getUniqueUnicode(prefix="lpmilestone")
         if target is None:
             target = self.make_project()
         milestone = LaunchpadMilestone(name, date_targeted, target)
@@ -118,3 +224,77 @@
         self.register_object(person)
         self.people[name] = person
         return person
+
+    def make_bug(self, id_=None, title=None):
+        if id_ is None:
+            id_ = self._factory.getUniqueInteger()
+        if title is None:
+            title = self._factory.getUniqueUnicode(
+                prefix="bug_%d_description" % id_)
+        bug = LaunchpadBug()
+        bug.id = id_
+        bug.title = title
+        self.register_object(bug)
+        return bug
+
+    def make_bug_task(self, bug=None, status=None, target=None,
+                      assignee=None, milestone=None):
+        if bug is None:
+            bug = self.make_bug()
+        if target is None:
+            target = self.make_project()
+        if status is None:
+            status = u"Expired"
+        bug_task = LaunchpadBugTask()
+        bug_task.bug = bug
+        bug_task.status = status
+        bug_task.target = target
+        bug_task.assignee = assignee
+        bug_task.milestone = milestone
+        self.register_object(bug_task)
+        bug.bug_tasks.append(bug_task)
+        return bug_task
+
+    def make_distribution(self, name=None):
+        if name is None:
+            name = self._factory.getUniqueUnicode(prefix="lpdistribution")
+        distribution = LaunchpadDistribution()
+        distribution.name = name
+        self.register_object(distribution)
+        return distribution
+
+    def make_distro_series(self, distribution=None, name=None):
+        if distribution is None:
+            distribution = self.make_distribution()
+        if name is None:
+            name = self._factory.getUniqueUnicode(
+                prefix="%s_release" % distribution.name)
+        distro_series = LaunchpadDistributionSeries()
+        distro_series.name = name
+        distro_series.distribution = distribution
+        self.register_object(distro_series)
+        return distro_series
+
+    def make_distribution_source_package(self, distribution=None, name=None):
+        if distribution is None:
+            distribution = self.make_distribution()
+        if name is None:
+            name = self._factory.getUniqueUnicode(
+                prefix="%s_package" % distribution.name)
+        distribution_source_package = LaunchpadDistributionSourcePackage()
+        distribution_source_package.distribution = distribution
+        distribution_source_package.name = name
+        self.register_object(distribution_source_package)
+        return distribution_source_package
+
+    def make_source_package(self, distroseries=None, name=None):
+        if distroseries is None:
+            distroseries = self.make_distro_series()
+        if name is None:
+            name = self._factory.getUniqueUnicode(
+                prefix="%s_package" % distroseries.name)
+        source_package = LaunchpadSourcePackage()
+        source_package.distroseries = distroseries
+        source_package.name = name
+        self.register_object(source_package)
+        return source_package

=== modified file 'lpworkitems/testing.py'
--- lpworkitems/testing.py	2011-03-24 16:54:15 +0000
+++ lpworkitems/testing.py	2011-06-08 02:19:22 +0000
@@ -1,5 +1,6 @@
 from storm.locals import create_database, Store
 from testtools import TestCase
+from testtools.matchers import Annotate, Matcher, Mismatch
 
 from lpworkitems.database import create_tables
 from lpworkitems.factory import Factory
@@ -21,3 +22,77 @@
     def setUp(self):
         super(TestCaseWithFakeLaunchpad, self).setUp()
         self.lp = FakeLaunchpad(self.factory)
+
+
+class FactoryTestCaseMixin(TestCase):
+
+    def assert_with_and_without(self, method, param, value, without_matcher=None,
+                                attribute_name=None):
+        """Test the result of calling method with and without a parameter.
+
+        This method checks that calling `method` with and without
+        `param` gives the correct results.
+
+        First `method` is called with `param` set to `value`, and the result
+        is checked to see that the attribute with the same name as `param`
+        is set to `value`.
+
+        If `attribute_name` is not `None` that that attribute will be
+        used instead of the one with the same name as `param`.
+
+        Then `method` is called again with `param=None` and the result returned.
+        If `without_matcher` is not None then it is checked that the
+        attribute of the result with the same name as `param` satisfies the
+        `matches` method of `without_matcher`.
+
+        :param method: the method under test
+        :type method: a function object
+        :param param: the name of the paramater and attribute to test.
+        :type param: str
+        :param value: the value to pass as the value for `param`
+            and to check against the result.
+        :type value: anything
+        :param without_matcher: a `Matcher` to use to test the result
+            attribute when `None` is passed, or `None` to skip that test.
+        :type without_matcher: `Matcher` or `None`.
+        :param attribute_name: the name of the attribute to test, if
+            different from `param`.
+        :type attribute_name: str
+        """
+        if attribute_name is None:
+            attribute_name = param
+        kwargs = {param: value}
+        ret = method(**kwargs)
+        self.assertEqual(
+            value, getattr(ret, attribute_name),
+            "%s returned an object with the wrong value for %s"
+            " when called with %s=%s" % (method, attribute_name, param, value))
+        kwargs = {param: None}
+        ret = method(**kwargs)
+        if without_matcher:
+            self.assertThat(
+                getattr(ret, attribute_name),
+                Annotate("%s returned an object with the wrong value "
+                         "for %s when called with %s=None"
+                         % (method, attribute_name, param),
+                         without_matcher))
+        return ret
+
+
+class IsNotInstanceMismatch(Mismatch):
+
+    def describe(self):
+        return "Is not an instance"
+
+
+class IsInstance(Matcher):
+
+    def __init__(self, klass):
+        self.klass = klass
+
+    def match(self, matchee):
+        if not isinstance(matchee, self.klass):
+            return IsNotInstanceMismatch()
+
+    def __str__(self):
+        return "Is an instance of %s" % self.klass

=== modified file 'lpworkitems/tests/test_factory.py'
--- lpworkitems/tests/test_factory.py	2011-06-04 18:45:34 +0000
+++ lpworkitems/tests/test_factory.py	2011-06-08 02:19:22 +0000
@@ -1,17 +1,19 @@
 import datetime
 
 from testtools.matchers import (
-    Annotate,
     Equals,
     Not,
     StartsWith,
     )
 
 from lpworkitems import models
-from lpworkitems.testing import TestCaseWithFactory
-
-
-class FactoryTestCase(TestCaseWithFactory):
+from lpworkitems.testing import (
+    FactoryTestCaseMixin,
+    TestCaseWithFactory,
+)
+
+
+class FactoryTestCase(FactoryTestCaseMixin, TestCaseWithFactory):
 
     def assert_stores_result(self, method, klass):
         """Assert that the method adds the result to the store.
@@ -38,49 +40,6 @@
             "The instance of %s stored by %s didn't match the "
             "one it returned" % (klass, method))
 
-    def assert_with_and_without(self, method, param, value, without_matcher=None):
-        """Test the result of calling method with and without a parameter.
-
-        This method checks that calling `method` with and without
-        `param` gives the correct results.
-
-        First `method` is called with `param` set to `value`, and the result
-        is checked to see that the attribute with the same name as `param`
-        is set to `value`.
-
-        Then `method` is called again with `param=None` and the result returned.
-        If `without_matcher` is not None then it is checked that the
-        attribute of the result with the same name as `param` satisfies the
-        `matches` method of `without_matcher`.
-
-        :param method: the method under test
-        :type method: a function object
-        :param param: the name of the paramater and attribute to test.
-        :type param: str
-        :param value: the value to pass as the value for `param`
-             and to check against the result.
-        :type value: anything
-        :param without_matcher: a `Matcher` to use to test the result
-             attribute when `None` is passed, or `None` to skip that test.
-        :type without_matcher: `Matcher` or `None`.
-        """
-        kwargs = {param: value}
-        ret = method(**kwargs)
-        self.assertEqual(
-            value, getattr(ret, param),
-            "%s returned an object with the wrong value for %s"
-            " when called with %s=%s" % (method, param, param, value))
-        kwargs = {param: None}
-        ret = method(**kwargs)
-        if without_matcher:
-            self.assertThat(
-                getattr(ret, param),
-                Annotate("%s returned an object with the wrong value "
-                         "for %s when called with %s=None"
-                         % (method, param, param),
-                         without_matcher))
-        return ret
-
 
 class FactoryTests(TestCaseWithFactory):
 

=== added file 'lpworkitems/tests/test_fake_launchpad.py'
--- lpworkitems/tests/test_fake_launchpad.py	1970-01-01 00:00:00 +0000
+++ lpworkitems/tests/test_fake_launchpad.py	2011-06-08 02:19:22 +0000
@@ -0,0 +1,415 @@
+from testtools import TestCase
+from testtools.matchers import EndsWith, Equals, StartsWith
+
+from lpworkitems import fake_launchpad
+from lpworkitems.testing import (
+    FactoryTestCaseMixin,
+    IsInstance,
+    TestCaseWithFakeLaunchpad,
+)
+
+
+class LaunchpadAPIObjectTests(TestCase):
+
+    def test_resource_type_link_ends_with_resource_type(self):
+        person = fake_launchpad.LaunchpadPerson()
+        self.assertThat(
+            person.resource_type_link,
+            EndsWith("#%s" % person.RESOURCE_TYPE))
+
+
+class FakeLaunchpadTests(TestCaseWithFakeLaunchpad):
+
+    def test_set_and_load(self):
+        url = self.factory.getUniqueUnicode()
+        result = fake_launchpad.LaunchpadPerson()
+        self.lp.set_load_result(url, result)
+        self.assertEqual(result, self.lp.load(url))
+
+    def test_register_object_sets_self_link(self):
+        obj = fake_launchpad.LaunchpadPerson()
+        self.assertEqual(None, obj.self_link)
+        self.lp.register_object(obj)
+        self.assertNotEqual(None, obj.self_link)
+
+    def test_register_object_sets_web_link(self):
+        obj = fake_launchpad.LaunchpadPerson()
+        self.assertEqual(None, obj.web_link)
+        self.lp.register_object(obj)
+        self.assertNotEqual(None, obj.web_link)
+
+    def test_register_object_registers(self):
+        obj = fake_launchpad.LaunchpadPerson()
+        self.lp.register_object(obj)
+        self.assertEqual(obj, self.lp.load(obj.self_link))
+
+    def test_register_object_uses_existing_self_link(self):
+        self_link = self.factory.getUniqueUnicode()
+        obj = fake_launchpad.LaunchpadPerson()
+        obj.self_link = self_link
+        self.lp.register_object(obj)
+        self.assertEqual(self_link, obj.self_link)
+        self.assertEqual(obj, self.lp.load(self_link))
+
+    def test_make_self_link_returns_unicode(self):
+        self_link = self.lp.make_self_link()
+        self.assertIsInstance(self_link, unicode)
+
+    def test_make_self_link_starts_with_self_link(self):
+        self_link = self.lp.make_self_link()
+        self.assertThat(self_link, StartsWith(u"self_link"))
+
+    def test_make_web_link_returns_unicode(self):
+        web_link = self.lp.make_web_link()
+        self.assertIsInstance(web_link, unicode)
+
+    def test_make_web_link_starts_with_web_link(self):
+        web_link = self.lp.make_web_link()
+        self.assertThat(web_link, StartsWith(u"web_link"))
+
+
+class FakeLaunchpadMakeProjectTests(FactoryTestCaseMixin,
+                                    TestCaseWithFakeLaunchpad):
+
+    def test_returns_project(self):
+        project = self.lp.make_project()
+        self.assertIsInstance(
+            project, fake_launchpad.LaunchpadProject)
+
+    def test_uses_name(self):
+        name = self.factory.getUniqueUnicode(prefix="testproject")
+        self.assert_with_and_without(
+            self.lp.make_project, "name", name, StartsWith(u"lpproject"))
+
+    def test_registers_project(self):
+        project = self.lp.make_project()
+        self.assertEqual(project, self.lp.load(project.self_link))
+
+
+class FakeLaunchpadMakeProjectSeriesTests(FactoryTestCaseMixin,
+                                          TestCaseWithFakeLaunchpad):
+
+    def test_series_returns_project_series(self):
+        project_series = self.lp.make_project_series()
+        self.assertIsInstance(
+            project_series, fake_launchpad.LaunchpadProjectSeries)
+
+    def test_series_uses_project(self):
+        project = self.lp.make_project()
+        self.assert_with_and_without(
+            self.lp.make_project_series, "project", project,
+            IsInstance(fake_launchpad.LaunchpadProject))
+
+    def test_series_uses_name(self):
+        name = self.factory.getUniqueUnicode()
+        series = self.assert_with_and_without(
+            self.lp.make_project_series, "name", name)
+        self.assertThat(
+            series.name,
+            StartsWith("%s_series" % series.project.name))
+
+    def test_registers_object(self):
+        series = self.lp.make_project_series()
+        self.assertEqual(series, self.lp.load(series.self_link))
+
+
+class FakeLaunchpadMakeMilestoneTests(FactoryTestCaseMixin,
+                                      TestCaseWithFakeLaunchpad):
+
+    def test_returns_milestone(self):
+        milestone = self.lp.make_milestone()
+        self.assertIsInstance(
+            milestone, fake_launchpad.LaunchpadMilestone)
+
+    def test_uses_name(self):
+        name = self.factory.getUniqueUnicode()
+        self.assert_with_and_without(
+            self.lp.make_milestone, "name", name,
+            StartsWith(u"lpmilestone"))
+
+    def test_uses_target(self):
+        target = self.lp.make_distribution()
+        self.assert_with_and_without(
+            self.lp.make_milestone, "target", target,
+            IsInstance(fake_launchpad.LaunchpadProject))
+
+    def test_uses_date_targeted(self):
+        date_targeted = self.factory.getUniqueDate()
+        self.assert_with_and_without(
+            self.lp.make_milestone, "date_targeted", date_targeted,
+            Equals(None))
+
+    def test_registers_milestone(self):
+        milestone = self.lp.make_milestone()
+        self.assertEqual(milestone, self.lp.load(milestone.self_link))
+
+
+class FakeLaunchpadMakeBlueprintTests(FactoryTestCaseMixin,
+                                      TestCaseWithFakeLaunchpad):
+
+    def test_returns_blueprint(self):
+        blueprint = self.lp.make_blueprint()
+        self.assertIsInstance(blueprint, fake_launchpad.LaunchpadBlueprint)
+
+    def test_uses_name(self):
+        name = self.factory.getUniqueUnicode(prefix=u"testbp")
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "name", name,
+            StartsWith(u"lpblueprint"))
+
+    def test_uses_priority(self):
+        priority = u"High"
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "priority", priority,
+            Equals(None))
+
+    def test_uses_definition_status(self):
+        definition_status = u"Drafting"
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "definition_status", definition_status,
+            Equals(None))
+
+    def test_uses_implementation_status(self):
+        implementation_status = u"Implemented"
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "implementation_status", implementation_status,
+            Equals(None))
+
+    def test_uses_approver(self):
+        approver = self.lp.make_person()
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "approver", approver, Equals(None))
+
+    def test_uses_drafter(self):
+        drafter = self.lp.make_person()
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "drafter", drafter, Equals(None))
+
+    def test_uses_assignee(self):
+        assignee = self.lp.make_person()
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "assignee", assignee, Equals(None))
+
+    def test_uses_milestone(self):
+        milestone = self.lp.make_milestone()
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "milestone", milestone, Equals(None))
+
+    def test_uses_whiteboard(self):
+        whiteboard = self.factory.getUniqueUnicode()
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "whiteboard", whiteboard, Equals(None))
+
+    def test_uses_specification_url(self):
+        specification_url = self.factory.getUniqueUnicode()
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "specification_url", specification_url,
+            Equals(None))
+
+    def test_uses_summary(self):
+        summary = self.factory.getUniqueUnicode()
+        self.assert_with_and_without(
+            self.lp.make_blueprint, "summary", summary, Equals(None))
+
+    def test_registers_blueprint(self):
+        blueprint = self.lp.make_blueprint()
+        self.assertEqual(blueprint, self.lp.load(blueprint.self_link))
+
+
+class FakeLaunchpadMakePersonTests(FactoryTestCaseMixin,
+                                   TestCaseWithFakeLaunchpad):
+
+    def test_returns_person(self):
+        person = self.lp.make_person()
+        self.assertIsInstance(person, fake_launchpad.LaunchpadPerson)
+
+
+    def test_uses_name(self):
+        name = self.factory.getUniqueUnicode(prefix=u"testperson")
+        self.assert_with_and_without(
+            self.lp.make_person, "name", name, StartsWith(u"lpperson"))
+
+    def test_registers_person(self):
+        person = self.lp.make_person()
+        self.assertEqual(person, self.lp.load(person.self_link))
+
+    def test_adds_to_people(self):
+        person = self.lp.make_person()
+        self.assertEqual(person, self.lp.people[person.name])
+
+
+class FakeLaunchpadMakeBugTests(FactoryTestCaseMixin,
+                                TestCaseWithFakeLaunchpad):
+
+    def test_returns_bug(self):
+        bug = self.lp.make_bug()
+        self.assertIsInstance(bug, fake_launchpad.LaunchpadBug)
+
+    def test_uses_id(self):
+        id_ = self.factory.getUniqueInteger()
+        self.assert_with_and_without(
+            self.lp.make_bug, "id_", id_, IsInstance(int),
+            attribute_name="id")
+
+    def test_uses_title(self):
+        title = self.factory.getUniqueUnicode(prefix=u"testtitle")
+        bug = self.assert_with_and_without(
+            self.lp.make_bug, "title", title)
+        self.assertThat(
+            bug.title,
+            StartsWith("bug_%d_description" % bug.id))
+
+    def test_registers_bug(self):
+        bug = self.lp.make_bug()
+        self.assertEqual(bug, self.lp.load(bug.self_link))
+
+
+class FakeLaunchpadMakeBugTaskTests(FactoryTestCaseMixin,
+                                    TestCaseWithFakeLaunchpad):
+
+    def test_returns_bug_task(self):
+        bug_task = self.lp.make_bug_task()
+        self.assertIsInstance(bug_task, fake_launchpad.LaunchpadBugTask)
+
+    def test_uses_bug(self):
+        bug = self.lp.make_bug()
+        self.assert_with_and_without(
+            self.lp.make_bug_task, "bug", bug,
+            IsInstance(fake_launchpad.LaunchpadBug))
+
+    def test_uses_target(self):
+        target = self.lp.make_distribution()
+        self.assert_with_and_without(
+            self.lp.make_bug_task, "target", target,
+            IsInstance(fake_launchpad.LaunchpadProject))
+
+    def test_uses_assignee(self):
+        assignee = self.lp.make_person()
+        self.assert_with_and_without(
+            self.lp.make_bug_task, "assignee", assignee, Equals(None))
+
+    def test_uses_milestone(self):
+        milestone = self.lp.make_milestone()
+        self.assert_with_and_without(
+            self.lp.make_bug_task, "milestone", milestone, Equals(None))
+
+    def test_uses_status(self):
+        status = u"Opinion"
+        self.assert_with_and_without(
+            self.lp.make_bug_task, "status", status, Equals(u"Expired"))
+
+    def test_registers_bug_task(self):
+        bug_task = self.lp.make_bug_task()
+        self.assertEqual(bug_task, self.lp.load(bug_task.self_link))
+
+    def test_adds_task_to_bug(self):
+        bug_task = self.lp.make_bug_task()
+        self.assertEqual(1, len(bug_task.bug.bug_tasks))
+        self.assertEqual(bug_task, bug_task.bug.bug_tasks[0])
+
+
+class FakeLaunchpadMakeDistributionTests(FactoryTestCaseMixin,
+                                         TestCaseWithFakeLaunchpad):
+
+    def test_returns_distribution(self):
+        distribution = self.lp.make_distribution()
+        self.assertIsInstance(
+            distribution, fake_launchpad.LaunchpadDistribution)
+
+    def test_uses_name(self):
+        name = self.factory.getUniqueUnicode(
+            prefix=u"testdistribuition")
+        self.assert_with_and_without(
+            self.lp.make_distribution, "name", name,
+            StartsWith(u"lpdistribution"))
+
+    def test_registers_distribution(self):
+        distribution = self.lp.make_distribution()
+        self.assertEqual(distribution, self.lp.load(distribution.self_link))
+
+
+class FakeLaunchpadMakeDistroSeriesTests(FactoryTestCaseMixin,
+                                         TestCaseWithFakeLaunchpad):
+
+    def test_returns_distro_series(self):
+        distro_series = self.lp.make_distro_series()
+        self.assertIsInstance(
+            distro_series, fake_launchpad.LaunchpadDistributionSeries)
+
+    def test_uses_distribution(self):
+        distribution = self.lp.make_distribution()
+        self.assert_with_and_without(
+            self.lp.make_distro_series, "distribution", distribution,
+            IsInstance(fake_launchpad.LaunchpadDistribution))
+
+    def test_uses_name(self):
+        name = self.factory.getUniqueUnicode(prefix="testdistroseries")
+        distro_series = self.assert_with_and_without(
+            self.lp.make_distro_series, "name", name)
+        self.assertThat(
+            distro_series.name,
+            StartsWith("%s_release" % distro_series.distribution.name))
+
+    def test_registers_distribution(self):
+        distribution = self.lp.make_distribution()
+        self.assertEqual(distribution, self.lp.load(distribution.self_link))
+
+
+class FakeLaunchpadMakeDistributionSourcePackage(FactoryTestCaseMixin,
+                                                 TestCaseWithFakeLaunchpad):
+
+    def test_returns_distribution_source_package(self):
+        distribution_source_package = (
+            self.lp.make_distribution_source_package())
+        self.assertIsInstance(
+            distribution_source_package,
+            fake_launchpad.LaunchpadDistributionSourcePackage)
+
+    def test_uses_distribution(self):
+        distribution = self.lp.make_distribution()
+        self.assert_with_and_without(
+            self.lp.make_distribution_source_package, "distribution",
+            distribution, IsInstance(fake_launchpad.LaunchpadDistribution))
+
+    def test_uses_name(self):
+        name = self.factory.getUniqueUnicode(prefix=u"testdsp")
+        dsp = self.assert_with_and_without(
+            self.lp.make_distribution_source_package, "name", name)
+        self.assertThat(
+            dsp.name,
+            StartsWith("%s_package" % dsp.distribution.name))
+
+    def test_registers_distribution_source_package(self):
+        distribution_source_package = (
+            self.lp.make_distribution_source_package())
+        self.assertEqual(
+            distribution_source_package,
+            self.lp.load(distribution_source_package.self_link))
+
+
+class FakeLaunchpadMakeSourcePackageTests(FactoryTestCaseMixin,
+                                          TestCaseWithFakeLaunchpad):
+
+    def test_returns_source_package(self):
+        source_package = self.lp.make_source_package()
+        self.assertIsInstance(
+            source_package, fake_launchpad.LaunchpadSourcePackage)
+
+    def test_uses_distroseries(self):
+        distroseries = self.lp.make_distro_series()
+        self.assert_with_and_without(
+            self.lp.make_source_package, "distroseries", distroseries,
+            IsInstance(fake_launchpad.LaunchpadDistributionSeries))
+
+    def test_uses_name(self):
+        name = self.factory.getUniqueUnicode(prefix=u"testpackage")
+        source_package = self.assert_with_and_without(
+            self.lp.make_source_package, "name", name)
+        self.assertThat(
+            source_package.name,
+            StartsWith(u"%s_package" % source_package.distroseries.name))
+
+    def test_registers_source_package(self):
+        source_package = self.lp.make_source_package()
+        self.assertEqual(
+            source_package, self.lp.load(source_package.self_link))

=== modified file 'tests.py'
--- tests.py	2011-05-31 16:20:49 +0000
+++ tests.py	2011-06-08 02:19:22 +0000
@@ -170,5 +170,6 @@
     suite.addTests(loader.loadTestsFromName("lpworkitems.tests.test_collect"))
     suite.addTests(loader.loadTestsFromName("lpworkitems.tests.test_error_collector"))
     suite.addTests(loader.loadTestsFromName("lpworkitems.tests.test_factory"))
+    suite.addTests(loader.loadTestsFromName("lpworkitems.tests.test_fake_launchpad"))
     suite.addTests(loader.loadTestsFromName("lpworkitems.tests.test_models"))
     return suite