Merge lp:~jtv/launchpad/bug-507681 into lp:launchpad

[Jeroen T. Vermeulen]

Generate TranslationTemplatesBuildJobs.

[Jeroen T. Vermeulen (jtv)]

= Bug 507681 =

This is the main work bug 507681, which in turn is part of the effort to generate translation templates on the build farm, based on source in a bzr tree.

This branch gets the branch scanner to create TranslationTemplateBuildJobs for branch changes that may require new translation templates to be generated.

You'll see occasional reference to what we call "pottery." Pottery is a Translations module that deals with detecting various types of translation setup in a source code branch (we only support certain intltool setups at the moment) and generating templates from them.

Going through the diff step by step:

configs/testrunner/launchpad-lazr.conf
lib/canonical/config/schema-lazr.conf

A new configuration item, rosetta.generate_templates, enables or disables the generation of these jobs. It's off by default, to avoid interfering with Soyuz operation unnecessarily before these new jobs become useful. However the feature is enabled on the test runner.

lib/lp/code/interfaces/branchjob.py
lib/lp/code/model/branchjob.py

Two of the IRosettaUploadJobSource utility methods were published in its interface. I changed their names to follow our naming style, and (after consultation with Henning) hopefully made the docstrings a bit clearer.

These two methods are used to control importing of templates and POFiles from a branch into a productseries' translations. Normally those imports are triggered by a change to the branch, but the user can also request a one-time import on the productseries.

For the one-time imports, a parameter force_translations_upload is set to True. When it's set, the importer ignores whether a productseries attached to the branch wants automatic translation imports from it and just uploads anyway.

This is strictly speaking a bug; it does the wrong thing when multiple productseries use the same branch. I isolated the brokenness a tiny bit by not passing on the force_translations_upload parameter to the "are there any productseries using this branch" method in the utility. Since force_translations_upload is an option on the productseries using the branch, it's safe to skip the check for productseries when the parameter is True.

In findProductSeries (née _find_product_series), I unified the two alternative queries to express that there is really only a very small difference.

lib/lp/codehosting/scanner/branch_scanner.py
lib/lp/codehosting/scanner/bzrsync.py

Here is where I registered an extra hook that runs when changes are pushed to a branch. This is similar to what other branch jobs already do; the real logic is in the ITranslationTemplatesBuildJobSource utility for ease of testing.

lib/lp/translations/interfaces/translationtemplatesbuildjob.py
lib/lp/translations/model/translationtemplatesbuildjob.py

A bit more logic to see whether Launchpad should try to generate templates for a branch. For now we decided not to introduce a separate setting for this; we'll simply try to generate templates for each branch that has translation series importing templates from it.

Except that pottery has a function to check whether it's worth trying this. It makes no sense to bother a build-farm slave if a branch c...

[Paul Hummer (rockstar)]

I think this branch is quite good. I just have one piece of input, and that's a recent change to the branch scanner. I made the change, and anyone outside the code team probably wasn't aware, so it's probably good you changed.

branch_scanner.py is about to get deleted. We no longer use that codepath, and instead, use the BranchScanJob in lib/lp/code/model/branchjob.py - The event subscription stuff you currently have in branch_scanner should actually go there.

I promise this time I'll take a look tomorrow at the changes, and not let this branch go out as far as the last one (which I feel pretty sheepish about).

review: Needs Fixing (code)

[Jeroen T. Vermeulen (jtv)]

I've added the event handler to branchjob, but left the obsolete code as I had it so there's some pointless duplication. Better than courting disaster if things evolve further before the obsolete code is culled.

Is it okay now?

[Paul Hummer (rockstar)]

review: Approve (code)

=== modified file 'configs/testrunner/launchpad-lazr.conf'
--- configs/testrunner/launchpad-lazr.conf	2010-01-29 17:15:31 +0000
+++ configs/testrunner/launchpad-lazr.conf	2010-02-19 09:01:18 +0000
@@ -193,6 +193,9 @@
 error_dir: /var/tmp/poimport.test
 oops_prefix: TPOI
 
+[rosetta]
+generate_templates: True
+
 [rosettabranches]
 oops_prefix: TRSBR
 error_dir: /var/tmp/rosettabranches.test

=== modified file 'lib/canonical/config/schema-lazr.conf'
--- lib/canonical/config/schema-lazr.conf	2010-01-22 04:01:17 +0000
+++ lib/canonical/config/schema-lazr.conf	2010-02-19 09:01:18 +0000
@@ -1578,6 +1578,10 @@
 # datatype: integer
 translate_pages_max_batch_size: 50
 
