Merge lp:~henninge/launchpad/devel-710591-importer into lp:launchpad

[Henning Eggers]

= Summary =

This is the final branch to fix bug 710591. It brings together
the functions and methods that the previous two introduced.

== Proposed fix ==

Add a boolean property to FileImporter that makes use
has_upstream_template to determine which "accept" method to
use.
Replace the use of "approve" in the importer with the
"accept" mtethods.

== Pre-implementation notes ==

I still refer to my chat with Danilo about this but also
Jeroen and I talked a bit while he reviewed the last
branch.

== Implementation details ==

Pretty straight forward implementation, I'd say.

== Tests ==

bin/test -vvcm lp.translations.utilities.tests.test_file_importer

I also ran this to check that anything related to "import" might
be affected:

bin/test -vvcm lp.translations -t import

== Demo and Q/A ==

Import on a source package and see what happens.

= Launchpad lint =

Checking for conflicts and issues in changed files.

Linting changed files:
  lib/lp/translations/interfaces/translationmessage.py
  lib/lp/translations/tests/test_translationmessage.py
  lib/lp/testing/factory.py
  lib/lp/translations/utilities/tests/test_file_importer.py
  lib/lp/translations/model/potmsgset.py
  lib/lp/translations/utilities/translation_import.py
  lib/lp/translations/model/translationmessage.py

./lib/lp/translations/tests/test_translationmessage.py
     365: E302 expected 2 blank lines, found 1

[Henning Eggers (henninge)]

Hi Ian,
thanks for the approval of the previous branch. I am requesting r-c for this final branch for the same bug, even though it did not have a code review yet just to make you aware of it.
Cheers,
Henning

[Ian Booth (wallyworld)]

Approved so long as the formal code review is ok and it's fully QAed as soon as possible after deployment to qastaging.

review: Approve (release-critical)

[Jeroen T. Vermeulen (jtv)]

Beautiful.

In accordance to my personal prove-you're-really-reading-it policy, I managed to find one very very minor thing to comment on:

107 + # - The by_maintainer flag must be set.

You may want to mention where this flag is (on the import-queue entry), since it's not where the reader would be most likely to look for it. You could say something like "the translation must come from an upload with the by_maintainer flag set."

Jeroen

review: Approve (code)

=== modified file 'lib/lp/registry/model/distribution.py'
--- lib/lp/registry/model/distribution.py	2011-02-09 19:25:43 +0000
+++ lib/lp/registry/model/distribution.py	2011-02-11 14:44:33 +0000
@@ -205,6 +205,9 @@
     HasTranslationImportsMixin,
     )
 from lp.translations.model.translationpolicy import TranslationPolicyMixin
+from lp.translations.utilities.translationsharinginfo import (
+    has_upstream_template,
+    )
 
 
 class Distribution(SQLBase, BugTargetBase, MakesAnnouncements,
@@ -1845,11 +1848,11 @@
         assert sourcepackage is not None, (
             "Translations sharing policy requires a SourcePackage.")
 
-        sharing_productseries = sourcepackage.productseries
-        if sharing_productseries is None:
-            # There is no known upstream series.  Take the uploader's
-            # word for whether these are upstream translations (in which
-            # case they're shared) or not.
+        if not has_upstream_template(
+                sourcepackage.distroseries, sourcepackage.sourcepackagename):
+            # There is no known upstream template or series.  Take the
+            # uploader's word for whether these are upstream translations
+            # (in which case they're shared) or not.
             # What are the consequences if that value is incorrect?  In
             # the case where translations from upstream are purportedly
             # from Ubuntu, we miss a chance at sharing when the package
@@ -1861,7 +1864,7 @@
             # translations for upstream.
             return purportedly_upstream
 
-        upstream_product = sharing_productseries.product
+        upstream_product = sourcepackage.productseries.product
         return upstream_product.invitesTranslationEdits(person, language)
 
 
 
=== modified file 'lib/lp/translations/model/potmsgset.py'
--- lib/lp/translations/model/potmsgset.py	2011-02-04 17:14:20 +0000
+++ lib/lp/translations/model/potmsgset.py	2011-02-11 14:44:33 +0000
@@ -796,11 +796,12 @@
             template, pofile.language, template.translation_side)
         other = self.getOtherTranslation(
             pofile.language, template.translation_side)
-        if other is not None:
-            other.is_current_upstream = False
-        if current is None or other is None:
+        if current is None or other is None or current == other:
             translator = suggestion.submitter
             potranslations = dictify_translations(suggestion.all_msgstrs)
+            if other is not None:
+                # Steal flag beforehand.
+                other.is_current_upstream = False
             self._setTranslation(
                 pofile, translator, suggestion.origin, potranslations,
                 share_with_other_side=True,
@@ -808,8 +809,9 @@
                 lock_timestamp=lock_timestamp)
         else:
             # Make it only current in upstream.
