Merge lp:~henninge/launchpad/bug-595925-second-attempt into lp:~launchpad/launchpad/recife

[Henning Eggers]

= Bug 595925 =

This branch only replaces calls in test code. The two production call sites will be updated in later branches. The first call site is in the view code and depends on bug 597539 being fixed or else many page tests do fail (I tried). The second is in the import code and requires some untangling or restructuring of code.

== Implementation details ==

This branch creates a new factory method "makeSuggestion" that makes use of the new "submitSuggestion" method. This factory method is then used in all test locations where "makeTranslationMessage(suggestion=True)" was used before.

In test_pofile.py I created TestTranslationSharedPOFileSourcePackage to move some tests there that were failing in TestTranslationSharedPOFile because it uses a product series.

I also fixed some tests in test_potmsgset.py that were using "set" to compare lists instead of assertContentEqual. Probably my doing.

I made sanitize_translations_from_webui work with lists for the translations because that is nice and robust.

I had to add an XXX to a windmill test because it depends on bug 597539, too.

== Tests ==

Run all the changed tests.

bin/test -vvcm lp.translations.browser.tests \
    -t test_pofile_view \
    -t test_translationmessage_view \
    -t translationmessage
bin/test -vvcm lp.translations.tests \
    -t test_pofile \
    -t test_potmsgset \
    -t test_translatablemessage \
    -t test_translations_to_review
bin/test -vvcm lp.translations.utilities.tests \
    -t test_sanitize \
    -t test_superfastimports
bin/test -vvcm lp.translations.windmill.tests \
    -t test_pofile_translate

But I already ran the full test suite on the branch successfully. ;-)

= Launchpad lint =

Checking for conflicts and issues in changed files.

Linting changed files:
  lib/lp/testing/factory.py
  lib/lp/translations/browser/translationmessage.py
  lib/lp/translations/browser/tests/test_pofile_view.py
  lib/lp/translations/browser/tests/test_translationmessage_view.py
  lib/lp/translations/tests/test_pofile.py
  lib/lp/translations/tests/test_potmsgset.py
  lib/lp/translations/tests/test_translatablemessage.py
  lib/lp/translations/tests/test_translations_to_review.py
  lib/lp/translations/utilities/sanitize.py
  lib/lp/translations/utilities/tests/test_sanitize.py
  lib/lp/translations/utilities/tests/test_superfastimports.py
  lib/lp/translations/windmill/tests/test_pofile_translate.py

./lib/lp/testing/factory.py
    2873: E301 expected 1 blank line, found 2
./lib/lp/translations/browser/translationmessage.py
     293: W602 deprecated form of raising exception
     300: W602 deprecated form of raising exception
     313: W602 deprecated form of raising exception
     339: E301 expected 1 blank line, found 2
     367: E301 expected 1 blank line, found 2
     511: E301 expected 1 blank line, found 2
     744: E301 expected 1 blank line, found 2
     827: E301 expected 1 blank line, found 2
     894: E301 expected 1 blank line, found 2
    1337: E301 expected 1 blank line, found 2
    1475: E302 expected 2 blank lines, found 3
    1509: E302 expected 2 blank lines, found 3
    1556: E302 expected 2 blank lines, found 1
./lib/lp/translations/tests/test_potmsgset.py
    1592: E202 whitespace before ']'

[Jeroen T. Vermeulen (jtv)]

Wow, big branch. I know it wasn't easy. Lots of goodness here, including lint cleanups all over the place. But you also inherited some uglier things, and it seems to me that your "make lint" run was incomplete somehow. I hope we can make some more headway with that, but in the interest of getting the branch in it's not as important as cleaning up the new bits.

We discussed some of these on IRC, but most we didn't.

=== lib/lp/testing/factory.py ===

Might as well make the "translations" parameter to _makeTranslationsDict default to None.

The docstring for _makeTranslationsDict goes "Make sure translations are in the right format." That's a bit ambiguous as to what happens when the translations are not in the right format. Consider saying something like "Convert translations" (and adding a note saying that it returns the original translations if they are already in the desired format).

In the same docstring, don't lead with "the right format"--name the format! An example like '{0: "foo"}' may say it most effectively.

Naming all types of sequence that might make up a non-dict translations list is probably a losing game: is it really necessary to accept tuples? What about ResultSets? If it's really needed, consider rearranging the conditions: "if translations is None / elif isinstance(translations, dict) / else" (where the "else" part returns dict(enumerate(translations))).

In makeSuggestion: it's no longer necessary to setSequence on a POTMsgSet you get from makePOTMsgSet. Just pass a sequence number to makePOTMsgSet.

In makeSuggestion, this line lacks spaces around the assignment operator:

        translations=self._makeTranslationsDict(translations)

And why does it set naked_translation_message.date_created to date_updated? I'd expect date_updated to set date_updated, not date_created.

== lib/lp/translations/browser/tests/test_pofile_view.py ==

Thanks for cleaning up the lint! While you're at it, could you chuck the entire test_suite function? We no longer need those, so they're just cruft now.

== lib/lp/translations/browser/translationmessage.py ==

More lint cleanups. Good show.

== lib/lp/translations/tests/test_pofile.py ==

There's a lot of code here that you clearly only moved, so you're probably more a victim than a perpetrator. But still I hope you can fix some of this, if it doesn't mean too much extra work.

In setUp, this comment:

# POTemplate is 'shared' if it has the same name ('messages').

...is rather confusing. I'd rather say that two POTemplates share if they have the same name. And separately, that these particular two templates both have "messages" for a name.

In the names devel_sr_pofile and stable_sr_pofile, unless the "sr" part is actually relevant to the tests, I'd leave it out of the names.

This comment:

# Create a single POTMsgSet that is used across all tests,
# and add it to only one of the POTemplates.

...commits the standard mistake of repeating what the code does. That's useless. The only interesting part is that the potmsgset is only added to one of the templates... *Why* is that?

And right below that, once again: no need to self.potmsgset.setSequence. Just pass the seq...

[Henning Eggers (henninge)]

Am 16.08.2010 16:37, schrieb Jeroen T. Vermeulen:
> Wow, big branch. I know it wasn't easy. Lots of goodness here, including lint cleanups all over the place. But you also inherited some uglier things, and it seems to me that your "make lint" run was incomplete somehow. I hope we can make some more headway with that, but in the interest of getting the branch in it's not as important as cleaning up the new bits.
>
> We discussed some of these on IRC, but most we didn't.
>
>
> === lib/lp/testing/factory.py ===
>
> Might as well make the "translations" parameter to _makeTranslationsDict default to None.
>
> The docstring for _makeTranslationsDict goes "Make sure translations are in the right format." That's a bit ambiguous as to what happens when the translations are not in the right format. Consider saying something like "Convert translations" (and adding a note saying that it returns the original translations if they are already in the desired format).
>
> In the same docstring, don't lead with "the right format"--name the format! An example like '{0: "foo"}' may say it most effectively.
>
> Naming all types of sequence that might make up a non-dict translations list is probably a losing game: is it really necessary to accept tuples? What about ResultSets? If it's really needed, consider rearranging the conditions: "if translations is None / elif isinstance(translations, dict) / else" (where the "else" part returns dict(enumerate(translations))).

I fixed all this as per our IRC discussion.

>
> In makeSuggestion: it's no longer necessary to setSequence on a POTMsgSet you get from makePOTMsgSet. Just pass a sequence number to makePOTMsgSet.

Ah yes, I copied and pasted makeSuggestion from makeTranslationMessage. I
added fixed it there, too. Funny enough, it was me who introduced the
parameter to the factory method in the first place. ;)

>
> In makeSuggestion, this line lacks spaces around the assignment operator:
>
> translations=self._makeTranslationsDict(translations)

Yes, I had it directly in the function call at first. Thanks.

>
> And why does it set naked_translation_message.date_created to date_updated? I'd expect date_updated to set date_updated, not date_created.
>

Again, copied from makeTranslationMessage where it is a bit more approriate
although it sets "date_created" and "date_reviewed" there. I renamed the
parameter in makeSuggestion to date_created and update all call sites.

>
> == lib/lp/translations/browser/tests/test_pofile_view.py ==
>
> Thanks for cleaning up the lint! While you're at it, could you chuck the entire test_suite function? We no longer need those, so they're just cruft now.

Ah yes, right. I am always happy to remove cruft! ;-)

>
>
> == lib/lp/translations/browser/translationmessage.py ==
>
> More lint cleanups. Good show.

Thank you for the applause! ;)

>
>
> == lib/lp/translations/tests/test_pofile.py ==
>
> There's a lot of code here that you clearly only moved, so you're probably more a victim than a perpetrator. But still I hope you can fix some of this, if it doesn't mean too much extra work.

Well, let's see .. ;-)

>
> In setUp, this comment:
>
> # POT...

[Jeroen T. Vermeulen (jtv)]

Thanks for all the work you put in cleaning things up! I'm perfectly happy for you to reject cleanups I suggested (but did not require) in pre-existing code. The goal of a review is to get the branch in, not to keep it out or delay it. It's good as it is.

The only part of this tome that needs any further follow-up AFAIC is this bit:

