Merge lp:~julian-edwards/launchpad/sync-close-bugs-bug-833736 into lp:launchpad

[Julian Edwards]

[r=julian-edwards][bug=833736] When closing bugs on package syncs, fix a bug that prevented closing bugs in a different distroseries source package to the original upload distroseries on the sourcepackagerelease.

Fix an additional bug in the original branch that prevented closure of bugs that are in a different distroseries package to the original uploaded distroseries.

=== modified file 'lib/lp/soyuz/interfaces/archive.py'
--- lib/lp/soyuz/interfaces/archive.py	2011-08-30 14:54:57 +0000
+++ lib/lp/soyuz/interfaces/archive.py	2011-09-06 10:47:26 +0000
@@ -1245,17 +1245,15 @@
     @operation_for_version('devel')
     def copyPackages(source_names, from_archive, to_pocket, person,
                      to_series=None, include_binaries=False):
-        """Atomically copy named sources into this archive from another.
+        """Copy multiple named sources into this archive from another.
 
         Asynchronously copy the most recent PUBLISHED versions of the named
         sources to the destination archive if necessary.  Calls to this
         method will return immediately if the copy passes basic security
         checks and the copy will happen sometime later with full checking.
 
-        This operation will only succeed when all requested packages
-        are synchronised between the archives. If any of the requested
-        copies cannot be performed, the whole operation will fail. There
-        will be no partial changes of the destination archive.
+        Partial changes of the destination archive can happen because each
+        source is copied in its own transaction.
 
         :param source_names: a list of string names of packages to copy.
         :param from_archive: the source archive from which to copy.
 
=== modified file 'lib/lp/soyuz/scripts/processaccepted.py'
--- lib/lp/soyuz/scripts/processaccepted.py	2011-08-31 11:58:28 +0000
+++ lib/lp/soyuz/scripts/processaccepted.py	2011-09-06 10:47:26 +0000
@@ -164,11 +164,13 @@
     changesfile_object = sourcepackagerelease.upload_changesfile
 
     close_bugs_for_sourcepackagerelease(
-        sourcepackagerelease, changesfile_object, since_version)
+        sourcepackagerelease, changesfile_object, since_version,
+        upload_distroseries=source_publication.distroseries)
 
 
 def close_bugs_for_sourcepackagerelease(source_release, changesfile_object,
-                                        since_version=None):
+                                        since_version=None,
+                                        upload_distroseries=None):
     """Close bugs for a given source.
 
     Given a `ISourcePackageRelease` and a corresponding changesfile object,
@@ -203,10 +205,13 @@
         # here, BE CAREFUL with the unproxied bug object and look at
         # what you're doing with it that might violate security.
         bug = removeSecurityProxy(bug)
+        if upload_distroseries is not None:
+            target = upload_distroseries.getSourcePackage(
+                source_release.sourcepackagename)
+        else:
+            target = source_release.sourcepackage
         edited_task = bug.setStatus(
-            target=source_release.sourcepackage,
-            status=BugTaskStatus.FIXRELEASED,
-            user=janitor)
+            target=target, status=BugTaskStatus.FIXRELEASED, user=janitor)
         if edited_task is not None:
             assert source_release.changelog_entry is not None, (
                 "New source uploads should have a changelog.")
 
=== modified file 'lib/lp/soyuz/scripts/tests/test_processaccepted.py'
--- lib/lp/soyuz/scripts/tests/test_processaccepted.py	2011-08-29 17:02:01 +0000
+++ lib/lp/soyuz/scripts/tests/test_processaccepted.py	2011-09-06 10:47:26 +0000
@@ -8,8 +8,10 @@
 
 from canonical.testing.layers import LaunchpadZopelessLayer
 from lp.bugs.interfaces.bugtask import BugTaskStatus
+from lp.registry.interfaces.pocket import PackagePublishingPocket
 from lp.soyuz.scripts.processaccepted import (
     close_bugs_for_sourcepackagerelease,
+    close_bugs_for_sourcepublication,
     )
 from lp.testing import TestCaseWithFactory
 
@@ -27,28 +29,30 @@
     """
     layer = LaunchpadZopelessLayer
 