-            suggestion.is_current_upstream = True
             if suggestion != other:
+                other.is_current_upstream = False
+                suggestion.is_current_upstream = True
                 pofile.markChanged(translator=suggestion.submitter)
 
     def _cloneAndDiverge(self, original_message, pofile):
 
=== added file 'lib/lp/translations/scripts/upload_translations.py'
--- lib/lp/translations/scripts/upload_translations.py	1970-01-01 00:00:00 +0000
+++ lib/lp/translations/scripts/upload_translations.py	2011-02-11 14:44:33 +0000
@@ -0,0 +1,96 @@
+# Copyright 2011 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+__metaclass__ = type
+
+__all__ = [
+    'UploadPackageTranslations',
+    ]
+
+import os
+
+from zope.component import getUtility
+
+from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
+from lp.registry.interfaces.sourcepackagename import ISourcePackageNameSet
+from lp.services.scripts.base import (
+    LaunchpadScript,
+    LaunchpadScriptFailure,
+    )
+from lp.translations.interfaces.translationimportqueue import (
+    ITranslationImportQueue,
+    )
+
+
+class UploadPackageTranslations(LaunchpadScript):
+    """Upload translations for given distribution package."""
+    description = "Upload translation files for a package."
+
+    def add_my_options(self):
+        """See `LaunchpadScript`."""
+        self.parser.add_option('-d', '--distribution', dest='distro',
+            help="Distribution to upload for.", default='ubuntu')
+        self.parser.add_option('-s', '--series', dest='distroseries',
+            help="Distribution release series to upload for.")
+        self.parser.add_option('-p', '--package', dest='package',
+            help="Name of source package to upload to.")
+        self.parser.add_option('-l', '--dry-run', dest='dryrun',
+            action='store_true', default=False,
+            help="Pretend to upload, but make no actual changes.")
+
+    def main(self):
+        """See `LaunchpadScript`."""
+        self._setDistroDetails()
+        self._setPackage()
+
+        if self.options.dryrun:
+            self.logger.info("Dry run.  Not really uploading anything.")
+
+        queue = getUtility(ITranslationImportQueue)
+        rosetta_team = getUtility(ILaunchpadCelebrities).rosetta_experts
+
+        for filename in self.args:
+            if not os.access(filename, os.R_OK):
+                self.logger.info("Skipping: %s" % filename)
+                continue
+            self.logger.info("Uploading: %s." % filename)
+            content = open(filename).read()
+            queue.addOrUpdateEntry(
+                filename, content, True, rosetta_team,
+                sourcepackagename = self.sourcepackagename,
+                distroseries = self.distroseries)
+            self._commit()
+
+        self.logger.info("Done.")
+
+    def _commit(self):
+        """Commit transaction (or abort if dry run)."""
+        if self.txn:
+            if self.options.dryrun:
+                self.txn.abort()
+            else:
+                self.txn.commit()
+
+    def _setDistroDetails(self):
+        """Figure out the `Distribution`/`DistroSeries` to act upon."""
+        # Avoid circular imports.
+        from lp.registry.interfaces.distribution import IDistributionSet
+
+        distroset = getUtility(IDistributionSet)
+        self.distro = distroset.getByName(self.options.distro)
+
+        if not self.options.distroseries:
+            raise LaunchpadScriptFailure(
+                "Specify a distribution release series.")
+
+        self.distroseries = self.distro.getSeries(self.options.distroseries)
+
+    def _setPackage(self):
+        """Find `SourcePackage` of given name."""
+        # Avoid circular imports.
+        if not self.options.package:
+            raise LaunchpadScriptFailure("No package specified.")
+
+        nameset = getUtility(ISourcePackageNameSet)
+
+        self.sourcepackagename = nameset.queryByName(self.options.package)
 
=== modified file 'lib/lp/translations/tests/test_translationmessage.py'
--- lib/lp/translations/tests/test_translationmessage.py	2011-02-04 18:04:14 +0000
+++ lib/lp/translations/tests/test_translationmessage.py	2011-02-11 14:44:33 +0000
@@ -362,6 +362,7 @@
 
         self.assertEqual([], karmarecorder.karma_events)
 
