Merge lp:~deryck/launchpad/better-testing-for-status-changes into lp:launchpad

[Deryck Hodge]

Refactor doctest for bugtask status changes into separate unit test and documentation.

This branch is the first toward a fix for Bug #126516, or more specifically for a fix to limit transitioning away from Fix Released status. Before this branch the tests for bugtask status changes was a mix of a unit test and doctest, both living under lp.bugs.tests.

The branch refactors that mess, opting to do a complete unit test of BugTask.transitionToStatus and BugTask.canTransitionToStatus. The doctest is then made to be documentation and moved to lp.bugs.doc. Some example code is left in the doctest, though refactored to use factory generated data.

To test, run:

./bin/test -cvvt bugtask-status-changes
./bin/test -cvvt test_bugtask_status

Thanks for the review!

[Abel Deuring (adeuring)]

(17:52:07) adeuring: deryck: I think it might make sense to change the test setup so that the product owner is not a member of the bug supervisor team; right now, the term "or user.inTeam(pillar.owner)" in canTransitionToStatus() is not executed
(17:52:53) deryck: adeuring, ok, that's a good idea. I can do that.
(17:53:07) adeuring: deryck: thanks! another suggestion, before you start ;)
(17:53:16) deryck: sure
(17:55:28) salgado heißt jetzt salgado-lunch
(17:55:30) adeuring: deryck: you don't test at all for celebrities.bug_watch_updater, celebrities.bug_importer, celebrities.janitor. You could add these tests quickly by definig a base class for tests of "extended permissions", where you do not define the user who is tested, then derive the "real" test classes for supervisor, owner and the celebrities.
(17:55:45) adeuring: That should make the tests a bit shorter and more comprehensive
(17:57:44) deryck: sure, I like that idea. I can do that, too.
(17:57:59) adeuring: deryck: cool, thanks!

[Abel Deuring (adeuring)]

Hi Deryck,

thanks for the refactoring. r=me.

Just a few nitpicks:

could you add TestCases for the celebrities bug_watch_updater,
bug_importer, janitor?

> +class TestBugTaskStatusTransitionForPrivilegedUserBase:
> + """Base class used to test privileged users and status transitions."""
> +
> + layer = LaunchpadFunctionalLayer
> +
> + def setUp(self):
> + super(TestBugTaskStatusTransitionForPrivilegedUserBase, self).setUp()
> + # Creation of task and target are deferred to subclasses.
> + self.task = None
> + self.person = None
> + self.makePersonAndTask()
> +
> + def makePersonAndTask(self):
> + """Create a bug task and privileged person for this task.
> +
> + This method is user by subclasses to correctly setup
> + each test.
> + """

I think this should be something like "is (overloaded|implemented) by
subclasses"

cheers
Abel

review: Approve (code)

=== renamed file 'lib/lp/bugs/tests/test_bugtask_status.txt' => 'lib/lp/bugs/doc/bugtask-status-changes.txt'
--- lib/lp/bugs/tests/test_bugtask_status.txt	2010-10-09 16:36:22 +0000
+++ lib/lp/bugs/doc/bugtask-status-changes.txt	2010-10-19 13:36:54 +0000
@@ -1,137 +1,57 @@
-= Setting Bug Statuses =
-
-    >>> from canonical.launchpad.interfaces import (
-    ...     CreateBugParams, IPersonSet, IProductSet)
+Changing Bug Task Status
+========================
+
+Restrictions
+------------
+
+There are a few simple rules around who can change the status of a
+bug task.  There are three statuses that can only be set by either
+the project registrant or the bug supervisor:
+
+ * Won't Fix
+ * Expired
+ * Triaged
+
+    >>> owner = factory.makePerson()
+    >>> product = factory.makeProduct(owner=owner)
+    >>> bugtask = factory.makeBugTask(target=product)
+    >>> user = factory.makePerson()
+
     >>> from lp.bugs.interfaces.bugtask import BugTaskStatus