>> # Setting a suggestion as current makes it have no unreviewed
>> # suggestions.
>>
>> As far as I know, that only happens if the review date is also updated.
>> (The creation or last-update date may be used as a fallback if the review
>> date is not set; I don't recall off the top of my head). In that case,
>> the new current translation is presumably newer than all suggestions and
>> so leaves no new suggestions. But the test code there only sets the
>> flag. I think this passes more or less by accident; what if there's
>> another suggestion that's newer than the suggestion that's being made
>> current?
>
> Didn't the old validators do all that? I agree though, that this most
> likely passes by accident now and I am pretty sure there may be more tests
> that do.

The validators only disabled the incumbent current message (if any). They did not set the review timestamp.

> This branch was meant as a mechanical replacement, though, so I think
> trying to check and fix all tests is beyond the scope.

That's fine with me. Could you add a note though, so we don't miss this when we debug problems with this test in the future? No need even to be completely 100% sure of what happens, just point out to future readers that there may possibly be a pitfall there.

Oh, and... Congratulations. :-)

Jeroen

review: Approve (code)

=== modified file 'lib/lp/testing/factory.py'
--- lib/lp/testing/factory.py	2010-08-10 17:28:08 +0000
+++ lib/lp/testing/factory.py	2010-08-17 09:48:55 +0000
@@ -2072,8 +2072,7 @@
         if pofile is None:
             pofile = self.makePOFile('sr')
         if potmsgset is None:
-            potmsgset = self.makePOTMsgSet(pofile.potemplate)
-            potmsgset.setSequence(pofile.potemplate, 1)
+            potmsgset = self.makePOTMsgSet(pofile.potemplate, sequence=1)
         if translator is None:
             translator = self.makePerson()
         if translations is None:
@@ -2092,6 +2091,42 @@
             naked_translation_message.sync()
         return translation_message
 