+
 class TestAcceptFromUpstreamImportOnPackage(TestCaseWithFactory):
     """Tests for `TranslationMessage.acceptFromUpstreamImportOnPackage`.
 
@@ -371,100 +372,199 @@
 
     layer = ZopelessDatabaseLayer
 
+    def _getStates(self, *messages):
+        """Get is_current_* states for messages.
+
+        :param messages: A list of messages to get state for.
+        :returns: List of tuples of two boolean values for the
+            values of (is_current_ubuntu, is_current_upstream) for each
+            message.
+        """
+        return [
+            (message.is_current_ubuntu, message.is_current_upstream)
+            for message in messages]
+
+    def _makeMessages(self, pofile,
+                      identical_ubuntu=None, identical_upstream=None,
+                      is_tracking=False):
+        """ Create a suggestion and possible pre-existing translations.
+
+        The two identical_* parameters are tri-state:
+        - If None, do not create such a message.
+        - If True, the suggestion is identical to this message.
+        - If False, the suggestion is different from this message.
+
+        :param pofile: The pofile to create messages in.
+        :param identical_ubuntu: If and how to create the ubuntu message.
+        :param identical upstream: If and how to create the upstream
+            message.
+        :param is_trackging: Used if both messages are created to indicate
+            that they should be identical to each other.
+        :returns: One, two or three messages, as requested.
+        """
+        ubuntu = None
+        upstream = None
+
+        potmsgset = self.factory.makePOTMsgSet(potemplate=pofile.potemplate)
+
+        if identical_upstream is not None:
+            upstream = self.factory.makeCurrentTranslationMessage(
+                potmsgset=potmsgset, pofile=pofile, current_other=True)
+            upstream.is_current_ubuntu = False
+        if identical_ubuntu is not None:
+            if is_tracking or (identical_ubuntu and identical_upstream):
+                assert upstream is not None, (
+                    "Don't use is_tracking without identical_upstream")
+                upstream.is_current_ubuntu = True
+                ubuntu = upstream
+            else:
+                ubuntu = self.factory.makeCurrentTranslationMessage(
+                        potmsgset=potmsgset, pofile=pofile)
+        if identical_upstream:
+            translations = upstream.translations
+        elif identical_ubuntu:
+            translations = ubuntu.translations
+        else:
+            translations = None
+        suggestion = self.factory.makeSuggestion(
+            pofile=pofile, potmsgset=potmsgset, translations=translations)
+
+        return [message for message in (suggestion, ubuntu, upstream)
+                        if message is not None]
+
     def test_accept_activates_message_if_untranslated(self):
         # An untranslated message accepts an imported translation.
         pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
-        suggestion = self.factory.makeSuggestion(pofile=pofile)
-        reviewer = self.factory.makePerson()
-        self.assertFalse(suggestion.is_current_ubuntu)
-        self.assertFalse(suggestion.is_current_upstream)
+        suggestion = self._makeMessages(pofile)[0]
 
         suggestion.acceptFromUpstreamImportOnPackage(pofile)
 
         # Messages are always accepted on the other side, too.
-        self.assertTrue(suggestion.is_current_ubuntu)
-        self.assertTrue(suggestion.is_current_upstream)
+        self.assertEqual([(True, True)], self._getStates(suggestion))
 
     def test_accept_no_previously_imported(self):
         # If there was already a current translation, but no previously
         # imported one, it is disabled when a suggestion is accepted.
-        pofile, potmsgset = self.factory.makePOFileAndPOTMsgSet(
-            side=TranslationSide.UBUNTU)
-        suggestion = self.factory.makeSuggestion(
-            pofile=pofile, potmsgset=potmsgset)
-        incumbent_message = self.factory.makeCurrentTranslationMessage(
-            pofile=pofile, potmsgset=potmsgset)
-
-        self.assertTrue(incumbent_message.is_current_ubuntu)
-        self.assertFalse(suggestion.is_current_ubuntu)
-
-        suggestion.acceptFromUpstreamImportOnPackage(pofile)
-
-        self.assertFalse(incumbent_message.is_current_ubuntu)
-        self.assertTrue(suggestion.is_current_ubuntu)
-        # Messages are always accepted on the other side, too.
-        self.assertTrue(suggestion.is_current_upstream)
+        pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
+        (suggestion, incumbent_message) = self._makeMessages(
+            pofile, identical_ubuntu=False)
+
+        suggestion.acceptFromUpstreamImportOnPackage(pofile)
+
+        self.assertEqual(
+            [(True, True), (False, False)],
+            self._getStates(suggestion, incumbent_message))
+
+    def test_accept_upstream_no_ubuntu(self):
+        # If there was already an upstream translation, but no ubuntu
+        # one, the suggestion replaces both.
+        pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
+        (suggestion, upstream_message) = self._makeMessages(
+            pofile, identical_upstream=False)
+
+        suggestion.acceptFromUpstreamImportOnPackage(pofile)
+
+        self.assertEqual(
+            [(True, True), (False, False)],
+            self._getStates(suggestion, upstream_message))
 
     def test_accept_previously_imported(self):
-        # If there was already a current translation, and a previously
-        # imported one, the current translation is left untouched.
-        pofile, potmsgset = self.factory.makePOFileAndPOTMsgSet(
-            side=TranslationSide.UBUNTU)
-        imported_message = self.factory.makeCurrentTranslationMessage(
-            pofile=pofile, potmsgset=potmsgset, current_other=True)
-        imported_message.is_current_ubuntu = False
-
-        suggestion = self.factory.makeSuggestion(
-            pofile=pofile, potmsgset=potmsgset)
-        incumbent_message = self.factory.makeCurrentTranslationMessage(
-            pofile=pofile, potmsgset=potmsgset)
-
-        self.assertTrue(incumbent_message.is_current_ubuntu)
-        self.assertFalse(suggestion.is_current_ubuntu)
-        self.assertTrue(imported_message.is_current_upstream)
-
-        suggestion.acceptFromUpstreamImportOnPackage(pofile)
-
-        self.assertTrue(incumbent_message.is_current_ubuntu)
-        self.assertFalse(suggestion.is_current_ubuntu)
-        # Messages are always accepted on the other side, too.
-        self.assertFalse(imported_message.is_current_upstream)
-        self.assertTrue(suggestion.is_current_upstream)
-
-    def test_accept_current_message(self):
-        # Accepting a message that's already current does nothing on this
-        # side but makes sure the other side's flag is set.
-        pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
-        translation = self.factory.makeCurrentTranslationMessage(
-            pofile=pofile)
-        self.assertTrue(translation.is_current_ubuntu)
-        self.assertFalse(translation.is_current_upstream)
-
-        translation.acceptFromUpstreamImportOnPackage(pofile)
-
-        self.assertTrue(translation.is_current_ubuntu)
-        self.assertTrue(translation.is_current_upstream)
-
-    def test_accept_current_and_imported_message(self):
+        # If there was already an ubuntu translation, and an upstream
+        # one, the ubuntu translation is left untouched.
+        pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
+        (suggestion, ubuntu_message, upstream_message) = self._makeMessages(
+            pofile, identical_ubuntu=False, identical_upstream=False)
+
+        suggestion.acceptFromUpstreamImportOnPackage(pofile)
+
+        # The suggestion is accepted as the upstream translation.
+        self.assertEqual(
+            [(False, True), (True, False), (False, False)],
+            self._getStates(suggestion, ubuntu_message, upstream_message))
+
+    def test_accept_previously_imported_tracking(self):
+        # If there was already an ubuntu translation, and an identical
+        # upstream one, the new suggestion replaces both.
+        pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
+        (suggestion, ubuntu_message, upstream_message) = self._makeMessages(
+            pofile, identical_ubuntu=False, identical_upstream=False,
+            is_tracking=True)
+
+        suggestion.acceptFromUpstreamImportOnPackage(pofile)
+
+        self.assertEqual(
+            [(True, True), (False, False), (False, False)],
+            self._getStates(suggestion, ubuntu_message, upstream_message))
+
+    def test_accept_different_upstream(self):
+        # If there was already an identcal ubuntu translation, and a
+        # different upstream one, the new suggestion will become both.
+        pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
+        (suggestion, ubuntu_message, upstream_message) = self._makeMessages(
+            pofile, identical_ubuntu=True, identical_upstream=False)
+
+        suggestion.acceptFromUpstreamImportOnPackage(pofile)
+
+        self.assertEqual(
+            [(True, True), (True, True), (False, False)],
+            self._getStates(suggestion, ubuntu_message, upstream_message))
+
+    def test_accept_different_ubuntu(self):
+        # If there was already an identcal upstream translation, and a
+        # different ubuntu one, the ubuntu translation is not touched.
+        pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
+        (suggestion, ubuntu_message, upstream_message) = self._makeMessages(
+            pofile, identical_ubuntu=False, identical_upstream=True)
+
+        suggestion.acceptFromUpstreamImportOnPackage(pofile)
+
+        self.assertEqual(
+            [(False, True), (True, False), (False, True)],
+            self._getStates(suggestion, ubuntu_message, upstream_message))
+
+    def test_accept_ubuntu_message(self):
+        # Accepting a message that's identical to the ubuntu message makes
+        # sure that the message also becomes current upstream.
+        pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
+        (suggestion, ubuntu_message) = self._makeMessages(
+            pofile, identical_ubuntu=True)
+
+        suggestion.acceptFromUpstreamImportOnPackage(pofile)
+
+        self.assertEqual(
+            [(True, True), (True, True)],
+            self._getStates(suggestion, ubuntu_message))
+
+    def test_accept_upstream_message(self):
+        # Accepting a message that's identical to the upstream message makes
+        # sure that the message also becomes current in ubuntu.
+        pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
+        (suggestion, upstream_message) = self._makeMessages(
+            pofile, identical_upstream=True)
+
+        suggestion.acceptFromUpstreamImportOnPackage(pofile)
+
+        self.assertEqual(
+            [(True, True), (True, True)],
+            self._getStates(suggestion, upstream_message))
+
+    def test_accept_ubuntu_and_upstream_message(self):
         # Accepting a message that's already current and was also imported
         # does nothing.
         pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
-        translation = self.factory.makeCurrentTranslationMessage(
-            pofile=pofile, current_other=True)
-        self.assertTrue(translation.is_current_ubuntu)
-        self.assertTrue(translation.is_current_upstream)
-
-        translation.acceptFromUpstreamImportOnPackage(pofile)
-
-        self.assertTrue(translation.is_current_ubuntu)
-        self.assertTrue(translation.is_current_upstream)
+        (suggestion, ubuntu_message, upstream_message) = self._makeMessages(
+            pofile, identical_ubuntu=True, identical_upstream=True)
+
+        suggestion.acceptFromUpstreamImportOnPackage(pofile)
+
+        self.assertEqual(
+            [(True, True), (True, True), (True, True)],
+            self._getStates(suggestion, ubuntu_message, upstream_message))
 
     def test_accept_detects_conflict(self):
         pofile = self.factory.makePOFile(side=TranslationSide.UBUNTU)
-        current = self.factory.makeCurrentTranslationMessage(pofile=pofile)
-        potmsgset = current.potmsgset
-        suggestion = self.factory.makeSuggestion(
-            pofile=pofile, potmsgset=potmsgset)
+        (suggestion, ubuntu_message) = self._makeMessages(
+            pofile, identical_ubuntu=False)
         old = datetime.now(UTC) - timedelta(days=1)
 
         self.assertRaises(
 
=== modified file 'lib/lp/translations/tests/test_translationpolicy.py'
--- lib/lp/translations/tests/test_translationpolicy.py	2010-11-10 05:04:16 +0000
+++ lib/lp/translations/tests/test_translationpolicy.py	2011-02-11 14:44:33 +0000
@@ -379,33 +379,63 @@
         self.user = self.factory.makePerson()
         self.language = self.factory.makeLanguage()
 
-    def _doesPackageShare(self, sourcepackage, from_upstream=False):
+    def _doesPackageShare(self, sourcepackage, by_maintainer=False):
         """Does this `SourcePackage` share with upstream?"""
         distro = sourcepackage.distroseries.distribution
         return distro.sharesTranslationsWithOtherSide(
             self.user, self.language, sourcepackage=sourcepackage,
-            purportedly_upstream=from_upstream)
+            purportedly_upstream=by_maintainer)
 
     def test_product_always_shares(self):
         product = self.factory.makeProduct()
         self.assertTrue(
             product.sharesTranslationsWithOtherSide(self.user, self.language))
 
-    def test_distribution_shares_only_if_invited(self):
+    def _makePackageAndProductSeries(self):
         package = self.factory.makeSourcePackage()
         self.factory.makePackagingLink(
             sourcepackagename=package.sourcepackagename,
             distroseries=package.distroseries)
-        product = package.productseries.product
+        return (package, package.productseries)
+
+    def test_distribution_shares_only_if_invited_with_template(self):
+        # With an upstream template, translations will be shared if the
+        # product invites edits.
+        package, productseries = self._makePackageAndProductSeries()
+        product = productseries.product
+        self.factory.makePOTemplate(productseries=productseries)
 
         product.translationpermission = TranslationPermission.OPEN
         self.assertTrue(self._doesPackageShare(package))
         product.translationpermission = TranslationPermission.CLOSED
         self.assertFalse(self._doesPackageShare(package))
 
-    def test_unlinked_package_shares_only_upstream_translations(self):
+    def test_distribution_shares_not_without_template(self):
+        # Without an upstream template, translations will not be shared
+        # if they do not originate from uploads done by the maintainer.
+        package, productseries = self._makePackageAndProductSeries()
+        product = productseries.product
+
+        product.translationpermission = TranslationPermission.OPEN
+        self.assertFalse(self._doesPackageShare(package))
+        product.translationpermission = TranslationPermission.CLOSED
+        self.assertFalse(self._doesPackageShare(package))
+
+    def test_distribution_shares_only_by_maintainer_without_template(self):
+        # Without an upstream template, translations will be shared
+        # if they do originate from uploads done by the maintainer.
+        package, productseries = self._makePackageAndProductSeries()
+        product = productseries.product
+
+        product.translationpermission = TranslationPermission.OPEN
+        self.assertTrue(self._doesPackageShare(package, by_maintainer=True))
+        product.translationpermission = TranslationPermission.CLOSED
+        self.assertTrue(self._doesPackageShare(package, by_maintainer=True))
+
+    def test_distribution_shares_only_by_maintainer_without_upstream(self):
+        # Without an upstream product series, translations will only be
+        # shared if they do originate from uploads done by the maintainer.
         package = self.factory.makeSourcePackage()
-        distro = package.distroseries.distribution
-        for from_upstream in [False, True]:
+        for by_maintainer in [False, True]:
             self.assertEqual(
-                from_upstream, self._doesPackageShare(package, from_upstream))
+                by_maintainer, self._doesPackageShare(package, by_maintainer))
 
=== modified file 'lib/lp/translations/utilities/tests/test_file_importer.py'
--- lib/lp/translations/utilities/tests/test_file_importer.py	2011-01-24 15:51:18 +0000
+++ lib/lp/translations/utilities/tests/test_file_importer.py	2011-02-11 14:44:33 +0000
@@ -11,7 +11,6 @@
 from zope.component import getUtility
 from zope.security.proxy import removeSecurityProxy
 
-from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
 from canonical.librarian.testing.fake import FakeLibrarian
 from canonical.testing import (
     LaunchpadZopelessLayer,
@@ -21,6 +20,7 @@
 from lp.testing import TestCaseWithFactory
 from lp.translations.enums import TranslationPermission
 from lp.translations.interfaces.potemplate import IPOTemplateSet
+from lp.translations.interfaces.side import TranslationSide
 from lp.translations.interfaces.translationfileformat import (
     TranslationFileFormat,
     )
@@ -582,9 +582,6 @@
     """Class test for the sharing operation of the FileImporter base class."""
     layer = LaunchpadZopelessLayer
 
-    UPSTREAM = 0
-    UBUNTU = 1
-
     POFILE = dedent("""\
         msgid ""
         msgstr ""