-
-    >>> firefox = getUtility(IProductSet).getByName('firefox')
-    >>> nopriv_user = getUtility(IPersonSet).getByName('no-priv')
-    >>> login('[e-mail]')
-    >>> firefox.setBugSupervisor(nopriv_user, nopriv_user)
-    >>> login('[e-mail]')
-    >>> bug_params = CreateBugParams(
-    ...     nopriv_user, 'Test bug', 'Something')
-    >>> firefox_bug = firefox.createBug(bug_params)
-
-Bug Supervisors can transition bugs to the Won't Fix, Expired and
-Triaged statuses.
-
-    >>> [firefox_bugtask] = firefox_bug.bugtasks
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.WONTFIX, nopriv_user)
-    >>> print firefox_bugtask.status.title
-    Won't Fix
-
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.EXPIRED, nopriv_user)
-    >>> print firefox_bugtask.status.title
-    Expired
-
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.TRIAGED, nopriv_user)
-    >>> print firefox_bugtask.status.title
-    Triaged
-
-The product registrant can transition to the Won't Fix, Expired and
-Triaged statuses too.
-
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.CONFIRMED, nopriv_user)
-    >>> print firefox_bugtask.status.title
-    Confirmed
-
-    >>> firefox.owner.inTeam(firefox.bug_supervisor)
-    False
-
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.WONTFIX, firefox.owner)
-    >>> print firefox_bugtask.status.title
-    Won't Fix
-
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.EXPIRED, firefox.owner)
-    >>> print firefox_bugtask.status.title
-    Expired
-
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.TRIAGED, firefox.owner)
-    >>> print firefox_bugtask.status.title
-    Triaged
-
-Users who are not bug supervisors or product registrants cannot
-transition the status to Won't Fix or Triaged. The option is not
-exposed in the UI, but we also enforce this rule at the database level
-to ensure that all call sites adhere to this.
-
-    >>> login('[e-mail]')
-    >>> firefox.setBugSupervisor(None, None)
-
-    >>> login('[e-mail]')
-
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.WONTFIX, nopriv_user)
-    Traceback (most recent call last):
-    ...
-    UserCannotEditBugTaskStatus: Only Bug Supervisors may change status to Won't Fix.
-
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.EXPIRED, nopriv_user)
-    Traceback (most recent call last):
-    ...
-    UserCannotEditBugTaskStatus: Only Bug Supervisors may change status to Expired.
-
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.TRIAGED, nopriv_user)
-    Traceback (most recent call last):
-    ...
-    UserCannotEditBugTaskStatus: Only Bug Supervisors may change status to Triaged.
-
-Users who are not bug supervisors or product registrants cannot
-transition the status from Won't Fix to anything else.
-
-    >>> login('[e-mail]')
-    >>> foo_bar = getUtility(ILaunchBag).user
-    >>> firefox.setBugSupervisor(foo_bar, foo_bar)
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.WONTFIX, foo_bar)
-
-    >>> login('[e-mail]')
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.NEW, nopriv_user)
-    Traceback (most recent call last):
-    ...
-    UserCannotEditBugTaskStatus: Only Bug Supervisors may change status to New.
+    >>> login_person(owner)
+    >>> bugtask.transitionToStatus(BugTaskStatus.WONTFIX, owner)
+    >>> print bugtask.status.title
+    Won't Fix
+
+Regular users of Launchpad cannot transition a bug task to any of
+these statuses.
+
+An additional restraint is added to Won't Fix.  Only the product
+registrant or bug supervisor can change from this status to any
+other status.
+
+    >>> login_person(user)
+    >>> bugtask.transitionToStatus(BugTaskStatus.CONFIRMED, user)
+    Traceback (most recent call last):
+    ...
+    UserCannotEditBugTaskStatus...
+
+This is fully tested in
+lp.bugs.tests.test_bugtask_status.TestBugTaskStatusSetting.
+
+Testing for Permission
+----------------------
 
 The method IBugTask.canTransitionToStatus comes in handy here. It
 tells us if a transition to a status is permitted. It is *not* a
-dry-run of transitionToStatus, but is good enough and fast enough to
-be used by UI code, e.g. to display only those statuses to which a
-user can transition a particular bugtask.
-
-    >>> login('[e-mail]')
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.TRIAGED, foo_bar)
-
-    >>> login('[e-mail]')
-
-    >>> firefox_bugtask.canTransitionToStatus(
-    ...     BugTaskStatus.WONTFIX, nopriv_user)
-    False
-
-    >>> firefox_bugtask.canTransitionToStatus(
-    ...     BugTaskStatus.TRIAGED, nopriv_user)
-    False
-
-    >>> firefox_bugtask.canTransitionToStatus(
-    ...     BugTaskStatus.INCOMPLETE, nopriv_user)
+dry-run of IBugTask.transitionToStatus, but is good enough and fast
+enough to be used by UI code, e.g. to display only those statuses to
+which a user can transition a particular bugtask.
+
+    >>> bugtask.canTransitionToStatus(BugTaskStatus.TRIAGED, owner)
     True