+    def _makeTranslationsDict(self, translations=None):
+        """Make sure translations are stored in a dict, e.g. {0: "foo"}.
+
+        If translations is already dict, it is returned unchanged.
+        If translations is a sequence, it is enumerated into a dict.
+        If translations is None, an arbitrary single translation is created.
+        """
+        if translations is None:
+            return {0: self.getUniqueString()}
+        if isinstance(translations, dict):
+            return translations
+        assert isinstance(translations, (list, tuple)), (
+                "Expecting either a dict or a sequence." )
+        return dict(enumerate(translations))
+
+    def makeSuggestion(self, pofile=None, potmsgset=None, translator=None,
+                       translations=None, date_created=None):
+        """Make a new suggested `TranslationMessage` in the given PO file."""
+        if pofile is None:
+            pofile = self.makePOFile('sr')
+        if potmsgset is None:
+            potmsgset = self.makePOTMsgSet(pofile.potemplate, sequence=1)
+        if translator is None:
+            translator = self.makePerson()
+        translations = self._makeTranslationsDict(translations)
+        translation_message = potmsgset.submitSuggestion(
+            pofile, translator, translations)
+        assert translation_message is not None, (
+            "Cannot make suggestion on translation credits POTMsgSet.")
+        if date_created is not None:
+            naked_translation_message = removeSecurityProxy(
+                translation_message)
+            naked_translation_message.date_created = date_created
+            naked_translation_message.sync()
+        return translation_message
+
     def makeSharedTranslationMessage(self, pofile=None, potmsgset=None,
                                      translator=None, suggestion=False,
                                      reviewer=None, translations=None,

=== modified file 'lib/lp/translations/browser/tests/test_pofile_view.py'
--- lib/lp/translations/browser/tests/test_pofile_view.py	2010-08-04 11:00:51 +0000
+++ lib/lp/translations/browser/tests/test_pofile_view.py	2010-08-17 09:48:55 +0000
@@ -45,9 +45,8 @@
         self.factory.makeTranslationMessage(
             self.pofile, self.new_suggestion,
             date_updated=self.now())
-        self.factory.makeTranslationMessage(
-            self.pofile, self.new_suggestion, suggestion=True,
-            date_updated=self.now())
+        self.factory.makeSuggestion(
+            self.pofile, self.new_suggestion, date_created=self.now())
         # An upstream that was changed in Ubuntu.
         self.changed = self.factory.makePOTMsgSet(
             self.potemplate, sequence=4)
@@ -171,8 +170,3 @@
     def setUp(self):
         super(TestPOFileTranslateViewInvalidFiltering, self).setUp()
         self.pofile = self.factory.makePOFile('eo')
-
-
-def test_suite():
-    return TestLoader().loadTestsFromName(__name__)
-

=== modified file 'lib/lp/translations/browser/tests/test_translationmessage_view.py'
--- lib/lp/translations/browser/tests/test_translationmessage_view.py	2010-03-23 19:49:56 +0000
+++ lib/lp/translations/browser/tests/test_translationmessage_view.py	2010-08-17 09:48:55 +0000
@@ -51,13 +51,20 @@
             translations = translation
         else:
             translations = [translation]
-        message = self.factory.makeTranslationMessage(
-            self.pofile, self.potmsgset,
-            translations=translations,
-            suggestion=suggestion,
-            is_current_upstream=is_packaged,
-            translator=self.owner,
-            date_updated=self.now())
+        if suggestion:
+            message = self.factory.makeSuggestion(
+                self.pofile, self.potmsgset,
+                translations=translations,
+                translator=self.owner,
+                date_created=self.now())
+        else:
+            message = self.factory.makeTranslationMessage(
+                self.pofile, self.potmsgset,
+                translations=translations,
+                suggestion=suggestion,
+                is_current_upstream=is_packaged,
+                translator=self.owner,
+                date_updated=self.now())
         message.browser_pofile = self.pofile
         return message
 

=== modified file 'lib/lp/translations/browser/translationmessage.py'
--- lib/lp/translations/browser/translationmessage.py	2010-08-04 11:00:51 +0000
+++ lib/lp/translations/browser/translationmessage.py	2010-08-17 09:48:55 +0000
@@ -58,12 +58,10 @@
 from canonical.launchpad.webapp.batching import BatchNavigator
 from canonical.launchpad.webapp.menu import structured
 
-
 #
 # Exceptions and helper classes
 #
 
-
 class POTMsgSetBatchNavigator(BatchNavigator):
 
     def __init__(self, results, request, start=0, size=1):
@@ -138,6 +136,7 @@
 #
 # Standard UI classes
 #
+
 class CurrentTranslationMessageFacets(POTemplateFacets):
     usedfor = ITranslationMessage
 
@@ -171,6 +170,7 @@
 #
 # Views
 #
+
 class CurrentTranslationMessageIndexView:
     """A view to forward to the translation form."""
 
@@ -536,7 +536,7 @@
         elif fallback_language is not None:
             # If there's a standard alternative language and no
             # user-specified language was provided, preselect it.
-            alternative_language =  fallback_language
+            alternative_language = fallback_language
             second_lang_code = fallback_language.code
         else:
             # The second_lang_code is None and there is no fallback_language.
@@ -1511,10 +1511,6 @@
 
     implements(ITranslationMessageSuggestions)
 
-    def isFromSamePOFile(self, submission):
-        """Return if submission is from the same PO file as a POMsgSet."""
-        return self.pofile == submission['pofile']
-
     def __init__(self, title, translation, submissions,
                  user_is_official_translator, form_is_writeable,
                  plural_form, seen_translations=None, legal_warning=False):

=== modified file 'lib/lp/translations/tests/test_pofile.py'
--- lib/lp/translations/tests/test_pofile.py	2010-08-10 14:39:46 +0000
+++ lib/lp/translations/tests/test_pofile.py	2010-08-17 09:48:55 +0000
@@ -1,8 +1,6 @@
 # Copyright 2009-2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-# pylint: disable-msg=C0102
-
 __metaclass__ = type
 
 from datetime import datetime, timedelta
@@ -25,6 +23,171 @@
 from canonical.launchpad.webapp.publisher import canonical_url
 
 
+class TestTranslationSharedPOFileSourcePackage(TestCaseWithFactory):
+    """Test behavior of PO files with shared POTMsgSets on a source package.
+    """
+
+    layer = ZopelessDatabaseLayer
+
+    def setUp(self):
+        # Create a product with two series and a shared POTemplate
+        # in different series ('devel' and 'stable').
+        super(TestTranslationSharedPOFileSourcePackage, self).setUp()
+        self.foo = self.factory.makeDistribution()
+        self.foo_devel = self.factory.makeDistroSeries(
+            name='devel', distribution=self.foo)
+        self.foo_stable = self.factory.makeDistroSeries(
+            name='stable', distribution=self.foo)
+        self.foo.official_rosetta = True
+        self.sourcepackagename = self.factory.makeSourcePackageName()
+
+        # Two POTemplates share translations if they have the same name,
+        # in this case 'messages'.
+        self.devel_potemplate = self.factory.makePOTemplate(
+            distroseries=self.foo_devel,
+            sourcepackagename=self.sourcepackagename,
+            name="messages")
+        self.stable_potemplate = self.factory.makePOTemplate(
+            distroseries=self.foo_stable,
+            sourcepackagename=self.sourcepackagename,
+            name="messages")
+
+        # We'll use two PO files, one for each series.
+        self.devel_pofile = self.factory.makePOFile(
+            'sr', self.devel_potemplate)
+        self.stable_pofile = self.factory.makePOFile(
+            'sr', self.stable_potemplate)
+
+        # The POTMsgSet is added to only one of the POTemplates.
+        self.potmsgset = self.factory.makePOTMsgSet(
+            self.devel_potemplate, sequence=1)
+
+    def test_getPOTMsgSetWithNewSuggestions_shared(self):
+        # Test listing of suggestions for POTMsgSets with a shared
+        # translation.
+
+        # A POTMsgSet has a shared, current translation created 5 days ago.
+        date_created = datetime.now(pytz.UTC) - timedelta(5)
+        translation = self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[u"Translation"], date_created=date_created)
+        translation.is_current_ubuntu = True
+
+        # When there are no suggestions, nothing is returned.
+        found_translations = list(
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
+        self.assertEquals(found_translations, [])
+
+        # When a suggestion is added one day after, the potmsgset is returned.
+        suggestion_date = date_created + timedelta(1)
+        suggestion = self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[u"Suggestion"], date_created=suggestion_date)
+        self.assertEquals(suggestion.is_current_ubuntu, False)
+
+        found_translations = list(
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
+        self.assertEquals(found_translations, [self.potmsgset])
+
+        # Setting a suggestion as current makes it have no unreviewed
+        # suggestions.
+        # XXX henninge 2010-08-17: It looks like this test passes by
+        # accident as the suggestion already is the newest translation
+        # available. Other tests may be passing just by accident, too.
+        # This will have to be investigated when all bits and pieces are in
+        # place.
+        translation.is_current_ubuntu = False
+        suggestion.is_current_ubuntu = True
+        found_translations = list(
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
+        self.assertEquals(found_translations, [])
+
+        # And adding another suggestion 2 days later, the potmsgset is
+        # again returned.
+        suggestion_date += timedelta(2)
+        translation = self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[u"New suggestion"], date_created=suggestion_date)
+        self.assertEquals(translation.is_current_ubuntu, False)
+
+        found_translations = list(
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
+        self.assertEquals(found_translations, [self.potmsgset])
+
+    def test_getPOTMsgSetWithNewSuggestions_diverged(self):
+        # Test listing of suggestions for POTMsgSets with a shared
+        # translation and a later diverged one.
+
+        # First we create a shared translation (5 days old), a diverged
+        # translation 1 day later.
+        # Then we make sure that getting unreviewed messages works when:
+        #  * A suggestion is added 1 day after (shows as unreviewed).
+        #  * A new diverged translation is added another day later (nothing).
+        #  * A new suggestion is added after another day (shows).
+        #  * Suggestion is made active (nothing).
+
+        # A POTMsgSet has a shared, current translation created 5 days ago.
+        date_created = datetime.now(pytz.UTC) - timedelta(5)
+        translation = self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[u"Shared translation"], date_created=date_created)
+        translation.is_current_ubuntu = True
+
+        # And we also have a diverged translation created a day after a shared
+        # current translation.
+        diverged_date = date_created + timedelta(1)
+        diverged_translation = self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[u"Old translation"], date_created=diverged_date)
+        diverged_translation.potemplate = self.devel_potemplate
+        diverged_translation.is_current_ubuntu = True
+
+        # There is also a suggestion against the shared translation
+        # created 2 days after the shared translation.
+        suggestion_date = date_created + timedelta(2)
+        suggestion = self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[u"Shared suggestion"], date_created=suggestion_date)
+        self.assertEquals(suggestion.is_current_ubuntu, False)
+
+        # A suggestion is shown since diverged_date < suggestion_date.
+        found_translations = list(
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
+        self.assertEquals(found_translations, [self.potmsgset])
+
+        # When a diverged translation is added after the shared suggestion,
+        # there are no unreviewed suggestions.
+        diverged_date = suggestion_date + timedelta(1)
+        diverged_translation_2 = self.factory.makeTranslationMessage(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[u"Translation"], date_updated=diverged_date)
+        diverged_translation.is_current_ubuntu = False
+        diverged_translation_2.potemplate = self.devel_potemplate
+        diverged_translation_2.is_current_ubuntu = True
+        found_translations = list(
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
+        self.assertEquals(found_translations, [])
+
+        # When a suggestion is added one day after, the potmsgset is returned.
+        suggestion_date = diverged_date + timedelta(1)
+        suggestion = self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[u"Suggestion"], date_created=suggestion_date)
+        self.assertEquals(suggestion.is_current_ubuntu, False)
+
+        found_translations = list(
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
+        self.assertEquals(found_translations, [self.potmsgset])
+
+        # Setting a suggestion as current makes it have no unreviewed
+        # suggestions.
+        translation.is_current_ubuntu = False
+        suggestion.is_current_ubuntu = True
+        found_translations = list(
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
+        self.assertEquals(found_translations, [])
+
+
 class TestTranslationSharedPOFile(TestCaseWithFactory):
     """Test behaviour of PO files with shared POTMsgSets."""
 
@@ -41,22 +204,22 @@
             name='stable', product=self.foo)
         self.foo.official_rosetta = True
 
-        # POTemplate is 'shared' if it has the same name ('messages').
+        # Two POTemplates share translations if they have the same name,
+        # in this case 'messages'.
         self.devel_potemplate = self.factory.makePOTemplate(
             productseries=self.foo_devel, name="messages")
         self.stable_potemplate = self.factory.makePOTemplate(self.foo_stable,
                                                         name="messages")
 
         # We'll use two PO files, one for each series.
-        self.devel_sr_pofile = self.factory.makePOFile(
+        self.devel_pofile = self.factory.makePOFile(
             'sr', self.devel_potemplate)
-        self.stable_sr_pofile = self.factory.makePOFile(
+        self.stable_pofile = self.factory.makePOFile(
             'sr', self.stable_potemplate)
 
-        # Create a single POTMsgSet that is used across all tests,
-        # and add it to only one of the POTemplates.
-        self.potmsgset = self.factory.makePOTMsgSet(self.devel_potemplate)
-        self.potmsgset.setSequence(self.devel_potemplate, 1)
+        # The POTMsgSet is added to only one of the POTemplates.
+        self.potmsgset = self.factory.makePOTMsgSet(
+            self.devel_potemplate, sequence=1)
 
     def test_findPOTMsgSetsContaining(self):
         # Test that search works correctly.
@@ -67,14 +230,14 @@
         potmsgset.setSequence(self.devel_potemplate, 2)
 
         found_potmsgsets = list(
-            self.devel_sr_pofile.findPOTMsgSetsContaining(u"wild"))
+            self.devel_pofile.findPOTMsgSetsContaining(u"wild"))
         self.assertEquals(found_potmsgsets, [potmsgset])
 
         # Just linking an existing POTMsgSet into another POTemplate
         # will make it be returned in searches.
         potmsgset.setSequence(self.stable_potemplate, 2)
         found_potmsgsets = list(
-            self.stable_sr_pofile.findPOTMsgSetsContaining(u"wild"))
+            self.stable_pofile.findPOTMsgSetsContaining(u"wild"))
         self.assertEquals(found_potmsgsets, [potmsgset])
 
         # Searching for singular in plural messages works as well.
@@ -84,49 +247,49 @@
         plural_potmsgset.setSequence(self.devel_potemplate, 3)
 
         found_potmsgsets = list(
-            self.devel_sr_pofile.findPOTMsgSetsContaining(u"singular"))
+            self.devel_pofile.findPOTMsgSetsContaining(u"singular"))
         self.assertEquals(found_potmsgsets, [plural_potmsgset])
 
         # And searching for plural text returns only the matching plural
         # message.
         found_potmsgsets = list(
-            self.devel_sr_pofile.findPOTMsgSetsContaining(u"plural"))
+            self.devel_pofile.findPOTMsgSetsContaining(u"plural"))
         self.assertEquals(found_potmsgsets, [plural_potmsgset])
 
         # Search translations as well.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
+            pofile=self.devel_pofile, potmsgset=potmsgset,
             translations=[u"One translation message"])
         found_potmsgsets = list(
-            self.devel_sr_pofile.findPOTMsgSetsContaining(u"translation"))
+            self.devel_pofile.findPOTMsgSetsContaining(u"translation"))
         self.assertEquals(found_potmsgsets, [potmsgset])
 
         # Search matches all plural forms.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=plural_potmsgset,
+            pofile=self.devel_pofile, potmsgset=plural_potmsgset,
             translations=[u"One translation message",
                           u"Plural translation message",
                           u"Third translation message"])
         found_potmsgsets = list(
-            self.devel_sr_pofile.findPOTMsgSetsContaining(
+            self.devel_pofile.findPOTMsgSetsContaining(
                 u"Plural translation"))
         self.assertEquals(found_potmsgsets, [plural_potmsgset])
 
         # Search works case insensitively for English strings.
         found_potmsgsets = list(
-            self.devel_sr_pofile.findPOTMsgSetsContaining(u"WiLd"))
+            self.devel_pofile.findPOTMsgSetsContaining(u"WiLd"))
         self.assertEquals(found_potmsgsets, [potmsgset])
         # ...English plural forms.
         found_potmsgsets = list(
-            self.devel_sr_pofile.findPOTMsgSetsContaining(u"PLurAl"))
+            self.devel_pofile.findPOTMsgSetsContaining(u"PLurAl"))
         self.assertEquals(found_potmsgsets, [plural_potmsgset])
         # ...translations.
         found_potmsgsets = list(
-            self.devel_sr_pofile.findPOTMsgSetsContaining(u"tRANSlaTIon"))
+            self.devel_pofile.findPOTMsgSetsContaining(u"tRANSlaTIon"))
         self.assertEquals(found_potmsgsets, [potmsgset, plural_potmsgset])
         # ...and translated plurals.
         found_potmsgsets = list(
-            self.devel_sr_pofile.findPOTMsgSetsContaining(u"THIRD"))
+            self.devel_pofile.findPOTMsgSetsContaining(u"THIRD"))
         self.assertEquals(found_potmsgsets, [plural_potmsgset])
 
     def test_getTranslationsFilteredBy(self):