@@ -612,18 +609,15 @@
 
     def _makeImportEntry(self, side, by_maintainer=False, uploader=None,
                          no_upstream=False):
-        if side == self.UPSTREAM:
+        if side == TranslationSide.UPSTREAM:
             potemplate = self.upstream_template
         else:
             # Create a template in a source package.
-            ubuntu = getUtility(ILaunchpadCelebrities).ubuntu
-            distroseries = self.factory.makeDistroSeries(distribution=ubuntu)
-            ubuntu.translation_focus = distroseries
-            sourcepackagename = self.factory.makeSourcePackageName()
             potemplate = self.factory.makePOTemplate(
-                distroseries=distroseries,
-                sourcepackagename=sourcepackagename,
-                name=self.upstream_template.name)
+                name=self.upstream_template.name, side=side)
+            distroseries = potemplate.distroseries
+            sourcepackagename = potemplate.sourcepackagename
+            distroseries.distribution.translation_focus = distroseries
             if not no_upstream:
                 # Link the source package to the upstream series to
                 # enable sharing.
@@ -657,7 +651,7 @@
 
     def test_makeImportEntry_templates_are_sharing(self):
         # Sharing between upstream and Ubuntu was set up correctly.
-        entry = self._makeImportEntry(self.UBUNTU)
+        entry = self._makeImportEntry(TranslationSide.UBUNTU)
         subset = getUtility(IPOTemplateSet).getSharingSubset(
                 distribution=entry.distroseries.distribution,
                 sourcepackagename=entry.sourcepackagename)
