Merge lp:~allenap/launchpad/ditch-get-bug-notifications-recipients-bug-659085-devel into lp:launchpad

[Gavin Panella]

Remove getBugNotificationRecipients()

This is the same change as reviewed in:

https://code.edge.launchpad.net/~allenap/launchpad/ditch-get-bug-notifications-recipients-bug-659085/+merge/38325

However, that branch turned into conflict hell so I decided to
manually apply its revisions to a fresh branch and fix things as I
went. I also decided to re-target it to devel (there were reasons the
previous branch was targeted to db-devel, but they're no longer
relevant).

I've confirmed that the diff of this branch is almost exactly the same
as that in the previous review with the differences worthy of mention:

- In lib/lp/registry/doc/structural-subscriptions.txt an addional
  couple of paragraphs of set-up has been removed. It does nothing
  because the set-up was for some other removed code.

- Some code in the previous merge proposal was unreviewed - I did it
  after Graham completed the review - so that does need
  reviewing. It's fairly short, and in this branch the changes are
  revisions 11800 to 11803 inclusive. Here'a s handy diff I prepared
  earlier: http://paste.ubuntu.com/519697/

[Henning Eggers (henninge)]

<henninge> allenap: I have never seen a doc test import from a unit test. Is that a good(tm) practice?
<allenap> henninge: I don't think it's a problem, but it is a bit odd. Certainly BugTaskSearchBugsElsewhereTest.__init__() smells bad.
<allenap> henninge: Arguable those helper methods should have been put in a mixin or just a separate class, but as it is it's reasonably easy to figure out what's going on. I don't think there's much harm in it.
<henninge> Argh! Now I get what that is doing.
<henninge> allenap: Luckily it's not part of this review ... ;-)
<allenap> henninge: Yes, that's what I thought :)
<henninge> allenap: could you call the result "naked_bugtasks" here?
<henninge> + bugtasks = [removeSecurityProxy(bugtask) for bugtask in bugtasks]
<allenap> henninge: Sure.
<henninge> I think there was an agreement to clearly mark naked entities as such ...
<henninge> allenap: r=me for the handy diff. ;-)

review: Approve (code)

=== modified file 'lib/lp/bugs/configure.zcml'
--- lib/lp/bugs/configure.zcml	2010-10-19 21:30:53 +0000
+++ lib/lp/bugs/configure.zcml	2010-10-25 19:52:46 +0000
@@ -706,7 +706,6 @@
                     getSubscribersForPerson
                     indexed_messages
                     getAlsoNotifiedSubscribers
-                    getStructuralSubscribers
                     getBugWatch
                     canBeNominatedFor
                     getNominationFor

=== modified file 'lib/lp/bugs/doc/bugtask-search.txt'
--- lib/lp/bugs/doc/bugtask-search.txt	2010-10-19 18:44:31 +0000
+++ lib/lp/bugs/doc/bugtask-search.txt	2010-10-25 19:52:46 +0000
@@ -299,7 +299,7 @@
     ...     BugTaskImportance,
     ...     BugTaskStatus,
     ...     )