-
-    >>> login('[e-mail]')
-    >>> firefox_bugtask.transitionToStatus(
-    ...     BugTaskStatus.WONTFIX, getUtility(ILaunchBag).user)
-
-    >>> login('[e-mail]')
-
-    >>> firefox_bugtask.canTransitionToStatus(
-    ...     BugTaskStatus.NEW, nopriv_user)
+    >>> bugtask.canTransitionToStatus(BugTaskStatus.TRIAGED, user)
     False
+
+This method is fully tested in
+lp.bugs.tests.test_bugtask_status.TestCanTransitionToStatus.

=== modified file 'lib/lp/bugs/tests/test_bugtask_status.py'
--- lib/lp/bugs/tests/test_bugtask_status.py	2010-10-04 19:50:45 +0000
+++ lib/lp/bugs/tests/test_bugtask_status.py	2010-10-19 13:36:54 +0000
@@ -1,22 +1,322 @@
 # Copyright 2009 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-"""Test for choosing the request and publication."""
+"""Tests for bug task status transitions."""
 
 __metaclass__ = type
 
-from canonical.launchpad.testing.systemdocs import (
-    LayeredDocFileSuite,
-    setUp,
-    tearDown,
+from zope.component import getUtility
+from zope.security.proxy import removeSecurityProxy
+
+from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
+from canonical.testing.layers import LaunchpadFunctionalLayer
+from lp.bugs.interfaces.bugtask import UserCannotEditBugTaskStatus
+from lp.bugs.model.bugtask import BugTaskStatus
+from lp.testing import (
+    person_logged_in,
+    TestCaseWithFactory,
     )
-from canonical.testing.layers import LaunchpadFunctionalLayer
-
-
-def test_suite():
-    suite = LayeredDocFileSuite(
-            'test_bugtask_status.txt',
-            layer=LaunchpadFunctionalLayer, setUp=setUp, tearDown=tearDown,
-            )
-    return suite
-
+
+
+class TestBugTaskStatusTransitionForUser(TestCaseWithFactory):
+    """Test bugtask status transitions for a regular logged in user."""
+
+    layer = LaunchpadFunctionalLayer
+
+    def setUp(self):
+        super(TestBugTaskStatusTransitionForUser, self).setUp()
+        self.user = self.factory.makePerson()
+        self.task = self.factory.makeBugTask()
+
+    def test_user_transition_all_statuses(self):
+        # A regular user should not be able to set statuses in
+        # BUG_SUPERVISOR_BUGTASK_STATUSES, but can set any
+        # other status.
+        self.assertEqual(self.task.status, BugTaskStatus.NEW)
+        with person_logged_in(self.user):
+            self.assertRaises(
+                UserCannotEditBugTaskStatus, self.task.transitionToStatus,
+                BugTaskStatus.WONTFIX, self.user)
+            self.assertRaises(
+                UserCannotEditBugTaskStatus, self.task.transitionToStatus,
+                BugTaskStatus.EXPIRED, self.user)
+            self.assertRaises(
+                UserCannotEditBugTaskStatus, self.task.transitionToStatus,
+                BugTaskStatus.TRIAGED, self.user)
+            self.task.transitionToStatus(BugTaskStatus.NEW, self.user)
+            self.assertEqual(self.task.status, BugTaskStatus.NEW)
+            self.task.transitionToStatus(
+                BugTaskStatus.INCOMPLETE, self.user)
+            self.assertEqual(self.task.status, BugTaskStatus.INCOMPLETE)
+            self.task.transitionToStatus(BugTaskStatus.OPINION, self.user)
+            self.assertEqual(self.task.status, BugTaskStatus.OPINION)
+            self.task.transitionToStatus(BugTaskStatus.INVALID, self.user)
+            self.assertEqual(self.task.status, BugTaskStatus.INVALID)
+            self.task.transitionToStatus(BugTaskStatus.CONFIRMED, self.user)
+            self.assertEqual(self.task.status, BugTaskStatus.CONFIRMED)
+            self.task.transitionToStatus(
+                BugTaskStatus.INPROGRESS, self.user)
+            self.assertEqual(self.task.status, BugTaskStatus.INPROGRESS)
+            self.task.transitionToStatus(
+                BugTaskStatus.FIXCOMMITTED, self.user)
+            self.assertEqual(self.task.status, BugTaskStatus.FIXCOMMITTED)
+            self.task.transitionToStatus(
+                BugTaskStatus.FIXRELEASED, self.user)
+            self.assertEqual(self.task.status, BugTaskStatus.FIXRELEASED)
+
+    def test_user_cannot_unset_wont_fix_status(self):
+        # A regular user should not be able to transition a bug away
+        # from Won't Fix.
+        removeSecurityProxy(self.task).status = BugTaskStatus.WONTFIX
+        with person_logged_in(self.user):
+            self.assertRaises(
+                UserCannotEditBugTaskStatus, self.task.transitionToStatus,
+                BugTaskStatus.CONFIRMED, self.user)
+
+    def test_user_canTransitionToStatus(self):
+        # Regular user cannot transition to BUG_SUPERVISOR_BUGTASK_STATUSES,
+        # but can transition to any other status.
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.WONTFIX, self.user),
+            False)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.EXPIRED, self.user),
+            False)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.TRIAGED, self.user),
+            False)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.NEW, self.user),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.INCOMPLETE, self.user), True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.OPINION, self.user),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.INVALID, self.user),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.CONFIRMED, self.user),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.INPROGRESS, self.user),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.FIXCOMMITTED, self.user),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.FIXRELEASED, self.user),
+            True)
+
+    def test_user_canTransitionToStatus_from_wontfix(self):
+        # A regular user cannot transition away from Won't Fix,
+        # so canTransitionToStatus should return False.
+        removeSecurityProxy(self.task).status = BugTaskStatus.WONTFIX
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.NEW, self.user),
+            False)
+
+
+class TestBugTaskStatusTransitionForPrivilegedUserBase:
+    """Base class used to test privileged users and status transitions."""
+
+    layer = LaunchpadFunctionalLayer
+
+    def setUp(self):
+        super(TestBugTaskStatusTransitionForPrivilegedUserBase, self).setUp()
+        # Creation of task and target are deferred to subclasses.
+        self.task = None
+        self.person = None
+        self.makePersonAndTask()
+
+    def makePersonAndTask(self):
+        """Create a bug task and privileged person for this task.
+
+        This method is implemented by subclasses to correctly setup
+        each test.
+        """
+        raise NotImplementedError(self.makePersonAndTask)
+
+    def test_privileged_user_transition_any_status(self):
+        # Privileged users (like owner or bug supervisor) should
+        # be able to set any status.
+        with person_logged_in(self.person):
+            self.task.transitionToStatus(BugTaskStatus.WONTFIX, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.WONTFIX)
+            self.task.transitionToStatus(BugTaskStatus.EXPIRED, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.EXPIRED)
+            self.task.transitionToStatus(BugTaskStatus.TRIAGED, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.TRIAGED)
+            self.task.transitionToStatus(BugTaskStatus.NEW, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.NEW)
+            self.task.transitionToStatus(
+                BugTaskStatus.INCOMPLETE, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.INCOMPLETE)
+            self.task.transitionToStatus(BugTaskStatus.OPINION, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.OPINION)
+            self.task.transitionToStatus(BugTaskStatus.INVALID, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.INVALID)
+            self.task.transitionToStatus(BugTaskStatus.CONFIRMED, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.CONFIRMED)
+            self.task.transitionToStatus(
+                BugTaskStatus.INPROGRESS, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.INPROGRESS)
+            self.task.transitionToStatus(
+                BugTaskStatus.FIXCOMMITTED, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.FIXCOMMITTED)
+            self.task.transitionToStatus(
+                BugTaskStatus.FIXRELEASED, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.FIXRELEASED)
+
+    def test_privileged_user_can_unset_wont_fix_status(self):
+        # Privileged users can transition away from Won't Fix.
+        removeSecurityProxy(self.task).status = BugTaskStatus.WONTFIX
+        with person_logged_in(self.person):
+            self.task.transitionToStatus(BugTaskStatus.CONFIRMED, self.person)
+            self.assertEqual(self.task.status, BugTaskStatus.CONFIRMED)
+
+    def test_privileged_user_canTransitionToStatus(self):
+        # Privileged users (like owner or bug supervisor) should
+        # be able to set any status, so canTransitionToStatus should
+        # always return True.
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.WONTFIX, self.person),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.EXPIRED, self.person),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.TRIAGED, self.person),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.NEW, self.person),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.INCOMPLETE, self.person),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.OPINION, self.person),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.INVALID, self.person),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.CONFIRMED, self.person),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.INPROGRESS, self.person),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.FIXCOMMITTED, self.person),
+            True)
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.FIXRELEASED, self.person),
+            True)
+
+    def test_privileged_user_canTransitionToStatus_from_wontfix(self):
+        # A privileged user can transition away from Won't Fix, so
+        # canTransitionToStatus should return True.
+        removeSecurityProxy(self.task).status = BugTaskStatus.WONTFIX
+        self.assertEqual(
+            self.task.canTransitionToStatus(
+                BugTaskStatus.NEW, self.person),
+            True)
+
+
+class TestBugTaskStatusTransitionOwnerPerson(
+    TestBugTaskStatusTransitionForPrivilegedUserBase, TestCaseWithFactory):
+    """Tests to ensure owner person can transition to any status.."""
+
+    def makePersonAndTask(self):
+        self.person = self.factory.makePerson()
+        self.product = self.factory.makeProduct(owner=self.person)
+        self.task = self.factory.makeBugTask(target=self.product)
+
+
+class TestBugTaskStatusTransitionOwnerTeam(
+    TestBugTaskStatusTransitionForPrivilegedUserBase, TestCaseWithFactory):
+    """Tests to ensure owner team can transition to any status.."""
+
+    def makePersonAndTask(self):
+        self.person = self.factory.makePerson()
+        self.team = self.factory.makeTeam(members=[self.person])
+        self.product = self.factory.makeProduct(owner=self.team)
+        self.task = self.factory.makeBugTask(target=self.product)
+
+
+class TestBugTaskStatusTransitionBugSupervisorPerson(
+    TestBugTaskStatusTransitionForPrivilegedUserBase, TestCaseWithFactory):
+    """Tests to ensure bug supervisor person can transition to any status."""
+
+    def makePersonAndTask(self):
+        self.owner = self.factory.makePerson()
+        self.person = self.factory.makePerson()
+        self.product = self.factory.makeProduct(owner=self.owner)
+        self.task = self.factory.makeBugTask(target=self.product)
+        with person_logged_in(self.owner):
+            self.product.setBugSupervisor(self.person, self.person)
+
+
+class TestBugTaskStatusTransitionBugSupervisorTeamMember(
+    TestBugTaskStatusTransitionForPrivilegedUserBase, TestCaseWithFactory):
+    """Tests to ensure bug supervisor team can transition to any status."""
+
+    def makePersonAndTask(self):
+        self.owner = self.factory.makePerson()
+        self.person = self.factory.makePerson()
+        self.team = self.factory.makeTeam(members=[self.person])
+        self.product = self.factory.makeProduct(owner=self.owner)
+        self.task = self.factory.makeBugTask(target=self.product)
+        with person_logged_in(self.owner):
+            self.product.setBugSupervisor(self.team, self.team)
+
+
+class TestBugTaskStatusTransitionBugWatchUpdater(
+    TestBugTaskStatusTransitionForPrivilegedUserBase, TestCaseWithFactory):
+    """Tests to ensure bug_watch_updater can transition to any status."""
+
+    def makePersonAndTask(self):
+        self.person = getUtility(ILaunchpadCelebrities).bug_watch_updater
+        self.task = self.factory.makeBugTask()
+
+
+class TestBugTaskStatusTransitionBugImporter(
+    TestBugTaskStatusTransitionForPrivilegedUserBase, TestCaseWithFactory):
+    """Tests to ensure bug_importer can transition to any status."""
+
+    def makePersonAndTask(self):
+        self.person = getUtility(ILaunchpadCelebrities).bug_importer
+        self.task = self.factory.makeBugTask()
+
+
+class TestBugTaskStatusTransitionJanitor(
+    TestBugTaskStatusTransitionForPrivilegedUserBase, TestCaseWithFactory):
+    """Tests to ensure lp janitor can transition to any status."""
+
+    def makePersonAndTask(self):
+        self.person = getUtility(ILaunchpadCelebrities).janitor
+        self.task = self.factory.makeBugTask()