@@ -139,27 +302,27 @@
 
         # When there are no translations, empty list is returned.
         found_translations = list(
-            self.devel_sr_pofile.getTranslationsFilteredBy(submitter))
+            self.devel_pofile.getTranslationsFilteredBy(submitter))
         self.assertEquals(found_translations, [])
 
         # If 'submitter' provides a translation, it's returned in a list.
         translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
+            pofile=self.devel_pofile, potmsgset=potmsgset,
             translations=[u"Translation message"],
             translator=submitter)
         found_translations = list(
-            self.devel_sr_pofile.getTranslationsFilteredBy(submitter))
+            self.devel_pofile.getTranslationsFilteredBy(submitter))
         self.assertEquals(found_translations, [translation])
 
         # If somebody else provides a translation, it's not added to the
         # list of submitter's translations.
         someone_else = self.factory.makePerson()
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
+            pofile=self.devel_pofile, potmsgset=potmsgset,
             translations=[u"Another translation"],
             translator=someone_else)
         found_translations = list(
-            self.devel_sr_pofile.getTranslationsFilteredBy(submitter))
+            self.devel_pofile.getTranslationsFilteredBy(submitter))
         self.assertEquals(found_translations, [translation])
 
         # Adding a translation for same POTMsgSet, but to a different
@@ -175,17 +338,17 @@
             translations=[u"Yet another translation"],
             translator=submitter)
         found_translations = list(
-            self.devel_sr_pofile.getTranslationsFilteredBy(submitter))
+            self.devel_pofile.getTranslationsFilteredBy(submitter))
         self.assertEquals(found_translations, [translation])
 
         # If a POTMsgSet is shared between two templates, a
         # translation is listed on both.
         potmsgset.setSequence(self.stable_potemplate, 1)
         found_translations = list(
-            self.stable_sr_pofile.getTranslationsFilteredBy(submitter))
+            self.stable_pofile.getTranslationsFilteredBy(submitter))
         self.assertEquals(found_translations, [translation])
         found_translations = list(
-            self.devel_sr_pofile.getTranslationsFilteredBy(submitter))
+            self.devel_pofile.getTranslationsFilteredBy(submitter))
         self.assertEquals(found_translations, [translation])
 
     def test_getPOTMsgSetTranslated_NoShared(self):
@@ -194,23 +357,23 @@
 
         # When there is no diverged translation either, nothing is returned.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(found_translations, [])
 
         # When a diverged translation is added, the potmsgset is returned.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Translation"])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(found_translations, [self.potmsgset])
 
         # If diverged translation is empty, POTMsgSet is not listed.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u""])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(found_translations, [])
 
     def test_getPOTMsgSetTranslated_Shared(self):
@@ -219,28 +382,28 @@
 
         # We create a shared translation first.
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Shared translation"])
 
         # When there is no diverged translation, shared one is returned.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(found_translations, [self.potmsgset])
 
         # When an empty diverged translation is added, nothing is listed.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u""])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(found_translations, [])
 
         # If diverged translation is non-empty, POTMsgSet is listed.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Translation"])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(found_translations, [self.potmsgset])
 
     def test_getPOTMsgSetTranslated_EmptyShared(self):
@@ -249,29 +412,29 @@
 
         # We create an empty shared translation first.
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u""])
 
         # When there is no diverged translation, shared one is returned,
         # but since it's empty, there are no results.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(found_translations, [])
 
         # When an empty diverged translation is added, nothing is listed.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u""])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(found_translations, [])
 
         # If diverged translation is non-empty, POTMsgSet is listed.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Translation"])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(found_translations, [self.potmsgset])
 
     def test_getPOTMsgSetTranslated_Multiple(self):
@@ -280,7 +443,7 @@
 
         # Add a diverged translation on the included POTMsgSet...
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Diverged translation"])
 
         # and a shared translation on newly added POTMsgSet...
@@ -289,12 +452,12 @@
         potmsgset.setSequence(self.devel_potemplate, 2)
 
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
+            pofile=self.devel_pofile, potmsgset=potmsgset,
             translations=[u"Shared translation"])
 
         # Both POTMsgSets are listed.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(found_translations, [self.potmsgset, potmsgset])
 
     def test_getPOTMsgSetUntranslated_NoShared(self):
@@ -303,23 +466,23 @@
 
         # When there is no diverged translation either, nothing is returned.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(found_translations, [self.potmsgset])
 
         # When a diverged translation is added, the potmsgset is returned.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Translation"])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(found_translations, [])
 
         # If diverged translation is empty, POTMsgSet is not listed.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u""])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(found_translations, [self.potmsgset])
 
     def test_getPOTMsgSetUntranslated_Shared(self):
@@ -328,28 +491,28 @@
 
         # We create a shared translation first.
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Shared translation"])
 
         # When there is no diverged translation, shared one is returned.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(found_translations, [])
 
         # When an empty diverged translation is added, nothing is listed.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u""])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(found_translations, [self.potmsgset])
 
         # If diverged translation is non-empty, POTMsgSet is listed.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Translation"])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(found_translations, [])
 
     def test_getPOTMsgSetUntranslated_EmptyShared(self):
@@ -358,29 +521,29 @@
 
         # We create an empty shared translation first.
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u""])
 
         # When there is no diverged translation, shared one is returned,
         # but since it's empty, there are no results.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(found_translations, [self.potmsgset])
 
         # When an empty diverged translation is added, nothing is listed.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u""])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(found_translations, [self.potmsgset])
 
         # If diverged translation is non-empty, POTMsgSet is listed.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Translation"])
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(found_translations, [])
 
     def test_getPOTMsgSetUntranslated_Multiple(self):
@@ -389,7 +552,7 @@
 
         # Add an empty translation to the included POTMsgSet...
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u""])
 
         # ...and a new untranslated POTMsgSet.
@@ -399,7 +562,7 @@
 
         # Both POTMsgSets are listed.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(found_translations, [self.potmsgset, potmsgset])
 
     def test_getPOTMsgSetWithNewSuggestions(self):
@@ -407,142 +570,26 @@
 
         # When there are no suggestions, nothing is returned.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
         self.assertEquals(found_translations, [])
 
         # When a suggestion is added, the potmsgset is returned.