-    >>> from lp.bugs.tests.test_bugtask_1 import (
+    >>> from lp.bugs.model.tests.test_bugtask import (
     ...     BugTaskSearchBugsElsewhereTest)
     >>> def bugTaskInfo(bugtask):
     ...     return '%i %i %s %s' % (

=== modified file 'lib/lp/bugs/interfaces/bug.py'
--- lib/lp/bugs/interfaces/bug.py	2010-10-15 16:09:18 +0000
+++ lib/lp/bugs/interfaces/bug.py	2010-10-25 19:52:46 +0000
@@ -81,7 +81,6 @@
 from lp.bugs.interfaces.bugwatch import IBugWatch
 from lp.bugs.interfaces.cve import ICve
 from lp.code.interfaces.branchlink import IHasLinkedBranches
-from lp.registry.enum import BugNotificationLevel
 from lp.registry.interfaces.mentoringoffer import ICanBeMentored
 from lp.registry.interfaces.person import IPerson
 from lp.services.fields import (
@@ -493,12 +492,6 @@
         from duplicates.
         """
 
-    def getStructuralSubscribers(recipients=None, level=None):
-        """Return `IPerson`s subscribed to this bug's targets.
-
-        This takes into account bug subscription filters.
-        """
-
     def getSubscriptionsFromDuplicates():
         """Return IBugSubscriptions subscribed from dupes of this bug."""
 

=== modified file 'lib/lp/bugs/interfaces/bugtask.py'
--- lib/lp/bugs/interfaces/bugtask.py	2010-10-22 21:38:42 +0000
+++ lib/lp/bugs/interfaces/bugtask.py	2010-10-25 19:52:46 +0000
@@ -1524,6 +1524,12 @@
     def getOpenBugTasksPerProduct(user, products):
         """Return open bugtask count for multiple products."""
 
+    def getStructuralSubscribers(bugtasks, recipients=None, level=None):
+        """Return `IPerson`s subscribed to the given bug tasks.
+
+        This takes into account bug subscription filters.
+        """
+
 
 def valid_remote_bug_url(value):
     """Verify that the URL is to a bug to a known bug tracker."""

=== modified file 'lib/lp/bugs/model/bug.py'
--- lib/lp/bugs/model/bug.py	2010-10-19 21:30:53 +0000
+++ lib/lp/bugs/model/bug.py	2010-10-25 19:52:46 +0000
@@ -176,9 +176,6 @@
 from lp.registry.interfaces.productseries import IProductSeries
 from lp.registry.interfaces.series import SeriesStatus
 from lp.registry.interfaces.sourcepackage import ISourcePackage
-from lp.registry.interfaces.structuralsubscription import (
-    IStructuralSubscriptionTarget,
-    )
 from lp.registry.model.mentoringoffer import MentoringOffer
 from lp.registry.model.person import (
     Person,
@@ -934,8 +931,9 @@
             # XXX: RobertCollins 2010-09-22 bug=374777: This SQL(...) is a
             # hack; it does not seem to be possible to express DISTINCT ON
             # with Storm.
-            (SQL("DISTINCT ON (Person.name, BugSubscription.person) 0 AS ignore"),
-             # return people and subscribptions
+            (SQL("DISTINCT ON (Person.name, BugSubscription.person) "
+                 "0 AS ignore"),
+             # Return people and subscriptions
              Person, BugSubscription),
             # For this bug or its duplicates
             Or(
@@ -986,8 +984,8 @@
 
         # Structural subscribers.
         also_notified_subscribers.update(
-            self.getStructuralSubscribers(
-                recipients=recipients, level=level))
+            getUtility(IBugTaskSet).getStructuralSubscribers(
+                self.bugtasks, recipients=recipients, level=level))
 
         # Direct subscriptions always take precedence over indirect
         # subscriptions.
@@ -999,58 +997,6 @@
             (also_notified_subscribers - direct_subscribers),
             key=lambda x: removeSecurityProxy(x).displayname)
 
-    def getStructuralSubscribers(self, recipients=None, level=None):
-        """See `IBug`. """
-        query_arguments = []
-        for bugtask in self.bugtasks:
-            if IStructuralSubscriptionTarget.providedBy(bugtask.target):
-                query_arguments.append((bugtask.target, bugtask))
-                if bugtask.target.parent_subscription_target is not None:
-                    query_arguments.append(
-                        (bugtask.target.parent_subscription_target, bugtask))
-            if ISourcePackage.providedBy(bugtask.target):
-                # Distribution series bug tasks with a package have the source
-                # package set as their target, so we add the distroseries
-                # explicitly to the set of subscription targets.
-                query_arguments.append((bugtask.distroseries, bugtask))
-            if bugtask.milestone is not None:
-                query_arguments.append((bugtask.milestone, bugtask))
-
-        if len(query_arguments) == 0:
-            return EmptyResultSet()
-
-        if level is None:
-            # If level is not specified, default to NOTHING so that all
-            # subscriptions are found. XXX: Perhaps this should go in
-            # getSubscriptionsForBugTask()?
-            level = BugNotificationLevel.NOTHING
-
-        # Build the query.
-        union = lambda left, right: left.union(right)
-        queries = (
-            target.getSubscriptionsForBugTask(bugtask, level)
-            for target, bugtask in query_arguments)
-        subscriptions = reduce(union, queries)
-
-        # Pull all the subscriptions in.
-        subscriptions = list(subscriptions)
-
-        # Prepare a query for the subscribers.
-        subscribers = Store.of(self).find(
-            Person, Person.id.is_in(
-                subscription.subscriberID
-                for subscription in subscriptions))
-
-        if recipients is not None:
-            # We need to process subscriptions, so pull all the subscribes
-            # into the cache, then update recipients with the subscriptions.
-            subscribers = list(subscribers)
-            for subscription in subscriptions:
-                recipients.addStructuralSubscriber(
-                    subscription.subscriber, subscription.target)
-
-        return subscribers
-
     def getBugNotificationRecipients(self, duplicateof=None, old_bug=None,
                                      level=None,
                                      include_master_dupe_subscribers=False):
@@ -1541,7 +1487,6 @@
             assert IProductSeries.providedBy(target)
             productseries = target
 
-        admins = getUtility(ILaunchpadCelebrities).admin
         if not (check_permission("launchpad.BugSupervisor", target) or
                 check_permission("launchpad.Driver", target)):
             raise NominationError(

=== modified file 'lib/lp/bugs/model/bugtask.py'
--- lib/lp/bugs/model/bugtask.py	2010-10-22 19:56:26 +0000
+++ lib/lp/bugs/model/bugtask.py	2010-10-25 19:52:46 +0000
@@ -127,6 +127,7 @@
     )
 from lp.bugs.model.bugnomination import BugNomination
 from lp.bugs.model.bugsubscription import BugSubscription
+from lp.registry.enum import BugNotificationLevel
 from lp.registry.interfaces.distribution import (
     IDistribution,
     IDistributionSet,
@@ -155,6 +156,9 @@
 from lp.registry.interfaces.projectgroup import IProjectGroup
 from lp.registry.interfaces.sourcepackage import ISourcePackage
 from lp.registry.interfaces.sourcepackagename import ISourcePackageNameSet
+from lp.registry.interfaces.structuralsubscription import (
+    IStructuralSubscriptionTarget,
+    )
 from lp.registry.model.pillar import pillar_sort_key
 from lp.registry.model.sourcepackagename import SourcePackageName
 from lp.services.propertycache import IPropertyCache
@@ -1953,7 +1957,7 @@
         query = " AND ".join(extra_clauses)
 
         if not decorators:
-            decorator = lambda x:x
+            decorator = lambda x: x
         else:
             def decorator(obj):
                 for decor in decorators:
@@ -2835,3 +2839,57 @@
             counts.append(package_counts)
 
         return counts
+
+    def getStructuralSubscribers(self, bugtasks, recipients=None, level=None):
+        """See `IBugTaskSet`."""
+        query_arguments = []
+        for bugtask in bugtasks:
+            if IStructuralSubscriptionTarget.providedBy(bugtask.target):
+                query_arguments.append((bugtask.target, bugtask))
+                if bugtask.target.parent_subscription_target is not None:
+                    query_arguments.append(
+                        (bugtask.target.parent_subscription_target, bugtask))
+            if ISourcePackage.providedBy(bugtask.target):
+                # Distribution series bug tasks with a package have the source
+                # package set as their target, so we add the distroseries
+                # explicitly to the set of subscription targets.
+                query_arguments.append((bugtask.distroseries, bugtask))
+            if bugtask.milestone is not None:
+                query_arguments.append((bugtask.milestone, bugtask))
+
+        if len(query_arguments) == 0:
+            return EmptyResultSet()
+
+        if level is None:
+            # If level is not specified, default to NOTHING so that all
+            # subscriptions are found.
+            level = BugNotificationLevel.NOTHING
+
+        # Build the query.
+        union = lambda left, right: (
+            removeSecurityProxy(left).union(
+                removeSecurityProxy(right)))
+        queries = (
+            target.getSubscriptionsForBugTask(bugtask, level)
+            for target, bugtask in query_arguments)
+        subscriptions = reduce(union, queries)
+
+        # Pull all the subscriptions in.
+        subscriptions = list(subscriptions)
+
+        # Prepare a query for the subscribers.
+        from lp.registry.model.person import Person
+        subscribers = IStore(Person).find(
+            Person, Person.id.is_in(
+                removeSecurityProxy(subscription).subscriberID
+                for subscription in subscriptions))
+
+        if recipients is not None:
+            # We need to process subscriptions, so pull all the subscribes into
+            # the cache, then update recipients with the subscriptions.
+            subscribers = list(subscribers)
+            for subscription in subscriptions:
+                recipients.addStructuralSubscriber(
+                    subscription.subscriber, subscription.target)
+
+        return subscribers

=== modified file 'lib/lp/bugs/model/tests/test_bug.py'
--- lib/lp/bugs/model/tests/test_bug.py	2010-10-15 16:11:17 +0000
+++ lib/lp/bugs/model/tests/test_bug.py	2010-10-25 19:52:46 +0000
@@ -5,10 +5,7 @@
 
 __metaclass__ = type
 
-from storm.store import ResultSet
-
 from canonical.testing.layers import DatabaseFunctionalLayer
-from lp.bugs.mail.bugnotificationrecipients import BugNotificationRecipients
 from lp.registry.enum import BugNotificationLevel
 from lp.registry.interfaces.person import PersonVisibility
 from lp.registry.model.structuralsubscription import StructuralSubscription
@@ -17,7 +14,6 @@
     person_logged_in,
     TestCaseWithFactory,
     )
-from lp.testing.matchers import StartsWith
 
 
 class TestBug(TestCaseWithFactory):
@@ -246,84 +242,3 @@
         self.assertTrue(
             subscriber not in duplicate_subscribers,
             "Subscriber should not be in duplicate_subscribers.")
-
-
-class TestBugStructuralSubscribers(TestCaseWithFactory):
-
-    layer = DatabaseFunctionalLayer
-
-    def test_getStructuralSubscribers_no_subscribers(self):
-        # If there are no subscribers for any of the bug's targets then no
-        # subscribers will be returned by getStructuralSubscribers().
-        product = self.factory.makeProduct()
-        bug = self.factory.makeBug(product=product)
-        subscribers = bug.getStructuralSubscribers()
-        self.assertIsInstance(subscribers, ResultSet)
-        self.assertEqual([], list(subscribers))
-
-    def test_getStructuralSubscribers_single_target(self):
-        # Subscribers for any of the bug's targets are returned.
-        subscriber = self.factory.makePerson()
-        login_person(subscriber)
-        product = self.factory.makeProduct()
-        product.addBugSubscription(subscriber, subscriber)
-        bug = self.factory.makeBug(product=product)
-        self.assertEqual([subscriber], list(bug.getStructuralSubscribers()))
-
-    def test_getStructuralSubscribers_multiple_targets(self):
-        # Subscribers for any of the bug's targets are returned.
-        actor = self.factory.makePerson()
-        login_person(actor)
-
-        subscriber1 = self.factory.makePerson()
-        subscriber2 = self.factory.makePerson()
-
-        product1 = self.factory.makeProduct(owner=actor)
-        product1.addBugSubscription(subscriber1, subscriber1)
-        product2 = self.factory.makeProduct(owner=actor)
-        product2.addBugSubscription(subscriber2, subscriber2)
-
-        bug = self.factory.makeBug(product=product1)
-        bug.addTask(actor, product2)
-
-        subscribers = bug.getStructuralSubscribers()
-        self.assertIsInstance(subscribers, ResultSet)
-        self.assertEqual(set([subscriber1, subscriber2]), set(subscribers))
-
-    def test_getStructuralSubscribers_recipients(self):
-        # If provided, getStructuralSubscribers() calls the appropriate
-        # methods on a BugNotificationRecipients object.
-        subscriber = self.factory.makePerson()
-        login_person(subscriber)
-        product = self.factory.makeProduct()
-        product.addBugSubscription(subscriber, subscriber)
-        bug = self.factory.makeBug(product=product)
-        recipients = BugNotificationRecipients()
-        subscribers = bug.getStructuralSubscribers(recipients=recipients)
-        # The return value is a list only when populating recipients.
-        self.assertIsInstance(subscribers, list)
-        self.assertEqual([subscriber], recipients.getRecipients())
-        reason, header = recipients.getReason(subscriber)
-        self.assertThat(
-            reason, StartsWith(
-                u"You received this bug notification because "
-                u"you are subscribed to "))
-        self.assertThat(header, StartsWith(u"Subscriber "))
-
-    def test_getStructuralSubscribers_level(self):
-        # getStructuralSubscribers() respects the given level.
-        subscriber = self.factory.makePerson()
-        login_person(subscriber)
-        product = self.factory.makeProduct()
-        subscription = product.addBugSubscription(subscriber, subscriber)
-        subscription.bug_notification_level = BugNotificationLevel.METADATA
-        bug = self.factory.makeBug(product=product)
-        self.assertEqual(
-            [subscriber], list(
-                bug.getStructuralSubscribers(
-                    level=BugNotificationLevel.METADATA)))
-        subscription.bug_notification_level = BugNotificationLevel.METADATA
-        self.assertEqual(
-            [], list(
-                bug.getStructuralSubscribers(
-                    level=BugNotificationLevel.COMMENTS)))

=== renamed file 'lib/lp/bugs/tests/test_bugtask.py' => 'lib/lp/bugs/model/tests/test_bugtask.py'
--- lib/lp/bugs/tests/test_bugtask.py	2010-10-21 16:40:10 +0000
+++ lib/lp/bugs/model/tests/test_bugtask.py	2010-10-25 19:52:46 +0000
@@ -8,31 +8,52 @@
 import unittest
 
 from lazr.lifecycle.snapshot import Snapshot
+from storm.store import ResultSet
 from zope.component import getUtility
 from zope.interface import providedBy
 
+from canonical.database.sqlbase import flush_database_updates
 from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
 from canonical.launchpad.searchbuilder import (
     all,
     any,
     )
+from canonical.launchpad.webapp.interfaces import ILaunchBag
 from canonical.testing.layers import (
     DatabaseFunctionalLayer,
     LaunchpadZopelessLayer,
     )
+from lp.app.enums import ServiceUsage
+from lp.bugs.interfaces.bug import IBugSet
 from lp.bugs.interfaces.bugtarget import IBugTarget
 from lp.bugs.interfaces.bugtask import (
     BugTaskImportance,
     BugTaskSearchParams,
     BugTaskStatus,
+    IBugTaskSet,
+    IUpstreamBugTask,
+    RESOLVED_BUGTASK_STATUSES,
+    UNRESOLVED_BUGTASK_STATUSES,
     )
+from lp.bugs.interfaces.bugwatch import IBugWatchSet
+from lp.bugs.mail.bugnotificationrecipients import BugNotificationRecipients
 from lp.bugs.model.bugtask import build_tag_search_clause
+from lp.bugs.tests.bug import (
+    create_old_bug,
+    sync_bugtasks,
+    )
 from lp.hardwaredb.interfaces.hwdb import (
     HWBus,
     IHWDeviceSet,
     )
+from lp.registry.enum import BugNotificationLevel
 from lp.registry.interfaces.distribution import IDistributionSet
-from lp.registry.interfaces.person import IPerson, IPersonSet
+from lp.registry.interfaces.person import (
+    IPerson,
+    IPersonSet,
+    )
+from lp.registry.interfaces.product import IProductSet
+from lp.registry.interfaces.projectgroup import IProjectGroupSet
 from lp.testing import (
     ANONYMOUS,
     login,
@@ -42,6 +63,11 @@
     TestCase,
     TestCaseWithFactory,
     )
+from lp.testing.factory import (
+    is_security_proxied_or_harmless,
+    LaunchpadObjectFactory,
+    )
+from lp.testing.matchers import StartsWith
 
 
 class TestBugTaskDelta(TestCaseWithFactory):
@@ -892,7 +918,7 @@
         self.assertEqual(2, tasks.count())
         # Cache in the storm cache the account->person lookup so its not
         # distorting what we're testing.
-        _ = IPerson(person.account, None)
+        IPerson(person.account, None)
         # One query and only one should be issued to get the tasks, bugs and
         # allow access to getConjoinedMaster attribute - an attribute that
         # triggers a permission check (nb: id does not trigger such a check)
@@ -945,6 +971,420 @@
         self.assertEqual([task2], list(result))
 
 
+class BugTaskSearchBugsElsewhereTest(unittest.TestCase):
+    """Tests for searching bugs filtering on related bug tasks.
+
+    It also acts as a helper class, which makes related doctests more
+    readable, since they can use methods from this class.
+    """
+    layer = DatabaseFunctionalLayer
+
+    def __init__(self, methodName='runTest', helper_only=False):
+        """If helper_only is True, set up it only as a helper class."""
+        if not helper_only:
+            unittest.TestCase.__init__(self, methodName=methodName)
+
+    def setUp(self):
+        login(ANONYMOUS)
+
+    def tearDown(self):
+        logout()
+
+    def _getBugTaskByTarget(self, bug, target):
+        """Return a bug's bugtask for the given target."""
+        for bugtask in bug.bugtasks:
+            if bugtask.target == target:
+                return bugtask
+        else:
+            raise AssertionError(
+                "Didn't find a %s task on bug %s." % (
+                    target.bugtargetname, bug.id))
+
+    def setUpBugsResolvedUpstreamTests(self):
+        """Modify some bugtasks to match the resolved upstream filter."""
+        bugset = getUtility(IBugSet)
+        productset = getUtility(IProductSet)
+        firefox = productset.getByName("firefox")
+        thunderbird = productset.getByName("thunderbird")
+
+        # Mark an upstream task on bug #1 "Fix Released"
+        bug_one = bugset.get(1)
+        firefox_upstream = self._getBugTaskByTarget(bug_one, firefox)
+        self.assertEqual(
+            ServiceUsage.LAUNCHPAD,
+            firefox_upstream.product.bug_tracking_usage)
+        self.old_firefox_status = firefox_upstream.status
+        firefox_upstream.transitionToStatus(
+            BugTaskStatus.FIXRELEASED, getUtility(ILaunchBag).user)
+        self.firefox_upstream = firefox_upstream
+
+        # Mark an upstream task on bug #9 "Fix Committed"
+        bug_nine = bugset.get(9)
+        thunderbird_upstream = self._getBugTaskByTarget(bug_nine, thunderbird)
+        self.old_thunderbird_status = thunderbird_upstream.status
+        thunderbird_upstream.transitionToStatus(
+            BugTaskStatus.FIXCOMMITTED, getUtility(ILaunchBag).user)
+        self.thunderbird_upstream = thunderbird_upstream
+
+        # Add a watch to a Debian bug for bug #2, and mark the task Fix
+        # Released.
+        bug_two = bugset.get(2)
+        bugwatchset = getUtility(IBugWatchSet)
+
+        # Get a debbugs watch.
+        watch_debbugs_327452 = bugwatchset.get(9)
+        self.assertEquals(watch_debbugs_327452.bugtracker.name, "debbugs")
+        self.assertEquals(watch_debbugs_327452.remotebug, "327452")
+
+        # Associate the watch to a Fix Released task.
+        debian = getUtility(IDistributionSet).getByName("debian")
+        debian_firefox = debian.getSourcePackage("mozilla-firefox")
+        bug_two_in_debian_firefox = self._getBugTaskByTarget(
+            bug_two, debian_firefox)
+        bug_two_in_debian_firefox.bugwatch = watch_debbugs_327452
+        bug_two_in_debian_firefox.transitionToStatus(
+            BugTaskStatus.FIXRELEASED, getUtility(ILaunchBag).user)
+
+        flush_database_updates()
+
+    def tearDownBugsElsewhereTests(self):
+        """Resets the modified bugtasks to their original statuses."""
+        self.firefox_upstream.transitionToStatus(
+            self.old_firefox_status,
+            self.firefox_upstream.target.bug_supervisor)
+        self.thunderbird_upstream.transitionToStatus(
+            self.old_thunderbird_status,
+            self.firefox_upstream.target.bug_supervisor)
+        flush_database_updates()
+
+    def assertBugTaskIsPendingBugWatchElsewhere(self, bugtask):
+        """Assert the bugtask is pending a bug watch elsewhere.
+
+        Pending a bugwatch elsewhere means that at least one of the bugtask's
+        related task's target isn't using Malone, and that
+        related_bugtask.bugwatch is None.
+        """
+        non_malone_using_bugtasks = [
+            related_task for related_task in bugtask.related_tasks
+            if not related_task.target_uses_malone]
+        pending_bugwatch_bugtasks = [
+            related_bugtask for related_bugtask in non_malone_using_bugtasks
+            if related_bugtask.bugwatch is None]
+        self.assert_(
+            len(pending_bugwatch_bugtasks) > 0,
+            'Bugtask %s on %s has no related bug watches elsewhere.' % (
+                bugtask.id, bugtask.target.displayname))
+
+    def assertBugTaskIsResolvedUpstream(self, bugtask):
+        """Make sure at least one of the related upstream tasks is resolved.
+
+        "Resolved", for our purposes, means either that one of the related
+        tasks is an upstream task in FIXCOMMITTED or FIXRELEASED state, or
+        it is a task with a bugwatch, and in FIXCOMMITTED, FIXRELEASED, or
+        INVALID state.
+        """
+        resolved_upstream_states = [
+            BugTaskStatus.FIXCOMMITTED, BugTaskStatus.FIXRELEASED]
+        resolved_bugwatch_states = [
+            BugTaskStatus.FIXCOMMITTED, BugTaskStatus.FIXRELEASED,
+            BugTaskStatus.INVALID]
+
+        # Helper functions for the list comprehension below.
+        def _is_resolved_upstream_task(bugtask):
+            return (
+                IUpstreamBugTask.providedBy(bugtask) and
+                bugtask.status in resolved_upstream_states)
+
+        def _is_resolved_bugwatch_task(bugtask):
+            return (
+                bugtask.bugwatch and bugtask.status in
+                resolved_bugwatch_states)
+
+        resolved_related_tasks = [
+            related_task for related_task in bugtask.related_tasks
+            if (_is_resolved_upstream_task(related_task) or
+                _is_resolved_bugwatch_task(related_task))]
+
+        self.assert_(len(resolved_related_tasks) > 0)
+        self.assert_(
+            len(resolved_related_tasks) > 0,
+            'Bugtask %s on %s has no resolved related tasks.' % (
+                bugtask.id, bugtask.target.displayname))
+
+    def assertBugTaskIsOpenUpstream(self, bugtask):
+        """Make sure at least one of the related upstream tasks is open.
+
+        "Open", for our purposes, means either that one of the related
+        tasks is an upstream task or a task with a bugwatch which has
+        one of the states listed in open_states.
+        """
+        open_states = [
+            BugTaskStatus.NEW,
+            BugTaskStatus.INCOMPLETE,
+            BugTaskStatus.CONFIRMED,
+            BugTaskStatus.INPROGRESS,
+            BugTaskStatus.UNKNOWN]
+
+        # Helper functions for the list comprehension below.
+        def _is_open_upstream_task(bugtask):
+            return (
+                IUpstreamBugTask.providedBy(bugtask) and
+                bugtask.status in open_states)
+
+        def _is_open_bugwatch_task(bugtask):
+            return (
+                bugtask.bugwatch and bugtask.status in
+                open_states)
+
+        open_related_tasks = [
+            related_task for related_task in bugtask.related_tasks
+            if (_is_open_upstream_task(related_task) or
+                _is_open_bugwatch_task(related_task))]
+
+        self.assert_(
+            len(open_related_tasks) > 0,
+            'Bugtask %s on %s has no open related tasks.' % (
+                bugtask.id, bugtask.target.displayname))
+
+    def _hasUpstreamTask(self, bug):
+        """Does this bug have an upstream task associated with it?
+
+        Returns True if yes, otherwise False.
+        """
+        for bugtask in bug.bugtasks:
+            if IUpstreamBugTask.providedBy(bugtask):
+                return True
+        return False
+
+    def assertShouldBeShownOnNoUpstreamTaskSearch(self, bugtask):
+        """Should the bugtask be shown in the search no upstream task search?
+
+        Returns True if yes, otherwise False.
+        """
+        self.assert_(
+            not self._hasUpstreamTask(bugtask.bug),
+            'Bugtask %s on %s has upstream tasks.' % (
+                bugtask.id, bugtask.target.displayname))
+
+
+class BugTaskSetFindExpirableBugTasksTest(unittest.TestCase):
+    """Test `BugTaskSet.findExpirableBugTasks()` behaviour."""
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        """Setup the zope interaction and create expirable bugtasks."""
+        login('[e-mail]')
+        self.user = getUtility(ILaunchBag).user
+        self.distribution = getUtility(IDistributionSet).getByName('ubuntu')
+        self.distroseries = self.distribution.getSeries('hoary')
+        self.product = getUtility(IProductSet).getByName('jokosher')
+        self.productseries = self.product.getSeries('trunk')
+        self.bugtaskset = getUtility(IBugTaskSet)
+        bugtasks = []
+        bugtasks.append(
+            create_old_bug("90 days old", 90, self.distribution))
+        bugtasks.append(
+            self.bugtaskset.createTask(
+                bug=bugtasks[-1].bug, owner=self.user,
+                distroseries=self.distroseries))
+        bugtasks.append(
+            create_old_bug("90 days old", 90, self.product))
+        bugtasks.append(
+            self.bugtaskset.createTask(
+                bug=bugtasks[-1].bug, owner=self.user,
+                productseries=self.productseries))
+        sync_bugtasks(bugtasks)
+
+    def tearDown(self):
+        logout()
+
+    def testSupportedTargetParam(self):
+        """The target param supports a limited set of BugTargets.
+
+        Four BugTarget types may passed as the target argument:
+        Distribution, DistroSeries, Product, ProductSeries.
+        """
+        supported_targets = [self.distribution, self.distroseries,
+                             self.product, self.productseries]
+        for target in supported_targets:
+            expirable_bugtasks = self.bugtaskset.findExpirableBugTasks(
+                0, self.user, target=target)
+            self.assertNotEqual(expirable_bugtasks.count(), 0,
+                 "%s has %d expirable bugtasks." %
+                 (self.distroseries, expirable_bugtasks.count()))
+
+    def testUnsupportedBugTargetParam(self):
+        """Test that unsupported targets raise errors.
+
+        Three BugTarget types are not supported because the UI does not
+        provide bug-index to link to the 'bugs that can expire' page.
+        ProjectGroup, SourcePackage, and DistributionSourcePackage will
+        raise an NotImplementedError.
+
+        Passing an unknown bugtarget type will raise an AssertionError.
+        """
+        project = getUtility(IProjectGroupSet).getByName('mozilla')
+        distributionsourcepackage = self.distribution.getSourcePackage(
+            'mozilla-firefox')
+        sourcepackage = self.distroseries.getSourcePackage(
+            'mozilla-firefox')
+        unsupported_targets = [project, distributionsourcepackage,
+                               sourcepackage]
+        for target in unsupported_targets:
+            self.assertRaises(
+                NotImplementedError, self.bugtaskset.findExpirableBugTasks,
+                0, self.user, target=target)
+
+        # Objects that are not a known BugTarget type raise an AssertionError.
+        self.assertRaises(
+            AssertionError, self.bugtaskset.findExpirableBugTasks,
+            0, self.user, target=[])
+
+
+class BugTaskSetTest(unittest.TestCase):
+    """Test `BugTaskSet` methods."""
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        login(ANONYMOUS)
+
+    def test_getBugTasks(self):
+        """ IBugTaskSet.getBugTasks() returns a dictionary mapping the given
+        bugs to their bugtasks. It does that in a single query, to avoid
+        hitting the DB again when getting the bugs' tasks.
+        """
+        login('[e-mail]')
+        factory = LaunchpadObjectFactory()
+        bug1 = factory.makeBug()
+        factory.makeBugTask(bug1)
+        bug2 = factory.makeBug()
+        factory.makeBugTask(bug2)
+        factory.makeBugTask(bug2)
+
+        bugs_and_tasks = getUtility(IBugTaskSet).getBugTasks(
+            [bug1.id, bug2.id])
+        # The bugtasks returned by getBugTasks() are exactly the same as the
+        # ones returned by bug.bugtasks, obviously.
+        self.failUnlessEqual(
+            set(bugs_and_tasks[bug1]).difference(bug1.bugtasks),
+            set([]))
+        self.failUnlessEqual(
+            set(bugs_and_tasks[bug2]).difference(bug2.bugtasks),
+            set([]))
+
+    def test_getBugTasks_with_empty_list(self):
+        # When given an empty list of bug IDs, getBugTasks() will return an
+        # empty dictionary.
+        bugs_and_tasks = getUtility(IBugTaskSet).getBugTasks([])
+        self.failUnlessEqual(bugs_and_tasks, {})
+
+
+class TestBugTaskStatuses(TestCase):
+
+    def test_open_and_resolved_statuses(self):
+        """
+        There are constants that are used to define which statuses are for
+        resolved bugs (`RESOLVED_BUGTASK_STATUSES`), and which are for
+        unresolved bugs (`UNRESOLVED_BUGTASK_STATUSES`). The two constants
+        include all statuses defined in BugTaskStatus, except for Unknown.
+        """
+        self.assertNotIn(BugTaskStatus.UNKNOWN, RESOLVED_BUGTASK_STATUSES)
+        self.assertNotIn(BugTaskStatus.UNKNOWN, UNRESOLVED_BUGTASK_STATUSES)
+
+
+class TestGetStructuralSubscribers(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def make_product_with_bug(self):
+        product = self.factory.makeProduct()
+        bug = self.factory.makeBug(product=product)
+        return product, bug
+
+    def getStructuralSubscribers(self, bugtasks, *args, **kwargs):
+        # Call IBugTaskSet.getStructuralSubscribers() and check that the
+        # result is security proxied.
+        result = getUtility(IBugTaskSet).getStructuralSubscribers(
+            bugtasks, *args, **kwargs)
+        self.assertTrue(is_security_proxied_or_harmless(result))
+        return result
+
+    def test_getStructuralSubscribers_no_subscribers(self):
+        # If there are no subscribers for any of the bug's targets then no
+        # subscribers will be returned by getStructuralSubscribers().
+        product, bug = self.make_product_with_bug()
+        subscribers = self.getStructuralSubscribers(bug.bugtasks)
+        self.assertIsInstance(subscribers, ResultSet)
+        self.assertEqual([], list(subscribers))
+
+    def test_getStructuralSubscribers_single_target(self):
+        # Subscribers for any of the bug's targets are returned.
+        subscriber = self.factory.makePerson()
+        login_person(subscriber)
+        product, bug = self.make_product_with_bug()
+        product.addBugSubscription(subscriber, subscriber)
+        self.assertEqual(
+            [subscriber], list(
+                self.getStructuralSubscribers(bug.bugtasks)))
+
+    def test_getStructuralSubscribers_multiple_targets(self):
+        # Subscribers for any of the bug's targets are returned.
+        actor = self.factory.makePerson()
+        login_person(actor)
+
+        subscriber1 = self.factory.makePerson()
+        subscriber2 = self.factory.makePerson()
+
+        product1 = self.factory.makeProduct(owner=actor)
+        product1.addBugSubscription(subscriber1, subscriber1)
+        product2 = self.factory.makeProduct(owner=actor)
+        product2.addBugSubscription(subscriber2, subscriber2)
+
+        bug = self.factory.makeBug(product=product1)
+        bug.addTask(actor, product2)
+
+        subscribers = self.getStructuralSubscribers(bug.bugtasks)
+        self.assertIsInstance(subscribers, ResultSet)
+        self.assertEqual(set([subscriber1, subscriber2]), set(subscribers))
+
+    def test_getStructuralSubscribers_recipients(self):
+        # If provided, getStructuralSubscribers() calls the appropriate
+        # methods on a BugNotificationRecipients object.
+        subscriber = self.factory.makePerson()
+        login_person(subscriber)
+        product, bug = self.make_product_with_bug()
+        product.addBugSubscription(subscriber, subscriber)
+        recipients = BugNotificationRecipients()
+        subscribers = self.getStructuralSubscribers(
+            bug.bugtasks, recipients=recipients)
+        # The return value is a list only when populating recipients.
+        self.assertIsInstance(subscribers, list)
+        self.assertEqual([subscriber], recipients.getRecipients())
+        reason, header = recipients.getReason(subscriber)
+        self.assertThat(
+            reason, StartsWith(
+                u"You received this bug notification because "
+                u"you are subscribed to "))
+        self.assertThat(header, StartsWith(u"Subscriber "))
+
+    def test_getStructuralSubscribers_level(self):
+        # getStructuralSubscribers() respects the given level.
+        subscriber = self.factory.makePerson()
+        login_person(subscriber)
+        product, bug = self.make_product_with_bug()
+        subscription = product.addBugSubscription(subscriber, subscriber)
+        subscription.bug_notification_level = BugNotificationLevel.METADATA
+        self.assertEqual(
+            [subscriber], list(
+                self.getStructuralSubscribers(
+                    bug.bugtasks, level=BugNotificationLevel.METADATA)))
+        subscription.bug_notification_level = BugNotificationLevel.METADATA
+        self.assertEqual(
+            [], list(
+                self.getStructuralSubscribers(
+                    bug.bugtasks, level=BugNotificationLevel.COMMENTS)))
+
+
 def test_suite():
     suite = unittest.TestSuite()
     suite.addTest(unittest.TestLoader().loadTestsFromName(__name__))

=== renamed file 'lib/lp/bugs/tests/test_bugtask_status.py' => 'lib/lp/bugs/model/tests/test_bugtask_status.py'
=== modified file 'lib/lp/bugs/stories/bugs/xx-bugs-advanced-search-upstream-status.txt'
--- lib/lp/bugs/stories/bugs/xx-bugs-advanced-search-upstream-status.txt	2010-10-18 22:24:59 +0000
+++ lib/lp/bugs/stories/bugs/xx-bugs-advanced-search-upstream-status.txt	2010-10-25 19:52:46 +0000
@@ -17,7 +17,7 @@
 
 Now if we go to the advanced search and choose to list only the bugs
 needing a bug watch, only the bugs with tasks in other contexts that
-don't use Launchpad Bugs are shown, if at least one of those contexts 
+don't use Launchpad Bugs are shown, if at least one of those contexts
 doesn't have a bug watch.
 
     # XXX: Bjorn Tillenius 2006-07-04 bug=51853:
@@ -97,7 +97,7 @@
 demonstrate.
 
     >>> from canonical.launchpad.ftests import login, logout
-    >>> from lp.bugs.tests.test_bugtask_1 import (
+    >>> from lp.bugs.model.tests.test_bugtask import (
     ...     BugTaskSearchBugsElsewhereTest)
     >>> test_helper = BugTaskSearchBugsElsewhereTest(helper_only=True)
     >>> login('[e-mail]')
@@ -181,8 +181,8 @@
        linux-source-2.6.15 Medium New
     2 Blackhole Trash folder
       — Medium New
- 
-The user opens a bookmark for "upstream status: Show only bugs that need 
+
+The user opens a bookmark for "upstream status: Show only bugs that need
 to be forwarded to an upstream bug tracker".
 
     >>> bookmark_params['field.status_upstream'] = 'pending_bugwatch'
@@ -225,7 +225,7 @@
     ...         bookmark_params, True))
     Traceback (most recent call last):
     ...
-    UnexpectedFormData: Unexpected value for field 'status_upstream'. 
+    UnexpectedFormData: Unexpected value for field 'status_upstream'.
     Perhaps your bookmarks are out of date or you changed the URL by hand?
 
 

=== modified file 'lib/lp/bugs/subscribers/bug.py'
--- lib/lp/bugs/subscribers/bug.py	2010-08-23 09:25:17 +0000
+++ lib/lp/bugs/subscribers/bug.py	2010-10-25 19:52:46 +0000
@@ -19,6 +19,8 @@
 import datetime
 from operator import attrgetter
 
+from zope.component import getUtility
+
 from canonical.config import config
 from canonical.database.sqlbase import block_implicit_flushes
 from canonical.launchpad.helpers import get_contact_email_addresses
@@ -34,14 +36,12 @@
     )
 from lp.bugs.adapters.bugdelta import BugDelta
 from lp.bugs.interfaces.bugchange import IBugChange
+from lp.bugs.interfaces.bugtask import IBugTaskSet
 from lp.bugs.mail.bugnotificationbuilder import BugNotificationBuilder
 from lp.bugs.mail.bugnotificationrecipients import BugNotificationRecipients
 from lp.bugs.mail.newbug import generate_bug_add_email
 from lp.registry.enum import BugNotificationLevel
 from lp.registry.interfaces.person import IPerson
-from lp.registry.interfaces.structuralsubscription import (
-    IStructuralSubscriptionTarget,
-    )
 
 
 @block_implicit_flushes
@@ -179,15 +179,10 @@
         if recipients is not None:
             recipients.addAssignee(bugtask.assignee)
 
-    if IStructuralSubscriptionTarget.providedBy(bugtask.target):
-        also_notified_subscribers.update(
-            bugtask.target.getBugNotificationsRecipients(
-                recipients, level=level))
-
-    if bugtask.milestone is not None:
-        also_notified_subscribers.update(
-            bugtask.milestone.getBugNotificationsRecipients(
-                recipients, level=level))
+    # Get structural subscribers.
+    also_notified_subscribers.update(
+        getUtility(IBugTaskSet).getStructuralSubscribers(
+            [bugtask], recipients, level))
 
     # If the target's bug supervisor isn't set,
     # we add the owner as a subscriber.

=== removed file 'lib/lp/bugs/tests/test_bugtask_0.py'
--- lib/lp/bugs/tests/test_bugtask_0.py	2010-10-21 04:19:36 +0000
+++ lib/lp/bugs/tests/test_bugtask_0.py	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-# Copyright 2009 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-"""Tests for bugtask.py."""
-
-__metaclass__ = type
-
-from doctest import (
-    DocTestSuite,
-    ELLIPSIS,
-    NORMALIZE_WHITESPACE,
-    REPORT_NDIFF,
-    )
-
-
-def test_open_and_resolved_statuses(self):
-    """
-    There are constants that are used to define which statuses are for
-    resolved bugs (RESOLVED_BUGTASK_STATUSES), and which are for
-    unresolved bugs (UNRESOLVED_BUGTASK_STATUSES). The two constants
-    include all statuses defined in BugTaskStatus, except for Unknown.
-
-        >>> from lp.bugs.interfaces.bugtask import (
-        ...     BugTaskStatus, RESOLVED_BUGTASK_STATUSES,
-        ...     UNRESOLVED_BUGTASK_STATUSES)
-        >>> not_included_status = set(BugTaskStatus.items).difference(
-        ...     RESOLVED_BUGTASK_STATUSES + UNRESOLVED_BUGTASK_STATUSES)
-        >>> [status.name for status in not_included_status]
-        ['UNKNOWN']
-    """
-
-
-def test_suite():
-    suite = DocTestSuite(
-        optionflags=REPORT_NDIFF|NORMALIZE_WHITESPACE|ELLIPSIS)
-    return suite

=== removed file 'lib/lp/bugs/tests/test_bugtask_1.py'
--- lib/lp/bugs/tests/test_bugtask_1.py	2010-10-21 12:43:32 +0000
+++ lib/lp/bugs/tests/test_bugtask_1.py	1970-01-01 00:00:00 +0000
@@ -1,345 +0,0 @@
-# Copyright 2009-2010 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-"""Bugtask related tests that are too complex to be readable as doctests."""
-
-__metaclass__ = type
-
-import unittest
-
-from zope.component import getUtility
-
-from canonical.database.sqlbase import flush_database_updates
-from canonical.launchpad.ftests import (
-    ANONYMOUS,
-    login,
-    logout,
-    )
-from canonical.launchpad.webapp.interfaces import ILaunchBag
-from canonical.testing.layers import DatabaseFunctionalLayer
-from lp.app.enums import ServiceUsage
-from lp.bugs.interfaces.bug import IBugSet
-from lp.bugs.interfaces.bugtask import (
-    BugTaskStatus,
-    IBugTaskSet,
-    IUpstreamBugTask,
-    )
-from lp.bugs.interfaces.bugwatch import IBugWatchSet
-from lp.bugs.tests.bug import (
-    create_old_bug,
-    sync_bugtasks,
-    )
-from lp.registry.interfaces.distribution import IDistributionSet
-from lp.registry.interfaces.product import IProductSet
-from lp.registry.interfaces.projectgroup import IProjectGroupSet
-from lp.testing.factory import LaunchpadObjectFactory
-
-
-class BugTaskSearchBugsElsewhereTest(unittest.TestCase):
-    """Tests for searching bugs filtering on related bug tasks.
-
-    It also acts as a helper class, which makes related doctests more
-    readable, since they can use methods from this class.
-    """
-    layer = DatabaseFunctionalLayer
-
-    def __init__(self, methodName='runTest', helper_only=False):
-        """If helper_only is True, set up it only as a helper class."""
-        if not helper_only:
-            unittest.TestCase.__init__(self, methodName=methodName)
-
-    def setUp(self):
-        login(ANONYMOUS)
-
-    def tearDown(self):
-        logout()
-
-    def _getBugTaskByTarget(self, bug, target):
-        """Return a bug's bugtask for the given target."""
-        for bugtask in bug.bugtasks:
-            if bugtask.target == target:
-                return bugtask
-        else:
-            raise AssertionError(
-                "Didn't find a %s task on bug %s." % (
-                    target.bugtargetname, bug.id))
-
-    def setUpBugsResolvedUpstreamTests(self):
-        """Modify some bugtasks to match the resolved upstream filter."""
-        bugset = getUtility(IBugSet)
-        productset = getUtility(IProductSet)
-        firefox = productset.getByName("firefox")
-        thunderbird = productset.getByName("thunderbird")
-
-        # Mark an upstream task on bug #1 "Fix Released"
-        bug_one = bugset.get(1)
-        firefox_upstream = self._getBugTaskByTarget(bug_one, firefox)
-        self.assertEqual(
-            ServiceUsage.LAUNCHPAD,
-            firefox_upstream.product.bug_tracking_usage)
-        self.old_firefox_status = firefox_upstream.status
-        firefox_upstream.transitionToStatus(
-            BugTaskStatus.FIXRELEASED, getUtility(ILaunchBag).user)
-        self.firefox_upstream = firefox_upstream
-
-        # Mark an upstream task on bug #9 "Fix Committed"
-        bug_nine = bugset.get(9)
-        thunderbird_upstream = self._getBugTaskByTarget(bug_nine, thunderbird)
-        self.old_thunderbird_status = thunderbird_upstream.status
-        thunderbird_upstream.transitionToStatus(
-            BugTaskStatus.FIXCOMMITTED, getUtility(ILaunchBag).user)
-        self.thunderbird_upstream = thunderbird_upstream
-
-        # Add a watch to a Debian bug for bug #2, and mark the task Fix
-        # Released.
-        bug_two = bugset.get(2)
-        current_user = getUtility(ILaunchBag).user
-        bugtaskset = getUtility(IBugTaskSet)
-        bugwatchset = getUtility(IBugWatchSet)
-
-        # Get a debbugs watch.
-        watch_debbugs_327452 = bugwatchset.get(9)
-        self.assertEquals(watch_debbugs_327452.bugtracker.name, "debbugs")
-        self.assertEquals(watch_debbugs_327452.remotebug, "327452")
-
-        # Associate the watch to a Fix Released task.
-        debian = getUtility(IDistributionSet).getByName("debian")
-        debian_firefox = debian.getSourcePackage("mozilla-firefox")
-        bug_two_in_debian_firefox = self._getBugTaskByTarget(
-            bug_two, debian_firefox)
-        bug_two_in_debian_firefox.bugwatch = watch_debbugs_327452
-        bug_two_in_debian_firefox.transitionToStatus(
-            BugTaskStatus.FIXRELEASED, getUtility(ILaunchBag).user)
-
-        flush_database_updates()
-
-    def tearDownBugsElsewhereTests(self):
-        """Resets the modified bugtasks to their original statuses."""
-        self.firefox_upstream.transitionToStatus(
-            self.old_firefox_status,
-            self.firefox_upstream.target.bug_supervisor)
-        self.thunderbird_upstream.transitionToStatus(
-            self.old_thunderbird_status,
-            self.firefox_upstream.target.bug_supervisor)
-        flush_database_updates()
-
-    def assertBugTaskIsPendingBugWatchElsewhere(self, bugtask):
-        """Assert the bugtask is pending a bug watch elsewhere.
-
-        Pending a bugwatch elsewhere means that at least one of the bugtask's
-        related task's target isn't using Malone, and that
-        related_bugtask.bugwatch is None.
-        """
-        non_malone_using_bugtasks = [
-            related_task for related_task in bugtask.related_tasks
-            if not related_task.target_uses_malone]
-        pending_bugwatch_bugtasks = [
-            related_bugtask for related_bugtask in non_malone_using_bugtasks
-            if related_bugtask.bugwatch is None]
-        self.assert_(
-            len(pending_bugwatch_bugtasks) > 0,
-            'Bugtask %s on %s has no related bug watches elsewhere.' % (
-                bugtask.id, bugtask.target.displayname))
-
-    def assertBugTaskIsResolvedUpstream(self, bugtask):
-        """Make sure at least one of the related upstream tasks is resolved.
-
-        "Resolved", for our purposes, means either that one of the related
-        tasks is an upstream task in FIXCOMMITTED or FIXRELEASED state, or
-        it is a task with a bugwatch, and in FIXCOMMITTED, FIXRELEASED, or
-        INVALID state.
-        """
-        resolved_upstream_states = [
-            BugTaskStatus.FIXCOMMITTED, BugTaskStatus.FIXRELEASED]
-        resolved_bugwatch_states = [
-            BugTaskStatus.FIXCOMMITTED, BugTaskStatus.FIXRELEASED,
-            BugTaskStatus.INVALID]
-
-        # Helper functions for the list comprehension below.
-        def _is_resolved_upstream_task(bugtask):
-            return (
-                IUpstreamBugTask.providedBy(bugtask) and
-                bugtask.status in resolved_upstream_states)
-
-        def _is_resolved_bugwatch_task(bugtask):
-            return (
-                bugtask.bugwatch and bugtask.status in
-                resolved_bugwatch_states)
-
-        resolved_related_tasks = [
-            related_task for related_task in bugtask.related_tasks
-            if (_is_resolved_upstream_task(related_task) or
-                _is_resolved_bugwatch_task(related_task))]
-
-        self.assert_(len(resolved_related_tasks) > 0)
-        self.assert_(
-            len(resolved_related_tasks) > 0,
-            'Bugtask %s on %s has no resolved related tasks.' % (
-                bugtask.id, bugtask.target.displayname))
-
-    def assertBugTaskIsOpenUpstream(self, bugtask):
-        """Make sure at least one of the related upstream tasks is open.
-
-        "Open", for our purposes, means either that one of the related
-        tasks is an upstream task or a task with a bugwatch which has
-        one of the states listed in open_states.
-        """
-        open_states = [
-            BugTaskStatus.NEW,
-            BugTaskStatus.INCOMPLETE,
-            BugTaskStatus.CONFIRMED,
-            BugTaskStatus.INPROGRESS,
-            BugTaskStatus.UNKNOWN]
-
-        # Helper functions for the list comprehension below.
-        def _is_open_upstream_task(bugtask):
-            return (
-                IUpstreamBugTask.providedBy(bugtask) and
-                bugtask.status in open_states)
-
-        def _is_open_bugwatch_task(bugtask):
-            return (
-                bugtask.bugwatch and bugtask.status in
-                open_states)
-
-        open_related_tasks = [
-            related_task for related_task in bugtask.related_tasks
-            if (_is_open_upstream_task(related_task) or
-                _is_open_bugwatch_task(related_task))]
-
-        self.assert_(
-            len(open_related_tasks) > 0,
-            'Bugtask %s on %s has no open related tasks.' % (
-                bugtask.id, bugtask.target.displayname))
-
-    def _hasUpstreamTask(self, bug):
-        """Does this bug have an upstream task associated with it?
-
-        Returns True if yes, otherwise False.
-        """
-        for bugtask in bug.bugtasks:
-            if IUpstreamBugTask.providedBy(bugtask):
-                return True
-        return False
-
-    def assertShouldBeShownOnNoUpstreamTaskSearch(self, bugtask):
-        """Should the bugtask be shown in the search no upstream task search?
-
-        Returns True if yes, otherwise False.
-        """
-        self.assert_(
-            not self._hasUpstreamTask(bugtask.bug),
-            'Bugtask %s on %s has upstream tasks.' % (
-                bugtask.id, bugtask.target.displayname))
-
-
-class BugTaskSetFindExpirableBugTasksTest(unittest.TestCase):
-    """Test `BugTaskSet.findExpirableBugTasks()` behaviour."""
-    layer = DatabaseFunctionalLayer
-
-    def setUp(self):
-        """Setup the zope interaction and create expirable bugtasks."""
-        login('[e-mail]')
-        self.user = getUtility(ILaunchBag).user
-        self.distribution = getUtility(IDistributionSet).getByName('ubuntu')
-        self.distroseries = self.distribution.getSeries('hoary')
-        self.product = getUtility(IProductSet).getByName('jokosher')
-        self.productseries = self.product.getSeries('trunk')
-        self.bugtaskset = getUtility(IBugTaskSet)
-        bugtasks = []
-        bugtasks.append(
-            create_old_bug("90 days old", 90, self.distribution))
-        bugtasks.append(
-            self.bugtaskset.createTask(
-                bug=bugtasks[-1].bug, owner=self.user,
-                distroseries=self.distroseries))
-        bugtasks.append(
-            create_old_bug("90 days old", 90, self.product))
-        bugtasks.append(
-            self.bugtaskset.createTask(
-                bug=bugtasks[-1].bug, owner=self.user,
-                productseries=self.productseries))
-        sync_bugtasks(bugtasks)
-
-    def tearDown(self):
-        logout()
-
-    def testSupportedTargetParam(self):
-        """The target param supports a limited set of BugTargets.
-
-        Four BugTarget types may passed as the target argument:
-        Distribution, DistroSeries, Product, ProductSeries.
-        """
-        supported_targets = [self.distribution, self.distroseries,
-                             self.product, self.productseries]
-        for target in supported_targets:
-            expirable_bugtasks = self.bugtaskset.findExpirableBugTasks(
-                0, self.user, target=target)
-            self.assertNotEqual(expirable_bugtasks.count(), 0,
-                 "%s has %d expirable bugtasks." %
-                 (self.distroseries, expirable_bugtasks.count()))
-
-    def testUnsupportedBugTargetParam(self):
-        """Test that unsupported targets raise errors.
-
-        Three BugTarget types are not supported because the UI does not
-        provide bug-index to link to the 'bugs that can expire' page.
-        ProjectGroup, SourcePackage, and DistributionSourcePackage will
-        raise an NotImplementedError.
-
-        Passing an unknown bugtarget type will raise an AssertionError.
-        """
-        project = getUtility(IProjectGroupSet).getByName('mozilla')
-        distributionsourcepackage = self.distribution.getSourcePackage(
-            'mozilla-firefox')
-        sourcepackage = self.distroseries.getSourcePackage(
-            'mozilla-firefox')
-        unsupported_targets = [project, distributionsourcepackage,
-                               sourcepackage]
-        for target in unsupported_targets:
-            self.assertRaises(
-                NotImplementedError, self.bugtaskset.findExpirableBugTasks,
-                0, self.user, target=target)
-
-        # Objects that are not a known BugTarget type raise an AssertionError.
-        self.assertRaises(
-            AssertionError, self.bugtaskset.findExpirableBugTasks,
-            0, self.user, target=[])
-
-
-class BugTaskSetTest(unittest.TestCase):
-    """Test `BugTaskSet` methods."""
-    layer = DatabaseFunctionalLayer
-
-    def setUp(self):
-        login(ANONYMOUS)
-
-    def test_getBugTasks(self):
-        """ IBugTaskSet.getBugTasks() returns a dictionary mapping the given
-        bugs to their bugtasks. It does that in a single query, to avoid
-        hitting the DB again when getting the bugs' tasks.
-        """
-        login('[e-mail]')
-        factory = LaunchpadObjectFactory()
-        bug1 = factory.makeBug()
-        factory.makeBugTask(bug1)
-        bug2 = factory.makeBug()
-        factory.makeBugTask(bug2)
-        factory.makeBugTask(bug2)
-
-        bugs_and_tasks = getUtility(IBugTaskSet).getBugTasks(
-            [bug1.id, bug2.id])
-        # The bugtasks returned by getBugTasks() are exactly the same as the
-        # ones returned by bug.bugtasks, obviously.
-        self.failUnlessEqual(
-            set(bugs_and_tasks[bug1]).difference(bug1.bugtasks),
-            set([]))
-        self.failUnlessEqual(
-            set(bugs_and_tasks[bug2]).difference(bug2.bugtasks),
-            set([]))
-
-    def test_getBugTasks_with_empty_list(self):
-        # When given an empty list of bug IDs, getBugTasks() will return an
-        # empty dictionary.
-        bugs_and_tasks = getUtility(IBugTaskSet).getBugTasks([])
-        self.failUnlessEqual(bugs_and_tasks, {})

=== modified file 'lib/lp/registry/doc/structural-subscriptions.txt'
--- lib/lp/registry/doc/structural-subscriptions.txt	2010-10-17 15:44:08 +0000
+++ lib/lp/registry/doc/structural-subscriptions.txt	2010-10-25 19:52:46 +0000
@@ -86,117 +86,6 @@
 When notifying subscribers of bug activity, both subscribers to the
 target and to the target's parent are notified.
 
-    >>> from canonical.launchpad.ftests import syncUpdate
-    >>> from lp.registry.enum import BugNotificationLevel
-    >>> from lp.registry.interfaces.structuralsubscription import BlueprintNotificationLevel
-    >>> from lp.bugs.mail.bugnotificationrecipients import (
-    ...     BugNotificationRecipients)
-
-We define some utility functions for printing out bug subscriptions and
-the recipients for the notifications they generate.
-
-    >>> def print_bug_subscribers(bug_subscribers):
-    ...     subscriber_names = sorted(subscriber.name
-    ...                               for subscriber in bug_subscribers)
-    ...     for name in subscriber_names:
-    ...         print name
-    >>> def print_bug_subscriptions(bug_subscriptions):
-    ...     for subscription in bug_subscriptions:
-    ...         print subscription.subscriber.name
-    >>> def print_bug_recipients(recipients):
-    ...     for recipient in recipients:
-    ...         reason = recipients.getReason(recipient)
-    ...         print '%s "%s"' % (recipient.name, reason[1])
-
-Sample person has a subscription to Ubuntu and to the Evolution package
-in Ubuntu. We set the bug notification level for both subscriptions.
-
-    >>> ubuntu_sub.bug_notification_level = BugNotificationLevel.COMMENTS
-    >>> evolution_sub.bug_notification_level = BugNotificationLevel.COMMENTS
-
-`getBugNotificationsRecipients` returns all the bug subscribers to the
-target and its parent, and adds the rationale for the subscriptions to
-the recipients set. Each subscriber is only added once.
-
-    >>> recipients = BugNotificationRecipients()
-    >>> bug_subscribers = evolution_package.getBugNotificationsRecipients(
-    ...     recipients=recipients)
-    >>> print_bug_subscriptions(ubuntu.bug_subscriptions)
-    name12
-    >>> print_bug_subscriptions(evolution_package.bug_subscriptions)
-    name12
-    >>> print_bug_subscribers(bug_subscribers)
-    name12
-    >>> print_bug_recipients(recipients)
-    name12 "Subscriber (evolution in ubuntu)"
-
-Foo Bar subscribes to Ubuntu.
-
-    >>> login('[e-mail]')
-    >>> foobar_subscription = ubuntu.addBugSubscription(foobar, foobar)
-    >>> recipients = BugNotificationRecipients()
-
-The set of subscribers to the evolution package for ubuntu now includes
-both subscribers to the package, and subscribers to the distribution.
-
-    >>> bug_subscribers = evolution_package.getBugNotificationsRecipients(
-    ...     recipients=recipients)
-    >>> print_bug_recipients(recipients)
-    name16 "Subscriber (Ubuntu)"
-    name12 "Subscriber (evolution in ubuntu)"
-
-We can pass the parameter `level` to getBugNotificationsRecipients().
-Subscribers whose subscription level is lower than the given parameter
-are not returned.
-
-    >>> foobar_subscription.bug_notification_level = (
-    ...     BugNotificationLevel.METADATA)
-    >>> recipients = BugNotificationRecipients()
-    >>> bug_subscribers = evolution_package.getBugNotificationsRecipients(
-    ...     recipients=recipients, level=BugNotificationLevel.COMMENTS)
-    >>> print_bug_recipients(recipients)
-    name12 "Subscriber (evolution in ubuntu)"
-
-We remove Sample Person's bug subscription to the package.
-
-    >>> evolution_sub.blueprint_notification_level = (
-    ...     BlueprintNotificationLevel.METADATA)
-    >>> evolution_package.removeBugSubscription(sampleperson, sampleperson)
-    >>> ubuntu.removeBugSubscription(sampleperson, sampleperson)
-    >>> syncUpdate(evolution_sub)
-
-Sample Person is no longer a subscriber to the package, but Foo Bar
-is still a subscriber, by being subscribed to Ubuntu.
-
-    >>> print_bug_subscribers(
-    ...     evolution_package.getBugNotificationsRecipients(
-    ...         recipients=recipients))
-    name16
-
-A project is the parent of each of its products.
-
-Fireox does not have any subscribers.
-
-    >>> print_bug_subscribers(firefox.getBugNotificationsRecipients())
-
-Mozilla is the parent of Fireox.
-
-    >>> from lp.registry.interfaces.projectgroup import IProjectGroupSet
-    >>> mozilla = getUtility(IProjectGroupSet).getByName('mozilla')
-    >>> print firefox.parent_subscription_target.displayname
-    the Mozilla Project
-
-Foobar subscribes to bug notificatios for Mozilla.
-
-    >>> mozilla.addBugSubscription(foobar, foobar)
-    <StructuralSubscription at ...>
-
-As a result of subscribing to Mozilla, Foobar is now a subscriber of
-Firefox.
-
-    >>> print_bug_subscribers(firefox.getBugNotificationsRecipients())
-    name16
-
 
 Target type display
 ===================

=== modified file 'lib/lp/registry/interfaces/structuralsubscription.py'
--- lib/lp/registry/interfaces/structuralsubscription.py	2010-10-07 10:06:55 +0000
+++ lib/lp/registry/interfaces/structuralsubscription.py	2010-10-25 19:52:46 +0000
@@ -181,20 +181,6 @@
     def getSubscription(person):
         """Return the subscription for `person`, if it exists."""
 
-    def getBugNotificationsRecipients(recipients=None, level=None):
-        """Return the set of bug subscribers to this target.
-
-        :param recipients: If recipients is not None, a rationale
-            is added for each subscriber.
-        :type recipients: `INotificationRecipientSet`
-        'param level: If level is not None, only strucutral
-            subscribers with a subscrition level greater or equal
-            to the given value are returned.
-        :type level: `BugNotificationLevel`
-        :return: An `INotificationRecipientSet` instance containing
-            the bug subscribers.
-        """
-
     target_type_display = Attribute("The type of the target, for display.")
 
     def userHasBugSubscriptions(user):

=== modified file 'lib/lp/registry/model/structuralsubscription.py'
--- lib/lp/registry/model/structuralsubscription.py	2010-10-07 10:06:55 +0000
+++ lib/lp/registry/model/structuralsubscription.py	2010-10-25 19:52:46 +0000
@@ -448,24 +448,6 @@
         return StructuralSubscription.select(
             query, orderBy='Person.displayname', clauseTables=['Person'])
 
-    def getBugNotificationsRecipients(self, recipients=None, level=None):
-        """See `IStructuralSubscriptionTarget`."""
-        if level is None:
-            subscriptions = self.bug_subscriptions
-        else:
-            subscriptions = self.getSubscriptions(
-                min_bug_notification_level=level)
-        subscribers = set(
-            subscription.subscriber for subscription in subscriptions)
-        if recipients is not None:
-            for subscriber in subscribers:
-                recipients.addStructuralSubscriber(subscriber, self)
-        parent = self.parent_subscription_target
-        if parent is not None:
-            subscribers.update(
-                parent.getBugNotificationsRecipients(recipients, level))
-        return subscribers
-
     @property
     def bug_subscriptions(self):
         """See `IStructuralSubscriptionTarget`."""