@@ -667,7 +661,7 @@
 
     def test_share_with_other_side_upstream(self):
         # An upstream queue entry will be shared with ubuntu.
-        entry = self._makeImportEntry(self.UPSTREAM)
+        entry = self._makeImportEntry(TranslationSide.UPSTREAM)
         importer = POFileImporter(
             entry, importers[TranslationFileFormat.PO], None)
         self.assertTrue(
@@ -676,7 +670,7 @@
 
     def test_share_with_other_side_ubuntu(self):
         # An ubuntu queue entry will not be shared with upstream.
-        entry = self._makeImportEntry(self.UBUNTU)
+        entry = self._makeImportEntry(TranslationSide.UBUNTU)
         importer = POFileImporter(
             entry, importers[TranslationFileFormat.PO], None)
         self.assertFalse(
@@ -685,7 +679,8 @@
 
     def test_share_with_other_side_ubuntu_no_upstream(self):
         # An ubuntu queue entry cannot share with a non-existent upstream.
-        entry = self._makeImportEntry(self.UBUNTU, no_upstream=True)
+        entry = self._makeImportEntry(
+            TranslationSide.UBUNTU, no_upstream=True)
         importer = POFileImporter(
             entry, importers[TranslationFileFormat.PO], None)
         self.assertFalse(
@@ -696,9 +691,75 @@
         # If the uploader in ubuntu has rights on upstream as well, the
         # translations are shared.
         entry = self._makeImportEntry(
-            self.UBUNTU, uploader=self.translator.translator)
+            TranslationSide.UBUNTU, uploader=self.translator.translator)
         importer = POFileImporter(
             entry, importers[TranslationFileFormat.PO], None)
         self.assertTrue(
             importer.share_with_other_side,
             "Ubuntu import should share with upstream.")
+
+    def test_is_upstream_import_on_sourcepackage_none(self):
+        # To do an upstream import on a sourcepackage, three conditions must
+        # be met.
+        # - It has to be on a sourcepackage.
+        # - The by_maintainer flag must be set on the queue entry.
+        # - There must be no matching template in the upstream project or
+        #   even no upstream project at all.
+        # This case meets none of them.
+        entry = self._makeImportEntry(
+            TranslationSide.UPSTREAM, uploader=self.translator.translator)
+        importer = POFileImporter(
+            entry, importers[TranslationFileFormat.PO], None)
+        self.assertFalse(importer.is_upstream_import_on_sourcepackage)
+
+    def test_is_upstream_import_on_sourcepackage_by_maintainer(self):
+        # This entry is by_maintainer.
+        entry = self._makeImportEntry(
+            TranslationSide.UPSTREAM, by_maintainer=True,
+            uploader=self.translator.translator)
+        importer = POFileImporter(
+            entry, importers[TranslationFileFormat.PO], None)
+        self.assertFalse(importer.is_upstream_import_on_sourcepackage)
+
+    def test_is_upstream_import_on_sourcepackage_upstream_template(self):
+        # This entry is for a sourcepackage with an upstream potemplate.
+        entry = self._makeImportEntry(
+            TranslationSide.UBUNTU, uploader=self.translator.translator)
+        importer = POFileImporter(
+            entry, importers[TranslationFileFormat.PO], None)
+        self.assertFalse(importer.is_upstream_import_on_sourcepackage)
+
+    def test_is_upstream_import_on_sourcepackage_upstream_any_template(self):
+        # Actually any upstream potemplate will disallow upstream imports.
+
+        # Use _makeImportEntry to create upstream template and packaging
+        # link.
+        unused_entry = self._makeImportEntry(
+            TranslationSide.UBUNTU, uploader=self.translator.translator)
+
+        sourcepackagename = unused_entry.sourcepackagename
+        distroseries = unused_entry.distroseries
+        other_potemplate = self.factory.makePOTemplate(
+            distroseries=distroseries, sourcepackagename=sourcepackagename)
+
+        entry = self.factory.makeTranslationImportQueueEntry(
+            potemplate=other_potemplate, by_maintainer=True,
+            uploader=self.translator.translator, content=self.POFILE)
+        entry.potemplate = other_potemplate
+        entry.pofile = self.factory.makePOFile(potemplate=other_potemplate)
+        transaction.commit()
+
+        importer = POFileImporter(
+            entry, importers[TranslationFileFormat.PO], None)
+
+        self.assertFalse(importer.is_upstream_import_on_sourcepackage)
+
+    def test_is_upstream_import_on_sourcepackage_ok(self):
+        # This entry qualifies.
+        entry = self._makeImportEntry(
+            TranslationSide.UBUNTU, by_maintainer=True, no_upstream=True,
+            uploader=self.translator.translator)
+        importer = POFileImporter(
+            entry, importers[TranslationFileFormat.PO], None)
+        self.assertTrue(importer.is_upstream_import_on_sourcepackage)
+
 
=== modified file 'lib/lp/translations/utilities/tests/test_translation_sharing_info.py'
--- lib/lp/translations/utilities/tests/test_translation_sharing_info.py	2011-02-03 18:40:36 +0000
+++ lib/lp/translations/utilities/tests/test_translation_sharing_info.py	2011-02-11 14:44:33 +0000
@@ -264,6 +264,27 @@
             has_upstream_template(
                 distroseries, sourcepackagename, different_templatename))
 
+    def test_has_upstream_template_any_template(self):
+        # There is one template on the upstream project, not specifying
+        # a template name still indicates that there is a template.
+        distroseries, sourcepackagename = self._makeSourcePackage()
+        productseries = self._makeUpstreamProductSeries(
+            distroseries, sourcepackagename)
+        self.factory.makePOTemplate(
+            productseries=productseries)
+
+        self.assertTrue(
+            has_upstream_template(distroseries, sourcepackagename))
+
+    def test_has_upstream_template_any_template_none(self):
+        # There is no template on the upstream project.
+        distroseries, sourcepackagename = self._makeSourcePackage()
+        productseries = self._makeUpstreamProductSeries(
+            distroseries, sourcepackagename)
+
+        self.assertFalse(
+            has_upstream_template(distroseries, sourcepackagename))
+
     def test_has_ubuntu_template_no_sourcepackage(self):
         # There is no Ubuntu source package, so no Ubuntu template can be
         # found.
@@ -308,3 +329,22 @@
 
         self.assertFalse(
             has_ubuntu_template(productseries, different_templatename))
+
+    def test_has_ubuntu_template_any_template(self):
+        # There is one template on the Ubuntu source package, not specifying
+        # a template name still indicates that there is a template.
+        distroseries, sourcepackagename = self._makeSourcePackage()
+        productseries = self._makeUpstreamProductSeries(
+            distroseries, sourcepackagename)
+        self.factory.makePOTemplate(
+            distroseries=distroseries, sourcepackagename=sourcepackagename)
+
+        self.assertTrue(has_ubuntu_template(productseries))
+
+    def test_has_ubuntu_template_any_template_none(self):
+        # There is no template on the Ubuntu source package.
+        distroseries, sourcepackagename = self._makeSourcePackage()
+        productseries = self._makeUpstreamProductSeries(
+            distroseries, sourcepackagename)
+
+        self.assertFalse(has_ubuntu_template(productseries))
 
=== modified file 'lib/lp/translations/utilities/translation_import.py'
--- lib/lp/translations/utilities/translation_import.py	2011-01-04 17:23:42 +0000
+++ lib/lp/translations/utilities/translation_import.py	2011-02-11 14:44:33 +0000
@@ -432,6 +432,23 @@
             purportedly_upstream=from_upstream)
 
     @cachedproperty