+# Generate templates using the buildfarm?
+# datatype: boolean
+generate_templates: False
+
 [rosetta_pofile_stats]
 # In daily runs of pofile statistics update, check for
 # POFiles that have been updated in the last how many days.

=== modified file 'lib/lp/code/interfaces/branchjob.py'
--- lib/lp/code/interfaces/branchjob.py	2010-01-14 23:33:30 +0000
+++ lib/lp/code/interfaces/branchjob.py	2010-02-19 09:01:18 +0000
@@ -180,6 +180,30 @@
             given) whose status is neither "complete" nor "failed."
         """
 
+    def providesTranslationFiles(branch):
+        """Is anyone importing translation files from this branch?
+
+        This is used to check if any product series is related to the branch
+        in order to decide if a job needs to be created.
+
+        :param branch: The `IBranch` that is being scanned.
+        :return: Boolean.
+        """
+
+    def findProductSeries(branch, force_translations_upload=False):
+        """Find `ProductSeries` that import translation files from branch.
+
+        :param branch: The `IBranch` that is being scanned.
+        :param force_translations_upload: If True, return all
+            `ProductSeries` attached to this branch regardless of their
+            import mode settings.
+        :return: a list of `IProductSeries`.
+        """
+        # XXX JeroenVermeulen 2010-01-12 bug=521095: 
+        # force_translations_upload was meant to ignore import settings
+        # for one specific ProductSeries attached to the branch, not any
+        # ProductSeries attached to the branch.
+
 
 class IReclaimBranchSpaceJob(IRunnableJob):
     """A job to delete a branch from disk after its been deleted from the db.

=== modified file 'lib/lp/code/model/branchjob.py'
--- lib/lp/code/model/branchjob.py	2010-02-17 00:39:08 +0000
+++ lib/lp/code/model/branchjob.py	2010-02-19 09:01:18 +0000
@@ -1,4 +1,4 @@
-# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 __all__ = [
@@ -53,8 +53,8 @@
 from lp.codehosting.scanner.fixture import (
     Fixtures, ServerFixture, make_zope_event_fixture)
 from lp.codehosting.scanner.bzrsync import (
-    BzrSync, schedule_diff_updates, schedule_translation_upload
-)
+    BzrSync, schedule_diff_updates, schedule_translation_templates_build,
+    schedule_translation_upload)
 from lp.codehosting.vfs import (branch_id_to_path, get_multi_server,
     get_scanner_server)
 from lp.services.job.model.job import Job
@@ -296,10 +296,12 @@
             mergedetection.auto_merge_branches,
             mergedetection.auto_merge_proposals,
             schedule_diff_updates,
+            schedule_translation_templates_build,
             schedule_translation_upload,
             ]
-        fixture = Fixtures(
-            [ServerFixture(cls.server), make_zope_event_fixture(*event_handlers)])
+        fixture = Fixtures([
+            ServerFixture(cls.server),
+            make_zope_event_fixture(*event_handlers)])
         fixture.setUp()
         yield
         fixture.tearDown()
@@ -729,41 +731,22 @@
         return self.metadata['force_translations_upload']
 
     @classmethod
-    def _get_any_product_series(cls, branch, force_translations_upload):
-        """Find an affected product series.
-
-        This is used to check if any product series is related to the branch
-        in order to decide if a job needs to be created.
-
-        :param branch: The IBranch that is being scanned.
-        :param force_translations_upload: Flag to override the settings in the
-            product series and upload all translation files.
-        :returns: a list of IProductSeries objects.
-        """
-        return cls._find_product_series(branch,
-                                        force_translations_upload).any()
+    def providesTranslationFiles(cls, branch):
+        """See `IRosettaUploadJobSource`."""
+        return not cls.findProductSeries(branch).is_empty()
 
     @staticmethod
-    def _find_product_series(branch, force_translations_upload):
-        """Find affected product series.
-
-        :param branch: The IBranch that is being scanned.
-        :param force_translations_upload: Flag to override the settings in the
-            product series and upload all translation files.
-        :returns: a list of IProductSeries objects.
-        """
+    def findProductSeries(branch, force_translations_upload=False):
+        """See `IRosettaUploadJobSource`."""
         store = getUtility(IStoreSelector).get(MAIN_STORE, MASTER_FLAVOR)