-        translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u"Suggestion"], suggestion=True)
-        self.assertEquals(translation.is_current_ubuntu, False)
-
-        found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
-        self.assertEquals(found_translations, [self.potmsgset])
-
-    def test_getPOTMsgSetWithNewSuggestions_Shared(self):
-        # Test listing of suggestions for POTMsgSets with a shared
-        # translation.
-
-        # A POTMsgSet has a shared, current translation created 5 days ago.
-        date_created = datetime.now(pytz.UTC)-timedelta(5)
-        translation = self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u"Translation"], date_updated=date_created)
-        self.assertEquals(translation.is_current_ubuntu, True)
-
-        # When there are no suggestions, nothing is returned.
-        found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
-        self.assertEquals(found_translations, [])
-
-        # When a suggestion is added one day after, the potmsgset is returned.
-        suggestion_date = date_created + timedelta(1)
-        translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u"Suggestion"], suggestion=True,
-            date_updated=suggestion_date)
-        self.assertEquals(translation.is_current_ubuntu, False)
-
-        found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
-        self.assertEquals(found_translations, [self.potmsgset])
-
-        # Setting a suggestion as current makes it have no unreviewed
-        # suggestions.
-        translation.is_current_ubuntu = True
-        found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
-        self.assertEquals(found_translations, [])
-
-        # And adding another suggestion 2 days later, the potmsgset is
-        # again returned.
-        suggestion_date += timedelta(2)
-        translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u"New suggestion"], suggestion=True,
-            date_updated=suggestion_date)
-        self.assertEquals(translation.is_current_ubuntu, False)
-
-        found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
-        self.assertEquals(found_translations, [self.potmsgset])
-
-    def test_getPOTMsgSetWithNewSuggestions_Diverged(self):
-        # Test listing of suggestions for POTMsgSets with a shared
-        # translation and a later diverged one.
-
-        # First we create a shared translation (5 days old), a diverged
-        # translation 1 day later.
-        # Then we make sure that getting unreviewed messages works when:
-        #  * A suggestion is added 1 day after (shows as unreviewed).
-        #  * A new diverged translation is added another day later (nothing).
-        #  * A new suggestion is added after another day (shows).
-        #  * Suggestion is made active (nothing).
-
-        # A POTMsgSet has a shared, current translation created 5 days ago.
-        date_created = datetime.now(pytz.UTC)-timedelta(5)
-        self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u"Shared translation"], date_updated=date_created)
-
-        # And we also have a diverged translation created a day after shared
-        # current translation.
-        diverged_date = date_created + timedelta(1)
-        self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u"Old translation"], date_updated=diverged_date)
-
-        # There is also a suggestion against the shared translation
-        # created 2 days after the shared translation.
-        suggestion_date = date_created + timedelta(2)
-        translation = self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u"Shared suggestion"], suggestion=True,
-            date_updated=suggestion_date)
-        self.assertEquals(translation.is_current_ubuntu, False)
-
-        # Shared suggestion is shown since diverged_date < suggestion_date.
-        found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
-        self.assertEquals(found_translations, [self.potmsgset])
-
-        # When a diverged translation is done after the shared suggestion,
-        # there are no unreviewed suggestions.
-        diverged_date = suggestion_date + timedelta(1)
-        translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u"Translation"], date_updated=diverged_date)
-        found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
-        self.assertEquals(found_translations, [])
-
-        # When a suggestion is added one day after, the potmsgset is returned.
-        suggestion_date = diverged_date + timedelta(1)
-        translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u"Suggestion"], suggestion=True,
-            date_updated=suggestion_date)
-        self.assertEquals(translation.is_current_ubuntu, False)
-
-        found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
-        self.assertEquals(found_translations, [self.potmsgset])
-
-        # Setting a suggestion as current makes it have no unreviewed
-        # suggestions.
-        translation.is_current_ubuntu = True
-        found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
-        self.assertEquals(found_translations, [])
-
-    def test_getPOTMsgSetWithNewSuggestions_Multiple(self):
+        translation = self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[u"Suggestion"])
+        self.assertEquals(translation.is_current_ubuntu, False)
+
+        found_translations = list(
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
+        self.assertEquals(found_translations, [self.potmsgset])
+
+    def test_getPOTMsgSetWithNewSuggestions_multiple(self):
         # Test that multiple unreviewed POTMsgSets are returned.
 
         # One POTMsgSet has no translations, but only a suggestion.
-        self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u"New suggestion"], suggestion=True)
+        self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[u"New suggestion"])
 
         # Another POTMsgSet has both a translation and a suggestion.
         potmsgset = self.factory.makePOTMsgSet(self.devel_potemplate,
@@ -550,52 +597,49 @@
         potmsgset.setSequence(self.devel_potemplate, 2)
         date_created = datetime.now(pytz.UTC) - timedelta(5)
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Translation"], date_updated=date_created)
         suggestion_date = date_created + timedelta(1)
-        self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
-            translations=[u"New suggestion"], suggestion=True,
-            date_updated=suggestion_date)
+        self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=potmsgset,
+            translations=[u"New suggestion"], date_created=suggestion_date)
 
         # Both POTMsgSets are listed.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
         self.assertEquals(found_translations, [self.potmsgset, potmsgset])
 
     def test_getPOTMsgSetWithNewSuggestions_distinct(self):
         # Provide two suggestions on a single message and make sure
         # a POTMsgSet is returned only once.
-        self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
-            potmsgset=self.potmsgset,
-            translations=["A suggestion"],
-            suggestion=True)
-        self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
-            potmsgset=self.potmsgset,
-            translations=["Another suggestion"],
-            suggestion=True)
+        self.factory.makeSuggestion(
+            pofile=self.devel_pofile,
+            potmsgset=self.potmsgset,
+            translations=["A suggestion"])
+        self.factory.makeSuggestion(
+            pofile=self.devel_pofile,
+            potmsgset=self.potmsgset,
+            translations=["Another suggestion"])
 
         potmsgsets = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
         self.assertEquals(potmsgsets,
                           [self.potmsgset])
         self.assertEquals(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions().count(),
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions().count(),
             1)
 
     def test_getPOTMsgSetWithNewSuggestions_empty(self):
         # Test listing of POTMsgSets with empty strings as suggestions.
 
         # When an empty suggestion is added, the potmsgset is NOT returned.
-        translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
-            translations=[u""], suggestion=True)
+        translation = self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
+            translations=[])
         self.assertEquals(False, translation.is_current_ubuntu)
 
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithNewSuggestions())
+            self.devel_pofile.getPOTMsgSetWithNewSuggestions())
         self.assertEquals([], found_translations)
 
     def test_getPOTMsgSetChangedInUbuntu(self):
@@ -603,72 +647,72 @@
 
         # If there are no translations in Ubuntu, nothing is listed.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(found_translations, [])
 
         # Adding a non-imported current translation doesn't change anything.
         translation = self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Non-imported translation"])
         self.assertEquals(translation.is_current_upstream, False)
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(found_translations, [])
 
         # Adding an imported translation which is also current indicates
         # that there are no changes.
         translation = self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Imported translation"], is_current_upstream=True)
         self.assertEquals(translation.is_current_upstream, True)
         self.assertEquals(translation.is_current_ubuntu, True)
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(found_translations, [])
 
         # However, changing current translation to a non-imported one
         # makes this a changed in Ubuntu translation.
         translation = self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Changed translation"], is_current_upstream=False)
         self.assertEquals(translation.is_current_upstream, False)
         self.assertEquals(translation.is_current_ubuntu, True)
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(found_translations, [self.potmsgset])
 
         # Adding a diverged, non-imported translation, still lists
         # it as a changed translation.
         translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Diverged translation"], is_current_upstream=False)
         self.assertEquals(translation.is_current_upstream, False)
         self.assertEquals(translation.is_current_ubuntu, True)
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(found_translations, [self.potmsgset])
 
         # But adding a diverged current and imported translation means
         # that it's not changed anymore.
         translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Diverged imported"], is_current_upstream=True,
             force_diverged=True)
         self.assertEquals(translation.is_current_upstream, True)
         self.assertEquals(translation.is_current_ubuntu, True)
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(found_translations, [])
 
         # Changing from a diverged, imported translation is correctly
         # detected.
         translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Diverged changed"], is_current_upstream=False)
         self.assertEquals(translation.is_current_upstream, False)
         self.assertEquals(translation.is_current_ubuntu, True)
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(found_translations, [self.potmsgset])
 
     def test_getPOTMsgSetChangedInUbuntu_diverged_imported(self):
@@ -682,11 +726,11 @@
         # 1) Shared imported and current translation.
         # 2) Diverged, imported, non-current message.
         shared = self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Shared imported current"],
             is_current_upstream=True)
         diverged = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Diverged imported non-current"],
             is_current_upstream=True, force_diverged=True)
         # As we can't come to this situation using existing code,
@@ -702,7 +746,7 @@
 
         # Such POTMsgSet is not considered changed in this PO file.
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(found_translations, [])
 
     def test_getPOTMsgSetChangedInUbuntu_SharedDiverged(self):
@@ -711,34 +755,34 @@
         # Adding an imported translation which is also current indicates
         # that there are no changes.
         translation = self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Imported translation"], is_current_upstream=True)
         self.assertEquals(translation.is_current_upstream, True)
         self.assertEquals(translation.is_current_ubuntu, True)
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(found_translations, [])
 
         # Adding a diverged, non-imported translation makes it appear
         # as changed.
         translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Changed translation"], is_current_upstream=False)
         self.assertEquals(translation.is_current_upstream, False)
         self.assertEquals(translation.is_current_ubuntu, True)
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(found_translations, [self.potmsgset])
 
     def test_getPOTMsgSetWithErrors(self):
         # Test listing of POTMsgSets with errors in translations.
         translation = self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=self.potmsgset,
+            pofile=self.devel_pofile, potmsgset=self.potmsgset,
             translations=[u"Imported translation"], is_current_upstream=True)
         removeSecurityProxy(translation).validation_status = (
             TranslationValidationStatus.UNKNOWNERROR)
         found_translations = list(
-            self.devel_sr_pofile.getPOTMsgSetWithErrors())
+            self.devel_pofile.getPOTMsgSetWithErrors())
         self.assertEquals(found_translations, [self.potmsgset])
 
     def test_updateStatistics(self):
@@ -757,72 +801,72 @@
         # Second POTMsgSet is untranslated, but with a suggestion.
         potmsgset = self.factory.makePOTMsgSet(self.devel_potemplate)
         potmsgset.setSequence(self.devel_potemplate, 2)
-        self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
-            translations=[u"Unreviewed suggestion"], suggestion=True)
+        self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=potmsgset,
+            translations=[u"Unreviewed suggestion"])
 
         # Third POTMsgSet is translated, and with a suggestion.
         potmsgset = self.factory.makePOTMsgSet(self.devel_potemplate)
         potmsgset.setSequence(self.devel_potemplate, 3)
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
-            translations=[u"Translation"], suggestion=False,
+            pofile=self.devel_pofile, potmsgset=potmsgset,
+            translations=[u"Translation"],
             date_updated=datetime.now(pytz.UTC)-timedelta(1))