+    def is_upstream_import_on_sourcepackage(self):
+        """Use TranslationMessage.acceptFromUpstreamImportOnPackage`."""
+        if self.pofile is None:
+            return False
+        if not self.translation_import_queue_entry.by_maintainer:
+            return False
+        if self.translation_import_queue_entry.sourcepackagename is None:
+            return False
+        distroseries = self.translation_import_queue_entry.distroseries
+        sourcepackagename = (
+            self.translation_import_queue_entry.sourcepackagename)
+        from lp.translations.utilities.translationsharinginfo import (
+            has_upstream_template)
+        return not has_upstream_template(
+            distroseries=distroseries, sourcepackagename=sourcepackagename)
+
+    @cachedproperty
     def translations_are_msgids(self):
         """Are these English strings instead of translations?
 
@@ -466,12 +483,16 @@
         message.validation_status = TranslationValidationStatus.OK
         return True
 
-    def _approveMessage(self, potmsgset, message, message_data):
+    def _acceptMessage(self, potmsgset, message, message_data):
         """Try to approve the message, return None on TranslationConflict."""
         try:
-            message.approve(
-                self.pofile, self.last_translator,
-                self.share_with_other_side, self.lock_timestamp)
+            if self.is_upstream_import_on_sourcepackage:
+                message.acceptFromUpstreamImportOnPackage(
+                    self.pofile, self.lock_timestamp)
+            else:
+                message.acceptFromImport(
+                    self.pofile, self.share_with_other_side,
+                    self.lock_timestamp)
         except TranslationConflict:
             self._addConflictError(message_data, potmsgset)
             if self.logger is not None:
@@ -529,7 +550,7 @@
         validation_ok = self._validateMessage(
             potmsgset, new_message, sanitized_translations, message_data)
         if validation_ok and self.is_editor:
-            return self._approveMessage(potmsgset, new_message, message_data)
+            return self._acceptMessage(potmsgset, new_message, message_data)
 
         return new_message
 
 
=== modified file 'lib/lp/translations/utilities/translationsharinginfo.py'
--- lib/lp/translations/utilities/translationsharinginfo.py	2011-02-03 18:40:36 +0000
+++ lib/lp/translations/utilities/translationsharinginfo.py	2011-02-11 14:44:33 +0000
@@ -161,14 +161,14 @@
         distroseries, sourcepackagename, templatename))
 
 
-def has_ubuntu_template(productseries, templatename):
+def has_ubuntu_template(productseries, templatename=None):
     """Check for existence of ubuntu template."""
     result = find_ubuntu_sharing_info(
         productseries, templatename, template_only=True)
     return not result.is_empty()
 
 
-def has_upstream_template(distroseries, sourcepackagename, templatename):
+def has_upstream_template(distroseries, sourcepackagename, templatename=None):
     """Check for existence of upstream template."""
     result = find_upstream_sharing_info(
             distroseries, sourcepackagename, templatename,
 
=== added file 'scripts/rosetta/upload-translations.py'
--- scripts/rosetta/upload-translations.py	1970-01-01 00:00:00 +0000
+++ scripts/rosetta/upload-translations.py	2011-02-11 14:44:33 +0000
@@ -0,0 +1,19 @@
+#!/usr/bin/python -S
+#
+# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+# pylint: disable-msg=W0403
+
+"""Upload translations to given package."""
+
+__metaclass__ = type
+
+import _pythonpath
+
+from lp.translations.scripts.upload_translations import (
+    UploadPackageTranslations)
+
+
+if __name__ == '__main__':
+    script = UploadPackageTranslations('upload-translations')
+    script.run()