-        if force_translations_upload:
-            productseries = store.find(
-                (ProductSeries),
-                ProductSeries.branch == branch)
-        else:
-            productseries = store.find(
-                (ProductSeries),
-                ProductSeries.branch == branch,
-                ProductSeries.translations_autoimport_mode !=
-                   TranslationsBranchImportMode.NO_IMPORT)
-        return productseries
+
+        conditions = [ProductSeries.branch == branch]
+        if not force_translations_upload:
+            import_mode = ProductSeries.translations_autoimport_mode
+            conditions.append(
+                import_mode != TranslationsBranchImportMode.NO_IMPORT)
+
+        return store.find(ProductSeries, And(*conditions))
 
     @classmethod
     def create(cls, branch, from_revision_id,
@@ -771,11 +754,11 @@
         """See `IRosettaUploadJobSource`."""
         if branch is None:
             return None
+
         if from_revision_id is None:
             from_revision_id = NULL_REVISION
-        productseries = cls._get_any_product_series(branch,
-                                                    force_translations_upload)
-        if productseries is not None:
+
+        if force_translations_upload or cls.providesTranslationFiles(branch):
             metadata = cls.getMetadata(from_revision_id,
                                        force_translations_upload)
             branch_job = BranchJob(
@@ -909,7 +892,7 @@
         self._init_translation_file_lists()
         # Get the product series that are connected to this branch and
         # that want to upload translations.
-        productseries = self._find_product_series(
+        productseries = self.findProductSeries(
             self.branch, self.force_translations_upload)
         translation_import_queue = getUtility(ITranslationImportQueue)
         for series in productseries:

=== modified file 'lib/lp/codehosting/scanner/branch_scanner.py'
--- lib/lp/codehosting/scanner/branch_scanner.py	2010-01-21 22:10:38 +0000
+++ lib/lp/codehosting/scanner/branch_scanner.py	2010-02-19 09:01:18 +0000
@@ -21,7 +21,8 @@
 from lp.codehosting.vfs import get_scanner_server
 from lp.codehosting.scanner import buglinks, email, mergedetection
 from lp.codehosting.scanner.bzrsync import (
-    BzrSync, schedule_diff_updates, schedule_translation_upload)
+    BzrSync, schedule_diff_updates, schedule_translation_templates_build,
+    schedule_translation_upload)
 from lp.codehosting.scanner.fixture import (
     Fixtures, make_zope_event_fixture, run_with_fixture, ServerFixture)
 from canonical.launchpad.webapp import canonical_url, errorlog
@@ -97,6 +98,7 @@
             mergedetection.auto_merge_branches,
             mergedetection.auto_merge_proposals,
             schedule_diff_updates,
+            schedule_translation_templates_build,
             schedule_translation_upload,
             ]
         server = get_scanner_server()

=== modified file 'lib/lp/codehosting/scanner/bzrsync.py'
--- lib/lp/codehosting/scanner/bzrsync.py	2010-01-07 04:48:10 +0000
+++ lib/lp/codehosting/scanner/bzrsync.py	2010-02-19 09:01:18 +0000
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 #
-# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Import version control metadata from a Bazaar branch into the database."""
@@ -10,12 +10,13 @@
 __all__ = [
     "BzrSync",
     'schedule_diff_updates',
+    'schedule_translation_templates_build',
     'schedule_translation_upload',
     ]
 
 import logging
-
 import pytz
+import transaction
 
 from zope.component import adapter, getUtility
 from zope.event import notify
@@ -27,8 +28,6 @@
 
 from lazr.uri import URI
 
-import transaction
-
 from lp.codehosting import iter_list_chunks
 from lp.codehosting.puller.worker import BranchMirrorer
 from lp.codehosting.scanner import events
@@ -37,6 +36,8 @@
 from lp.code.interfaces.branchjob import IRosettaUploadJobSource
 from lp.code.interfaces.branchrevision import IBranchRevisionSet
 from lp.code.interfaces.revision import IRevisionSet
+from lp.translations.interfaces.translationtemplatesbuildjob import (
+    ITranslationTemplatesBuildJobSource)
 
 UTC = pytz.timezone('UTC')
 
@@ -358,5 +359,11 @@
 
 
 @adapter(events.TipChanged)
+def schedule_translation_templates_build(tip_changed):
+    utility = getUtility(ITranslationTemplatesBuildJobSource)
+    utility.scheduleTranslationTemplatesBuild(tip_changed.db_branch)
+
+
+@adapter(events.TipChanged)
 def schedule_diff_updates(tip_changed):
     tip_changed.db_branch.scheduleDiffUpdates()

=== modified file 'lib/lp/translations/interfaces/translationtemplatesbuildjob.py'
--- lib/lp/translations/interfaces/translationtemplatesbuildjob.py	2010-01-12 23:37:32 +0000
+++ lib/lp/translations/interfaces/translationtemplatesbuildjob.py	2010-02-19 09:01:18 +0000
@@ -15,6 +15,13 @@
 class ITranslationTemplatesBuildJobSource(Interface):
     """Container for `TranslationTemplatesBuildJob`s."""
 
+    def generatesTemplates(branch):
+        """Can this branch usefully generate translation templates?
+
+        If yes, then use `create` to schedule a build-farm job to
+        generate the templates based on the source code in the branch.
+        """
+
     def create(branch):
         """Create new `TranslationTemplatesBuildJob`.
 
@@ -24,3 +31,6 @@
             generate templates for.
         :return: A new `TranslationTemplatesBuildJob`.
         """
+
+    def scheduleTranslationTemplatesBuild(branch):
+        """Schedule a translation templates build job, if appropriate."""

=== modified file 'lib/lp/translations/model/translationtemplatesbuildjob.py'
--- lib/lp/translations/model/translationtemplatesbuildjob.py	2010-01-15 01:20:20 +0000
+++ lib/lp/translations/model/translationtemplatesbuildjob.py	2010-02-19 09:01:18 +0000
@@ -11,6 +11,9 @@
 
 from zope.component import getUtility
 from zope.interface import classProvides, implements
+from zope.security.proxy import removeSecurityProxy
+
+from canonical.config import config
 
 from canonical.launchpad.webapp.interfaces import (
     DEFAULT_FLAVOR, IStoreSelector, MAIN_STORE, MASTER_FLAVOR)
@@ -18,11 +21,12 @@
 from lp.buildmaster.interfaces.buildfarmjob import (
     BuildFarmJobType, IBuildFarmJob, ISpecificBuildFarmJobClass)
 from lp.buildmaster.model.buildfarmjob import BuildFarmJob
-from lp.code.interfaces.branchjob import IBranchJob
+from lp.code.interfaces.branchjob import IBranchJob, IRosettaUploadJobSource
 from lp.code.model.branchjob import BranchJob, BranchJobDerived, BranchJobType
 from lp.soyuz.model.buildqueue import BuildQueue
 from lp.translations.interfaces.translationtemplatesbuildjob import (
     ITranslationTemplatesBuildJobSource)
+from lp.translations.pottery.detect_intltool import is_intltool_structure
 
 
 class TranslationTemplatesBuildJob(BranchJobDerived, BuildFarmJob):
@@ -61,6 +65,35 @@
         return '%s translation templates build' % self.branch.bzr_identity
 
     @classmethod
+    def _hasPotteryCompatibleSetup(cls, branch):
+        """Does `branch` look as if pottery can generate templates for it?
+
+        :param branch: A `Branch` object.
+        """
+        bzr_branch = removeSecurityProxy(branch).getBzrBranch()
+        return is_intltool_structure(bzr_branch.basis_tree())
+
+    @classmethod
+    def generatesTemplates(cls, branch):
+        """See `ITranslationTemplatesBuildJobSource`."""
+        if branch.private:
+            # We don't support generating template from private branches
+            # at the moment.
+            return False
+
+        utility = getUtility(IRosettaUploadJobSource)
+        if not utility.providesTranslationFiles(branch):
+            # Nobody asked for templates generated from this branch.
+            return False
+
+        if not cls._hasPotteryCompatibleSetup(branch):
+            # Nothing we could do with this branch if we wanted to.
+            return False
+
+        # Yay!  We made it.
+        return True
+
+    @classmethod
     def create(cls, branch):
         """See `ITranslationTemplatesBuildJobSource`."""
         store = getUtility(IStoreSelector).get(MAIN_STORE, MASTER_FLAVOR)
@@ -82,6 +115,17 @@
         return specific_job
 
     @classmethod
+    def scheduleTranslationTemplatesBuild(cls, branch):
+        """See `ITranslationTemplatesBuildJobSource`."""
+        if not config.rosetta.generate_templates:
+            # This feature is disabled by default.
+            return
+
+        if cls.generatesTemplates(branch):
+            # This branch is used for generating templates.
+            cls.create(branch)
+
+    @classmethod
     def getByJob(cls, job):
         """See `ISpecificBuildFarmJobClass`."""
         store = getUtility(IStoreSelector).get(MAIN_STORE, DEFAULT_FLAVOR)

=== modified file 'lib/lp/translations/tests/test_translationtemplatesbuildjob.py'
--- lib/lp/translations/tests/test_translationtemplatesbuildjob.py	2010-02-11 19:11:11 +0000
+++ lib/lp/translations/tests/test_translationtemplatesbuildjob.py	2010-02-19 09:01:18 +0000
@@ -8,17 +8,26 @@
 from zope.component import getUtility
 from zope.security.proxy import removeSecurityProxy
 
+from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
+from canonical.launchpad.interfaces.librarian import ILibraryFileAliasSet
 from canonical.launchpad.webapp.testing import verifyObject
-from canonical.testing import ZopelessDatabaseLayer
+from canonical.launchpad.webapp.interfaces import (
+    DEFAULT_FLAVOR, IStoreSelector, MAIN_STORE)
+from canonical.testing import LaunchpadZopelessLayer, ZopelessDatabaseLayer
 
 from lp.testing import TestCaseWithFactory
 
 from lp.buildmaster.interfaces.buildfarmjob import (
     IBuildFarmJob, ISpecificBuildFarmJobClass)
+from lp.buildmaster.interfaces.buildfarmjobbehavior import (
+    IBuildFarmJobBehavior)
 from lp.code.interfaces.branchjob import IBranchJob
+from lp.code.model.branchjob import BranchJob
 from lp.services.job.model.job import Job
 from lp.soyuz.interfaces.buildqueue import IBuildQueueSet
 from lp.soyuz.model.buildqueue import BuildQueue
+from lp.translations.interfaces.translations import (
+    TranslationsBranchImportMode)
 from lp.translations.interfaces.translationtemplatesbuildjob import (
     ITranslationTemplatesBuildJobSource)
 from lp.translations.model.translationtemplatesbuildjob import (
@@ -47,9 +56,7 @@
         verifyObject(IBranchJob, self.specific_job)
         verifyObject(IBuildFarmJob, self.specific_job)
 
-        # The class also implements a utility and
-        # ISpecificBuildFarmJobClass.
-        verifyObject(ITranslationTemplatesBuildJobSource, self.jobset)
+        # The class also implements ISpecificBuildFarmJobClass.
         verifyObject(ISpecificBuildFarmJobClass, TranslationTemplatesBuildJob)
 
         # Each of these jobs knows the branch it will operate on.
@@ -98,5 +105,158 @@
         self.assertEqual(1000, self.specific_job.score())
 
 
+class FakeTranslationTemplatesJobSource(TranslationTemplatesBuildJob):
+    """Fake utility class.
+
+    Allows overriding of _hasPotteryCompatibleSetup.
+
+    How do you fake a utility that is implemented as a class, not a
+    factory?  By inheriting from `TranslationTemplatesJob`, this class
+    "copies" the utility.  But you can make it fake the utility's
+    behavior by setting an attribute of the class (not an object!) at
+    the beginning of every test.
+    """
+    # Fake _hasPotteryCompatibleSetup, and if so, make it give what
+    # answer?
+    fake_pottery_compatibility = None
+
+    @classmethod
+    def _hasPotteryCompatibleSetup(cls, branch):
+        if cls.fake_pottery_compatibility is None:
+            # No fake compatibility setting call the real method.
+            return TranslationTemplatesBuildJob._hasPotteryCompatibleSetup(
+                branch)
+        else:
+            # Fake pottery compatibility.
+            return cls.fake_pottery_compatibility
+
+
+class TestTranslationTemplatesBuildJobSource(TestCaseWithFactory):
+    """Test `TranslationTemplatesBuildJobSource`."""
+
+    layer = LaunchpadZopelessLayer
+
+    def setUp(self):
+        super(TestTranslationTemplatesBuildJobSource, self).setUp()
+        self.jobsource = FakeTranslationTemplatesJobSource
+        self.jobsource.fake_pottery_compabitility = None
+
+    def tearDown(self):
+        self._fakePotteryCompatibleSetup(compatible=None)
+        super(TestTranslationTemplatesBuildJobSource, self).tearDown()
+
+    def _makeTranslationBranch(self, fake_pottery_compatible=None):
+        """Create a branch that provides translations for a productseries."""
+        if fake_pottery_compatible is None:
+            self.useBzrBranches()
+            branch, tree = self.create_branch_and_tree()
+        else:
+            branch = self.factory.makeAnyBranch()
+        product = removeSecurityProxy(branch.product)
+        trunk = product.getSeries('trunk')
+        trunk.branch = branch
+        trunk.translations_autoimport_mode = (
+            TranslationsBranchImportMode.IMPORT_TEMPLATES)
+
+        self._fakePotteryCompatibleSetup(fake_pottery_compatible)
+
+        return branch
+
+    def _fakePotteryCompatibleSetup(self, compatible=True):
+        """Mock up branch compatibility check.
+
+        :param compatible: Whether the mock check should say that
+            branches have a pottery-compatible setup, or that they
+            don't.
+        """
+        self.jobsource.fake_pottery_compatibility = compatible
+
+    def test_baseline(self):
+        utility = getUtility(ITranslationTemplatesBuildJobSource)
+        verifyObject(ITranslationTemplatesBuildJobSource, utility)
+
+    def test_generatesTemplates(self):
+        # A branch "generates templates" if it is a translation branch
+        # for a productseries that imports templates from it; is not
+        # private; and has a pottery compatible setup.
+        # For convenience we fake the pottery compatibility here.
+        branch = self._makeTranslationBranch(fake_pottery_compatible=True)
+        self.assertTrue(self.jobsource.generatesTemplates(branch))
+
+    def test_not_pottery_compatible(self):
+        # If pottery does not see any files it can work with in the
+        # branch, generatesTemplates returns False.
+        branch = self._makeTranslationBranch()
+        self.assertFalse(self.jobsource.generatesTemplates(branch))
+    
+    def test_branch_not_used(self):
+        # We don't generate templates branches not attached to series.
+        branch = self._makeTranslationBranch(fake_pottery_compatible=True)
+
+        trunk = branch.product.getSeries('trunk')
+        removeSecurityProxy(trunk).branch = None
+
+        self.assertFalse(self.jobsource.generatesTemplates(branch))
+
+    def test_not_importing_templates(self):
+        # We don't generate templates when imports are disabled.
+        branch = self._makeTranslationBranch(fake_pottery_compatible=True)
+
+        trunk = branch.product.getSeries('trunk')
+        removeSecurityProxy(trunk).translations_autoimport_mode = (
+            TranslationsBranchImportMode.NO_IMPORT)
+
+        self.assertFalse(self.jobsource.generatesTemplates(branch))
+
+    def test_private_branch(self):
+        # We don't generate templates for private branches.
+        branch = self._makeTranslationBranch(fake_pottery_compatible=True)
+        removeSecurityProxy(branch).private = True
+        self.assertFalse(self.jobsource.generatesTemplates(branch))
+
+    def test_scheduleTranslationTemplatesBuild(self):
+        # If the feature is enabled, scheduleTranslationTemplatesBuild
+        # will schedule a templates build whenever a change is pushed to
+        # a branch that generates templates.
+        branch = self._makeTranslationBranch(fake_pottery_compatible=True)
+
+        self.jobsource.scheduleTranslationTemplatesBuild(branch)
+
+        store = getUtility(IStoreSelector).get(MAIN_STORE, DEFAULT_FLAVOR)
+        branchjobs = list(store.find(BranchJob, BranchJob.branch == branch))
+        self.assertEqual(1, len(branchjobs))
+        self.assertEqual(branch, branchjobs[0].branch)
+
+
+class TestTranslationTemplatesBuildBehavior(TestCaseWithFactory):
+    """Test `TranslationTemplatesBuildBehavior`."""
+
+    layer = ZopelessDatabaseLayer
+
+    def setUp(self):
+        super(TestTranslationTemplatesBuildBehavior, self).setUp()
+        self.jobset = getUtility(ITranslationTemplatesBuildJobSource)
+        self.branch = self.factory.makeBranch()
+        self.specific_job = self.jobset.create(self.branch)
+        self.behavior = IBuildFarmJobBehavior(self.specific_job)
+
+    def test_getChroot(self):
+        # _getChroot produces the current chroot for the current Ubuntu
+        # release, on the nominated architecture for
+        # architecture-independent builds.
+        ubuntu = getUtility(ILaunchpadCelebrities).ubuntu
+        current_ubuntu = ubuntu.currentseries
+        distroarchseries = current_ubuntu.nominatedarchindep
+
+        # Set an arbitrary chroot file.
+        fake_chroot_file = getUtility(ILibraryFileAliasSet)[1]
+        distroarchseries.addOrUpdateChroot(fake_chroot_file)
+
+        chroot = self.behavior._getChroot()
+
+        self.assertNotEqual(None, chroot)
+        self.assertEqual(fake_chroot_file, chroot)
+
+
 def test_suite():
     return TestLoader().loadTestsFromName(__name__)