-        self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
-            translations=[u"Another suggestion"], suggestion=True)
+        self.factory.makeSuggestion(
+            pofile=self.devel_pofile, potmsgset=potmsgset,
+            translations=[u"Another suggestion"])
 
         # Fourth POTMsgSet is translated in import.
         potmsgset = self.factory.makePOTMsgSet(self.devel_potemplate)
         potmsgset.setSequence(self.devel_potemplate, 4)
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
+            pofile=self.devel_pofile, potmsgset=potmsgset,
             translations=[u"Imported translation"], is_current_upstream=True)
 
         # Fifth POTMsgSet is translated in import, but changed in Ubuntu.
         potmsgset = self.factory.makePOTMsgSet(self.devel_potemplate)
         potmsgset.setSequence(self.devel_potemplate, 5)
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
+            pofile=self.devel_pofile, potmsgset=potmsgset,
             translations=[u"Imported translation"], is_current_upstream=True)
         translation = self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
+            pofile=self.devel_pofile, potmsgset=potmsgset,
             translations=[u"LP translation"], is_current_upstream=False)
 
         # Sixth POTMsgSet is translated in LP only.
         potmsgset = self.factory.makePOTMsgSet(self.devel_potemplate)
         potmsgset.setSequence(self.devel_potemplate, 6)
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile, potmsgset=potmsgset,
+            pofile=self.devel_pofile, potmsgset=potmsgset,
             translations=[u"New translation"], is_current_upstream=False)
 
         removeSecurityProxy(self.devel_potemplate).messagecount = (
             self.devel_potemplate.getPOTMsgSetsCount())
 
         # Returns current, updates, rosetta, unreviewed counts.
-        stats = self.devel_sr_pofile.updateStatistics()
-        self.assertEquals(stats, (1, 1, 3, 2))
+        stats = self.devel_pofile.updateStatistics()
+        self.assertEquals((1, 1, 3, 2), stats)
 
-        self.assertEquals(self.devel_sr_pofile.messageCount(), 6)
-        self.assertEquals(self.devel_sr_pofile.translatedCount(), 4)
-        self.assertEquals(self.devel_sr_pofile.untranslatedCount(), 2)
-        self.assertEquals(self.devel_sr_pofile.currentCount(), 1)
-        self.assertEquals(self.devel_sr_pofile.rosettaCount(), 3)
-        self.assertEquals(self.devel_sr_pofile.updatesCount(), 1)
-        self.assertEquals(self.devel_sr_pofile.unreviewedCount(), 2)
+        self.assertEquals(6, self.devel_pofile.messageCount())
+        self.assertEquals(4, self.devel_pofile.translatedCount())
+        self.assertEquals(2, self.devel_pofile.untranslatedCount())
+        self.assertEquals(1, self.devel_pofile.currentCount())
+        self.assertEquals(3, self.devel_pofile.rosettaCount())
+        self.assertEquals(1, self.devel_pofile.updatesCount())
+        self.assertEquals(2, self.devel_pofile.unreviewedCount())
 
     def test_TranslationFileData_adapter(self):
         # Test that exporting works correctly with shared and diverged
         # messages.
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset,
             translations=["Shared translation"])
 
         # Get the adapter and extract only English singular and
         # first translation form from all messages.
         translation_file_data = getAdapter(
-            self.devel_sr_pofile, ITranslationFileData, 'all_messages')
+            self.devel_pofile, ITranslationFileData, 'all_messages')
         exported_messages = [
             (msg.singular_text, msg.translations[0])
             for msg in translation_file_data.messages]
@@ -832,7 +876,7 @@
 
         # When we add a diverged translation, only that is exported.
         self.factory.makeTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset,
             translations=["Diverged translation"],
             force_diverged=True)
@@ -840,7 +884,7 @@
         # Get the adapter and extract only English singular and
         # first translation form from all messages.
         translation_file_data = getAdapter(
-            self.devel_sr_pofile, ITranslationFileData, 'all_messages')
+            self.devel_pofile, ITranslationFileData, 'all_messages')
         exported_messages = [
             (msg.singular_text, msg.translations[0])
             for msg in translation_file_data.messages]
@@ -1003,9 +1047,9 @@
                                                              name="messages")
 
         # We'll use two PO files, one for each series.
-        self.devel_sr_pofile = self.factory.makePOFile(
+        self.devel_pofile = self.factory.makePOFile(
             'sr', self.devel_potemplate)
-        self.stable_sr_pofile = self.factory.makePOFile(
+        self.stable_pofile = self.factory.makePOFile(
             'sr', self.stable_potemplate)
 
         # Create two POTMsgSets that can be used to test in what order
@@ -1016,19 +1060,19 @@
         self.potmsgset2.setSequence(self.devel_potemplate, 2)
 
     def test_getPOTMsgSetTranslated_ordering(self):
-        # Translate both POTMsgSets in devel_sr_pofile, so
+        # Translate both POTMsgSets in devel_pofile, so
         # they are returned with getPOTMsgSetTranslated() call.
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset1,
             translations=["Shared translation"])
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset2,
             translations=["Another shared translation"])
 
         translated_potmsgsets = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(
             [self.potmsgset1, self.potmsgset2], translated_potmsgsets)
 
@@ -1039,20 +1083,20 @@
 
         # And they are returned in the new order as desired.
         translated_potmsgsets = list(
-            self.stable_sr_pofile.getPOTMsgSetTranslated())
+            self.stable_pofile.getPOTMsgSetTranslated())
         self.assertEquals(
             [self.potmsgset2, self.potmsgset1], translated_potmsgsets)
 
         # Order is unchanged for the previous template.
         translated_potmsgsets = list(
-            self.devel_sr_pofile.getPOTMsgSetTranslated())
+            self.devel_pofile.getPOTMsgSetTranslated())
         self.assertEquals(
             [self.potmsgset1, self.potmsgset2], translated_potmsgsets)
 
     def test_getPOTMsgSetUntranslated_ordering(self):
-        # Both POTMsgSets in devel_sr_pofile are untranslated.
+        # Both POTMsgSets in devel_pofile are untranslated.
         untranslated_potmsgsets = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(
             [self.potmsgset1, self.potmsgset2], untranslated_potmsgsets)
 
@@ -1063,42 +1107,42 @@
 
         # And they are returned in the new order as desired.
         untranslated_potmsgsets = list(
-            self.stable_sr_pofile.getPOTMsgSetUntranslated())
+            self.stable_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(
             [self.potmsgset2, self.potmsgset1], untranslated_potmsgsets)
 
         # Order is unchanged for the previous template.
         untranslated_potmsgsets = list(
-            self.devel_sr_pofile.getPOTMsgSetUntranslated())
+            self.devel_pofile.getPOTMsgSetUntranslated())
         self.assertEquals(
             [self.potmsgset1, self.potmsgset2], untranslated_potmsgsets)
 
     def test_getPOTMsgSetChangedInUbuntu_ordering(self):
-        # Suggest a translation on both POTMsgSets in devel_sr_pofile,
+        # Suggest a translation on both POTMsgSets in devel_pofile,
         # so they are returned with getPOTMsgSetWithNewSuggestions() call.
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset1,
             translations=["Imported"],
             is_current_upstream=True)
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset1,
             translations=["Changed"],
             is_current_upstream=False)
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset2,
             translations=["Another imported"],
             is_current_upstream=True)
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset2,
             translations=["Another changed"],
             is_current_upstream=False)
 
         potmsgsets = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(
             [self.potmsgset1, self.potmsgset2], potmsgsets)
 
@@ -1109,28 +1153,28 @@
 
         # And they are returned in the new order as desired.
         potmsgsets = list(
-            self.stable_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.stable_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(
             [self.potmsgset2, self.potmsgset1], potmsgsets)
 
         # Order is unchanged for the previous template.
         potmsgsets = list(
-            self.devel_sr_pofile.getPOTMsgSetChangedInUbuntu())
+            self.devel_pofile.getPOTMsgSetChangedInUbuntu())
         self.assertEquals(
             [self.potmsgset1, self.potmsgset2], potmsgsets)
 
     def test_getPOTMsgSetWithErrors_ordering(self):
-        # Suggest a translation on both POTMsgSets in devel_sr_pofile,
+        # Suggest a translation on both POTMsgSets in devel_pofile,
         # so they are returned with getPOTMsgSetWithNewSuggestions() call.
         imported1 = self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset1,
             translations=["Imported"],
             is_current_upstream=True)
         removeSecurityProxy(imported1).validation_status = (
             TranslationValidationStatus.UNKNOWNERROR)
         imported2 = self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset2,
             translations=["Another imported"],
             is_current_upstream=True)
@@ -1138,7 +1182,7 @@
             TranslationValidationStatus.UNKNOWNERROR)
 
         potmsgsets = list(
-            self.devel_sr_pofile.getPOTMsgSetWithErrors())
+            self.devel_pofile.getPOTMsgSetWithErrors())
         self.assertEquals(
             [self.potmsgset1, self.potmsgset2], potmsgsets)
 
@@ -1149,13 +1193,13 @@
 
         # And they are returned in the new order as desired.
         potmsgsets = list(
-            self.stable_sr_pofile.getPOTMsgSetWithErrors())
+            self.stable_pofile.getPOTMsgSetWithErrors())
         self.assertEquals(
             [self.potmsgset2, self.potmsgset1], potmsgsets)
 
         # Order is unchanged for the previous template.
         potmsgsets = list(
-            self.devel_sr_pofile.getPOTMsgSetWithErrors())
+            self.devel_pofile.getPOTMsgSetWithErrors())
         self.assertEquals(
             [self.potmsgset1, self.potmsgset2], potmsgsets)
 