-    def test_close_bugs_for_sourcepackagerelease_with_no_changes_file(self):
-        # If there's no changes file it should read the changelog_entry on
-        # the sourcepackagerelease.
-
-        spr = self.factory.makeSourcePackageRelease(changelog_entry="blah")
-
+    def makeChangelogWithBugs(self, spr, target_series=None):
+        """Create a changelog for the passed sourcepackagerelease that has
+        6 bugs referenced.
+
+        :param spr: The sourcepackagerelease that needs a changelog.
+        :param target_distro: the distribution context for the source package
+            bug target.  If None, default to its uploaded distribution.
+
+        :return: A tuple which is a list of (bug, bugtask)
+        """
         # Make 4 bugs and corresponding bugtasks and put them in an array
         # as tuples.
         bugs = []
-        for i in range(5):
+        for i in range(6):
+            if target_series is None:
+                target = spr.sourcepackage
+            else:
+                target = target_series.getSourcePackage(spr.sourcepackagename)
             bug = self.factory.makeBug()
-            bugtask = self.factory.makeBugTask(
-                target=spr.sourcepackage, bug=bug)
+            bugtask = self.factory.makeBugTask(target=target, bug=bug)
             bugs.append((bug, bugtask))
-
-        unfixed_bug = self.factory.makeBug()
-        unfixed_task = self.factory.makeBugTask(
-            target=spr.sourcepackage, bug=unfixed_bug)
-
         # Make a changelog entry for a package which contains the IDs of
-        # the 5 bugs separated across 2 releases.
-        changelog=dedent("""
+        # the 6 bugs separated across 3 releases.
+        changelog = dedent("""
             foo (1.0-3) unstable; urgency=low
 
               * closes: %s, %s
@@ -74,18 +78,53 @@
             bugs[2][0].id,
             bugs[3][0].id,
             bugs[4][0].id,
-            unfixed_bug.id,
+            bugs[5][0].id,
             ))
         lfa = self.factory.makeLibraryFileAlias(content=changelog)
-
         removeSecurityProxy(spr).changelog = lfa
         self.layer.txn.commit()
+        return bugs
+
+    def test_close_bugs_for_sourcepackagerelease_with_no_changes_file(self):
+        # If there's no changes file it should read the changelog_entry on
+        # the sourcepackagerelease.
+
+        spr = self.factory.makeSourcePackageRelease(changelog_entry="blah")
+        bugs = self.makeChangelogWithBugs(spr)
 
         # Call the method and test it's closed the bugs.
         close_bugs_for_sourcepackagerelease(spr, changesfile_object=None,
                                             since_version="1.0-1")
         for bug, bugtask in bugs:
+            if bug.id != bugs[5][0].id:
+                self.assertEqual(BugTaskStatus.FIXRELEASED, bugtask.status)
+            else:
+                self.assertEqual(BugTaskStatus.NEW, bugtask.status)
+
+    def test__close_bugs_for_sourcepublication__uses_right_distro(self):
+        # If a source was originally uploaded to a different distro,
+        # closing bugs based on a publication of the same source in a new
+        # distro should work.
+
+        # Create a source package that was originally uploaded to one
+        # distro and publish it in a second distro.
+        spr = self.factory.makeSourcePackageRelease(changelog_entry="blah")
+        target_distro = self.factory.makeDistribution()
+        target_distroseries = self.factory.makeDistroSeries(target_distro)
+        bugs = self.makeChangelogWithBugs(
+            spr, target_series=target_distroseries)
+        target_spph = self.factory.makeSourcePackagePublishingHistory(
+            sourcepackagerelease=spr, distroseries=target_distroseries,
+            archive=target_distro.main_archive,
+            pocket=PackagePublishingPocket.RELEASE)
+
+        # The test depends on this pre-condition.
+        self.assertNotEqual(spr.upload_distroseries.distribution,
+                            target_distroseries.distribution)
+
+        close_bugs_for_sourcepublication(target_spph, since_version="1.0")
+
+        for bug, bugtask in bugs:
             self.assertEqual(BugTaskStatus.FIXRELEASED, bugtask.status)
 
-        self.assertEqual(BugTaskStatus.NEW, unfixed_task.status)