@@ -1190,11 +1234,11 @@
 
         # Give the method something to search for.
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset1,
             translations=["Shared translation"])
         self.factory.makeSharedTranslationMessage(
-            pofile=self.devel_sr_pofile,
+            pofile=self.devel_pofile,
             potmsgset=self.potmsgset2,
             translations=["Another shared translation"])
 
@@ -1203,7 +1247,7 @@
         removeSecurityProxy(self.potmsgset2).sequence = 1
 
         potmsgsets = list(
-            self.devel_sr_pofile.findPOTMsgSetsContaining("translation"))
+            self.devel_pofile.findPOTMsgSetsContaining("translation"))
 
         # Order ignores potmsgset.sequence.
         self.assertEquals(
@@ -1627,11 +1671,10 @@
         # Adding a suggestion (i.e. unused translation)
         # will not change the current count when there's
         # already an imported message.
-        self.factory.makeTranslationMessage(
+        self.factory.makeSuggestion(
             pofile=self.pofile,
             potmsgset=self.potmsgset,
-            translations=["A suggestion"],
-            suggestion=True)
+            translations=["A suggestion"])
         self.pofile.updateStatistics()
         self.assertEquals(self.pofile.currentCount(), 1)
 

=== modified file 'lib/lp/translations/tests/test_potmsgset.py'
--- lib/lp/translations/tests/test_potmsgset.py	2010-08-13 05:02:57 +0000
+++ lib/lp/translations/tests/test_potmsgset.py	2010-08-17 09:48:55 +0000
@@ -273,56 +273,54 @@
         serbian = sr_pofile.language
 
         # When there are no suggestions, empty list is returned.
-        self.assertEquals(
-            set(self.potmsgset.getLocalTranslationMessages(
-                self.devel_potemplate, serbian)),
-            set([]))
+        self.assertContentEqual(
+            [],
+            self.potmsgset.getLocalTranslationMessages(
+                self.devel_potemplate, serbian))
 
         # A shared suggestion is shown in both templates.
-        shared_suggestion = self.factory.makeSharedTranslationMessage(
-            pofile=sr_pofile, potmsgset=self.potmsgset, suggestion=True)
-        self.assertEquals(
-            set(self.potmsgset.getLocalTranslationMessages(
-                self.devel_potemplate, serbian)),
-            set([shared_suggestion]))
-        self.assertEquals(
-            set(self.potmsgset.getLocalTranslationMessages(
-                self.stable_potemplate, serbian)),
-            set([shared_suggestion]))
+        shared_suggestion = self.factory.makeSuggestion(
+            pofile=sr_pofile, potmsgset=self.potmsgset)
+        self.assertContentEqual(
+            [shared_suggestion],
+            self.potmsgset.getLocalTranslationMessages(
+                self.devel_potemplate, serbian))
+        self.assertContentEqual(
+            [shared_suggestion],
+            self.potmsgset.getLocalTranslationMessages(
+                self.stable_potemplate, serbian))
 
         # A suggestion on another PO file is still shown in both templates.
-        another_suggestion = self.factory.makeSharedTranslationMessage(
-            pofile=sr_stable_pofile, potmsgset=self.potmsgset,
-            suggestion=True)
-        self.assertEquals(
-            set(self.potmsgset.getLocalTranslationMessages(
-                self.devel_potemplate, serbian)),
-            set([shared_suggestion, another_suggestion]))
-        self.assertEquals(
-            set(self.potmsgset.getLocalTranslationMessages(
-                self.stable_potemplate, serbian)),
-            set([shared_suggestion, another_suggestion]))
+        another_suggestion = self.factory.makeSuggestion(
+            pofile=sr_stable_pofile, potmsgset=self.potmsgset)
+        self.assertContentEqual(
+            [shared_suggestion, another_suggestion],
+            self.potmsgset.getLocalTranslationMessages(
+                self.devel_potemplate, serbian))
+        self.assertContentEqual(
+            [shared_suggestion, another_suggestion],
+            self.potmsgset.getLocalTranslationMessages(
+                self.stable_potemplate, serbian))
 
         # Setting one of the suggestions as current will leave
         # them both 'reviewed' and thus hidden.
         current_translation = self.factory.makeSharedTranslationMessage(
-            pofile=sr_pofile, potmsgset=self.potmsgset, suggestion=False)
-        self.assertEquals(
-            set(self.potmsgset.getLocalTranslationMessages(
-                self.devel_potemplate, serbian)),
-            set([]))
+            pofile=sr_pofile, potmsgset=self.potmsgset)
+        self.assertContentEqual(
+            [],
+            self.potmsgset.getLocalTranslationMessages(
+                self.devel_potemplate, serbian))
 
     def test_getLocalTranslationMessages_empty_message(self):
         # An empty suggestion is never returned.
         self.potmsgset.setSequence(self.stable_potemplate, 1)
         pofile = self.factory.makePOFile('sr', self.stable_potemplate)
-        empty_suggestion = self.factory.makeSharedTranslationMessage(
-            pofile=pofile, potmsgset=self.potmsgset, suggestion=True,
-            translations=[""])
-        self.assertEquals(
-            set([]),
-            set(self.potmsgset.getLocalTranslationMessages(
-                self.stable_potemplate, pofile.language)))
+        empty_suggestion = self.factory.makeSuggestion(
+            pofile=pofile, potmsgset=self.potmsgset, translations=[None])
+        self.assertContentEqual(
+            [],
+            self.potmsgset.getLocalTranslationMessages(
+                self.stable_potemplate, pofile.language))
 
     def test_getExternallyUsedTranslationMessages(self):
         """Test retrieval of externally used translations."""
@@ -349,9 +347,8 @@
 
         # If there are only suggestions on the external POTMsgSet,
         # no externally used suggestions are returned.
-        external_suggestion = self.factory.makeSharedTranslationMessage(
-            pofile=external_pofile, potmsgset=external_potmsgset,
-            suggestion=True)
+        external_suggestion = self.factory.makeSuggestion(
+            pofile=external_pofile, potmsgset=external_potmsgset)
 
         transaction.commit()
 
@@ -363,7 +360,7 @@
         # it is returned as the externally used suggestion.
         imported_translation = self.factory.makeSharedTranslationMessage(
             pofile=external_pofile, potmsgset=external_potmsgset,
-            suggestion=False, is_current_upstream=True)
+            is_current_upstream=True)
         imported_translation.makeCurrentUbuntu(False)
 
         transaction.commit()
@@ -376,7 +373,7 @@
         # it is returned as the externally used suggestion as well.
         current_translation = self.factory.makeSharedTranslationMessage(
             pofile=external_pofile, potmsgset=external_potmsgset,
-            suggestion=False, is_current_upstream=False)
+            is_current_upstream=False)
 
         transaction.commit()
 
@@ -409,9 +406,8 @@
 
         # If there is a suggestion on the external POTMsgSet,
         # it is returned.
-        external_suggestion = self.factory.makeSharedTranslationMessage(
-            pofile=external_pofile, potmsgset=external_potmsgset,
-            suggestion=True)
+        external_suggestion = self.factory.makeSuggestion(
+            pofile=external_pofile, potmsgset=external_potmsgset)
 
         transaction.commit()
 
@@ -423,7 +419,7 @@
         # POTMsgSet, it is not returned as the external suggestion.
         imported_translation = self.factory.makeSharedTranslationMessage(
             pofile=external_pofile, potmsgset=external_potmsgset,
-            suggestion=False, is_current_upstream=True)
+            is_current_upstream=True)
         imported_translation.makeCurrentUbuntu(False)
 
         transaction.commit()
@@ -436,7 +432,7 @@
         # considered an external suggestion.
         current_translation = self.factory.makeSharedTranslationMessage(
             pofile=external_pofile, potmsgset=external_potmsgset,
-            suggestion=False, is_current_upstream=False)
+            is_current_upstream=False)
 
         transaction.commit()
 
@@ -769,13 +765,12 @@
             removeSecurityProxy(self.pofile), self.potmsgset,
             translations=[u'trans1'], reviewer=self.factory.makePerson(),
             is_current_upstream=True, date_updated=self.now())
-        self.suggestion1 = self.factory.makeTranslationMessage(
-            self.pofile, self.potmsgset, suggestion=True,
-            translations=[u'sugg1'], reviewer=self.factory.makePerson(),
-            date_updated=self.now())
-        self.suggestion2 = self.factory.makeTranslationMessage(
-            self.pofile, self.potmsgset, suggestion=True,
-            translations=[u'sugg2'], date_updated=self.now())
+        self.suggestion1 = self.factory.makeSuggestion(
+            self.pofile, self.potmsgset, translations=[u'sugg1'],
+            date_created=self.now())
+        self.suggestion2 = self.factory.makeSuggestion(
+            self.pofile, self.potmsgset, translations=[u'sugg2'],
+            date_created=self.now())
         self._setDateCreated(self.suggestion2)
 
     def test_dismiss_all(self):

=== modified file 'lib/lp/translations/tests/test_translatablemessage.py'
--- lib/lp/translations/tests/test_translatablemessage.py	2010-03-24 13:56:15 +0000
+++ lib/lp/translations/tests/test_translatablemessage.py	2010-08-17 09:48:55 +0000
@@ -44,13 +44,17 @@
             is_current_ubuntu or is_current_upstream or is_diverged)
         if translation is not None:
             translation = [translation]
-        return self.factory.makeTranslationMessage(
-            pofile=self.pofile, potmsgset=self.potmsgset,
-            translations=translation,
-            suggestion=is_suggestion,
-            is_current_upstream=is_current_upstream,
-            force_diverged=is_diverged,
-            date_updated=date_updated)
+        if is_suggestion:
+            return self.factory.makeSuggestion(
+                pofile=self.pofile, potmsgset=self.potmsgset,
+                translations=translation, date_created=date_updated)
+        else:
+            return self.factory.makeTranslationMessage(
+                pofile=self.pofile, potmsgset=self.potmsgset,
+                translations=translation,
+                is_current_upstream=is_current_upstream,
+                force_diverged=is_diverged,
+                date_updated=date_updated)
 
 
 class TestTranslatableMessage(TestTranslatableMessageBase):
@@ -172,24 +176,24 @@
         super(TestTranslatableMessageSuggestions, self).setUp()
         self.now = self.gen_now().next
         self.suggestion1 = self._createTranslation(date_updated=self.now())
-        self.current =  self._createTranslation(is_current_ubuntu=True,
-                                                date_updated=self.now())
+        self.current = self._createTranslation(
+            is_current_ubuntu=True, date_updated=self.now())
         self.suggestion2 = self._createTranslation(date_updated=self.now())
         self.message = TranslatableMessage(self.potmsgset, self.pofile)
 
     def test_getAllSuggestions(self):
-        # There are three different methods to return 
+        # There are three different methods to return.
         suggestions = self.message.getAllSuggestions()
         self.assertContentEqual([self.suggestion1, self.suggestion2],
                                 suggestions)
 
     def test_getDismissedSuggestions(self):
-        # There are three different methods to return 
+        # There are three different methods to return.
         suggestions = self.message.getDismissedSuggestions()
         self.assertContentEqual([self.suggestion1], suggestions)
 
     def test_getUnreviewedSuggestions(self):
-        # There are three different methods to return 
+        # There are three different methods to return.
         suggestions = self.message.getUnreviewedSuggestions()
         self.assertContentEqual([self.suggestion2], suggestions)
 

=== modified file 'lib/lp/translations/tests/test_translations_to_review.py'
--- lib/lp/translations/tests/test_translations_to_review.py	2010-05-07 12:29:23 +0000
+++ lib/lp/translations/tests/test_translations_to_review.py	2010-08-17 09:48:55 +0000
@@ -26,6 +26,7 @@
 
 class ReviewTestMixin:
     """Base for testing which translations a reviewer can review."""
+
     def setUpMixin(self, for_product=True):
         """Set up test environment.
 
@@ -82,10 +83,10 @@
 
         later_time = self.base_time + timedelta(0, 3600)
         self.suggestion = removeSecurityProxy(
-            self.factory.makeTranslationMessage(
+            self.factory.makeSuggestion(
                 potmsgset=self.potmsgset, pofile=self.pofile,
                 translator=self.factory.makePerson(), translations=['wi'],
-                date_updated=later_time, suggestion=True))
+                date_created=later_time))
 
         self.assertTrue(self.translation.is_current_ubuntu)
         self.pofile.updateStatistics()
@@ -109,6 +110,7 @@
 
     Can be applied to product or distribution setups.
     """
+
     def test_OneFileToReview(self):
         # In the base case, the method finds one POFile for self.person
         # to review.

=== modified file 'lib/lp/translations/utilities/sanitize.py'
--- lib/lp/translations/utilities/sanitize.py	2010-03-26 20:14:32 +0000
+++ lib/lp/translations/utilities/sanitize.py	2010-08-17 09:48:55 +0000
@@ -51,8 +51,7 @@
         """Find out which newline style is used in text."""
         error_message = (
             "%s text (%r) mixes different newline markers." % (
-                text_name, text)
-            )
+                text_name, text))
         style = None
         # To avoid confusing the single-character newline styles for mac and
         # unix with the two-character windows one, remove the windows-style
@@ -169,6 +168,9 @@
     :param pluralforms: The number of expected pluralforms
     """
     # Sanitize all given translations.
+    # Make sure the translations are stored in a dict.
+    if isinstance(translations, (list, tuple)):
+        translations = dict(enumerate(translations))
     # Unneeded plural forms are stored as well (needed since we may
     # have incorrect plural form data, so we can just reactivate them
     # once we fix the plural information for the language)
@@ -188,4 +190,3 @@
 # There will be a different function for translation coming from imports but
 # for now it is identical to the one used in browser code.
 sanitize_translations_from_import = sanitize_translations_from_webui
-

=== modified file 'lib/lp/translations/utilities/tests/test_sanitize.py'
--- lib/lp/translations/utilities/tests/test_sanitize.py	2010-03-26 19:37:58 +0000
+++ lib/lp/translations/utilities/tests/test_sanitize.py	2010-08-17 09:48:55 +0000
@@ -203,8 +203,23 @@
             }
         self.assertEqual(
             expected_sanitized,
-            sanitize_translations_from_webui(self.english, translations, 3)
-            )
+            sanitize_translations_from_webui(self.english, translations, 3))
+
+    def test_sanitize_translations_not_in_dict(self):
+        # A list is converted to a dictionary.
+        translations = [
+            u'Pluralform 0',
+            u'Pluralform 1',
+            u'Pluralform 2',
+            ]
+        expected_sanitized = {
+            0: u'Pluralform 0',
+            1: u'Pluralform 1',
+            2: u'Pluralform 2',
+            }
+        self.assertEqual(
+            expected_sanitized,
+            sanitize_translations_from_webui(self.english, translations, 3))
 
     def test_sanitize_translations_missing_pluralform(self):
         # Missing plural forms are normalized to None.
@@ -219,8 +234,7 @@
             }
         self.assertEqual(
             expected_sanitized,
-            sanitize_translations_from_webui(self.english, translations, 3)
-            )
+            sanitize_translations_from_webui(self.english, translations, 3))
 
     def test_sanitize_translations_excess_pluralform(self):
         # Excess plural forms are sanitized, too.
@@ -238,8 +252,7 @@
             }
         self.assertEqual(
             expected_sanitized,
-            sanitize_translations_from_webui(self.english, translations, 3)
-            )
+            sanitize_translations_from_webui(self.english, translations, 3))
 
 
 def test_suite():

=== modified file 'lib/lp/translations/utilities/tests/test_superfastimports.py'
--- lib/lp/translations/utilities/tests/test_superfastimports.py	2010-03-23 21:07:11 +0000
+++ lib/lp/translations/utilities/tests/test_superfastimports.py	2010-08-17 09:48:55 +0000
@@ -13,6 +13,7 @@
 from lp.translations.utilities.translation_common_format import (
     TranslationMessageData)
 
+
 class TestSuperFastImports(TestCaseWithFactory):
     """Test how ExistingPOFileInDatabase cache works."""
 
@@ -66,8 +67,7 @@
     def test_inactive_messages(self):
         # Make sure non-current messages (i.e. suggestions) are
         # not cached in ExistingPOFileInDatabase.
-        inactive_message = self.factory.makeTranslationMessage(
-            pofile=self.pofile, suggestion=True)
+        inactive_message = self.factory.makeSuggestion(pofile=self.pofile)
         cached_file = ExistingPOFileInDatabase(self.pofile)
         message_data = self.getTranslationMessageData(inactive_message)
         self.assertFalse(

=== modified file 'lib/lp/translations/windmill/tests/test_pofile_translate.py'
--- lib/lp/translations/windmill/tests/test_pofile_translate.py	2010-05-24 16:20:27 +0000
+++ lib/lp/translations/windmill/tests/test_pofile_translate.py	2010-08-17 09:48:55 +0000
@@ -7,6 +7,7 @@
 __all__ = []
 
 import transaction
+from zope.security.proxy import removeSecurityProxy
 
 from canonical.launchpad.windmill.testing import constants, lpuser
 from lp.translations.windmill.testing import TranslationsWindmillLayer
@@ -151,9 +152,11 @@
         current_translation = self.factory.makeTranslationMessage(
             pofile=pofile, potmsgset=potmsgset, translations=['current'])
         transaction.commit()
-        suggestion = self.factory.makeTranslationMessage(
-            pofile=pofile, potmsgset=potmsgset,
-            translations=['suggestion'], suggestion=True)
+        suggestion = self.factory.makeSuggestion(
+            pofile=pofile, potmsgset=potmsgset, translations=['suggestion'])
+        # XXX henninge 2010-08-13 bug=597539: The view code depends on the
+        # pofile attribute being set.
+        removeSecurityProxy(suggestion).pofile = pofile
         transaction.commit()
         logout()
 
@@ -484,4 +487,3 @@
             reviewer and current_is_reviewer or
             translator and not current_is_reviewer)
         assert switch_done is True, "Could not switch working mode."
-