def test_publish(self): upload = self.uploadTestData() transaction.commit() upload.queue_root.realiseUpload(self.logger) # Test if the job was created correctly jobs = list(PackageTranslationsUploadJob.iterReady()) self.assertEqual(1, len(jobs)) job = jobs[0] # Assert if the job corresponds to the file we uploaded self.assertEqual(job.sourcepackagename, self.spr.sourcepackagename) self.assertEqual(job.libraryfilealias.filename, self.translations_file) # Test if the pmount translations tarball files were added to the # translation import queue with dbuser("upload_package_translations_job"): job.run() self.assertContentEqual(self._getImportableFilesFromTarball(), self._getQueuePaths()) self.factory.makePOTemplate( distroseries=self.breezy_autotest, sourcepackagename=self.spr.sourcepackagename, path="po/pmount.pot", translation_domain=self.package_name) # Approve all translations in the queue with dbuser("translations_import_queue_gardener"): gardener = ImportQueueGardener( 'translations-import-queue-gardener', logger=self.logger, test_args=[]) gardener.main() # Import all approved translations with dbuser("poimport"): importer = TranslationsImport('poimport', logger=self.logger, test_args=[]) importer.main() # Test if all translations in the queue were successfully imported self.assertContentEqual( self._getImportableFilesFromTarball(), self._getQueuePaths(import_status=RosettaImportStatus.IMPORTED))
def setUp(self): super(TestTranslationsImport, self).setUp() self.queue = TranslationImportQueue() self.script = TranslationsImport('poimport', test_args=[]) self.script.logger.setLevel(logging.FATAL) self.owner = self.factory.makePerson()
class TestTranslationsImport(TestCaseWithFactory): layer = LaunchpadScriptLayer def setUp(self): super(TestTranslationsImport, self).setUp() self.queue = TranslationImportQueue() self.script = TranslationsImport('poimport', test_args=[]) self.script.logger.setLevel(logging.FATAL) self.owner = self.factory.makePerson() def _makeProductSeries(self): """Make a product series called 'trunk'.""" return self.factory.makeProduct(owner=self.owner).getSeries('trunk') def _makeEntry(self, path, **kwargs): """Produce a queue entry.""" uploader = kwargs.pop('uploader', self.owner) return self.queue.addOrUpdateEntry( path, '# Nothing here', False, uploader, **kwargs) def _makeApprovedEntry(self, uploader): """Produce an approved queue entry.""" path = '%s.pot' % self.factory.getUniqueString() series = self.factory.makeProductSeries() template = self.factory.makePOTemplate(series) entry = self._makeEntry( path, uploader=uploader, potemplate=template, productseries=template.productseries) entry.status = RosettaImportStatus.APPROVED return entry def _getEmailRecipients(self): """List the recipients of all pending outgoing emails.""" return sum([ recipients for sender, recipients, text in stub.test_emails], []) def test_describeEntry_without_target(self): productseries = self._makeProductSeries() entry = self._makeEntry('foo.po', productseries=productseries) description = self.script._describeEntry(entry) pattern = "'foo.po' \(id [0-9]+\) in [A-Za-z0-9_-]+ trunk series$" self.assertNotEqual(None, re.match(pattern, description)) def test_describeEntry_for_pofile(self): productseries = self._makeProductSeries() template = self.factory.makePOTemplate(productseries=productseries) pofile = template.newPOFile('nl') entry = self._makeEntry( 'foo.po', productseries=productseries, potemplate=template, pofile=pofile) description = self.script._describeEntry(entry) pattern = "Dutch \(nl\) translation of .* in .* trunk \(id [0-9]+\)$" self.assertNotEqual(None, re.match(pattern, description)) def test_describeEntry_for_template(self): productseries = self._makeProductSeries() template = self.factory.makePOTemplate(productseries=productseries) entry = self._makeEntry( 'foo.pot', productseries=productseries, potemplate=template) description = self.script._describeEntry(entry) pattern = 'Template "[^"]+" in [A-Za-z0-9_-]+ trunk \(id [0-9]+\)$' self.assertNotEqual(None, re.match(pattern, description)) def test_checkEntry(self): productseries = self._makeProductSeries() template = self.factory.makePOTemplate(productseries=productseries) entry = self._makeEntry( 'foo.pot', productseries=productseries, potemplate=template) self.assertTrue(self.script._checkEntry(entry)) def test_checkEntry_without_target(self): productseries = self._makeProductSeries() entry = self._makeEntry('foo.pot', productseries=productseries) self.assertFalse(self.script._checkEntry(entry)) self.assertIn( "Entry is approved but has no place to import to.", self.script.failures.keys()) def test_checkEntry_misapproved_product(self): productseries = self._makeProductSeries() template = self.factory.makePOTemplate() entry = self._makeEntry( 'foo.pot', productseries=productseries, potemplate=template) self.assertNotEqual(None, entry.import_into) self.assertFalse(self.script._checkEntry(entry)) self.assertIn( "Entry was approved for the wrong productseries.", self.script.failures.keys()) def test_checkEntry_misapproved_package(self): package = self.factory.makeSourcePackage() other_series = self.factory.makeDistroSeries( distribution=package.distroseries.distribution) template = self.factory.makePOTemplate( distroseries=package.distroseries, sourcepackagename=package.sourcepackagename) entry = self._makeEntry( 'foo.pot', sourcepackagename=package.sourcepackagename, distroseries=other_series, potemplate=template) self.assertNotEqual(None, entry.import_into) self.assertFalse(self.script._checkEntry(entry)) self.assertIn( "Entry was approved for the wrong distroseries.", self.script.failures.keys()) def test_handle_serious_error(self): productseries = self._makeProductSeries() template = self.factory.makePOTemplate(productseries=productseries) entry = self._makeEntry( 'snaf.pot', productseries=productseries, potemplate=template) entry.potemplate = template entry.status = RosettaImportStatus.APPROVED self.assertNotEqual(None, entry.import_into) message = "The system has exploded." self.script._importEntry = FakeMethod( failure=OutrageousSystemError(message)) self.assertRaises(OutrageousSystemError, self.script.main) self.assertEqual(RosettaImportStatus.FAILED, entry.status) self.assertEqual(message, entry.error_output) def test_handle_unexpected_exception(self): # Unexpected exceptions during import are caught and reported. productseries = self._makeProductSeries() template = self.factory.makePOTemplate(productseries=productseries) entry = self._makeEntry( 'foo.pot', productseries=productseries, potemplate=template) entry.potemplate = template entry.status = RosettaImportStatus.APPROVED self.assertNotEqual(None, entry.import_into) message = "Nobody expects the Spanish Inquisition!" self.script._importEntry = FakeMethod( failure=UnexpectedException(message)) self.script.main() self.assertEqual(RosettaImportStatus.FAILED, entry.status) self.assertEqual(message, entry.error_output) def test_main_leaves_oops_handling_alone(self): """Ensure that script.main is not altering oops reporting.""" self.script.main() default_reporting = errorlog.ErrorReportingUtility() default_reporting.configure('error_reports') self.assertEqual(default_reporting.oops_prefix, errorlog.globalErrorUtility.oops_prefix) def test_notifies_uploader(self): entry = self._makeApprovedEntry(self.owner) transaction.commit() self.script._importEntry(entry) transaction.commit() self.assertEqual( [self.owner.preferredemail.email], self._getEmailRecipients()) def test_does_not_notify_vcs_imports(self): vcs_imports = getUtility(ILaunchpadCelebrities).vcs_imports entry = self._makeApprovedEntry(vcs_imports) transaction.commit() self.script._importEntry(entry) transaction.commit() self.assertEqual([], self._getEmailRecipients())
#!/usr/bin/python -S # # Copyright 2009 Canonical Ltd. This software is licensed under the # GNU Affero General Public License version 3 (see the file LICENSE). import _pythonpath from lp.services.config import config from lp.translations.scripts.po_import import TranslationsImport if __name__ == '__main__': script = TranslationsImport( 'rosetta-poimport', dbuser=config.poimport.dbuser) script.lock_and_run()
def test_copyFromPPAToArchiveWithTranslations(self): # Upload the package to a PPA and process it. src_upload, spph, bin_upload = self.uploadToPPA() target_archive = self.breezy_autotest.main_archive # Copy the source package with binaries from PPA to the main archive. # Give QueueAdmin permissions for the user so the upload will be # accepted right away. person = target_archive.owner for component in self.breezy_autotest.components: getUtility(IArchivePermissionSet).newQueueAdmin( target_archive, person, component) self.assertTrue( target_archive.canAdministerQueue(person, self.breezy_autotest.components, spph.pocket, self.breezy_autotest)) target_archive.copyPackage(source_name=self.package_name, version=self.version, from_archive=self.name16.archive, to_pocket='RELEASE', to_series=self.breezy_autotest.name, person=person, include_binaries=True, unembargo=True, auto_approve=True) # Get copy job and run it, should be enough to publish it copy_job_source = getUtility(IPlainPackageCopyJobSource) copy_job = copy_job_source.getActiveJobs(target_archive).one() with dbuser('copy_packages'): copy_job.run() published_source = target_archive.getPublishedSources(name='pmount')[0] self.assertIsNotNone(published_source) self.assertEqual( published_source.sourcepackagerelease.upload_archive.displayname, 'PPA for Foo Bar') self.assertEqual(published_source.archive.displayname, 'Primary Archive for Ubuntu Test') # Move package to main, as only main and restricted packages have # their translations processed. published_source = published_source.changeOverride( new_component="main") self.spr = published_source.sourcepackagerelease self.assertIsNotNone(published_source.getPublishedBinaries()) # Process the upload for it to create the PTUJ upload = IStore(PackageUpload).find(PackageUpload).order_by( Desc(PackageUpload.id)).first() upload.realiseUpload(self.logger) # Assert the job is created correctly ptu_jobs = list(PackageTranslationsUploadJob.iterReady()) self.assertNotEqual(len(ptu_jobs), 0) # Let's attachTranslations ptu_job = ptu_jobs[0] with dbuser('upload_package_translations_job'): ptu_job.run() # Test if the pmount translations tarball files were added to the # translation import queue self.assertContentEqual(self._getImportableFilesFromTarball(), self._getQueuePaths()) self.factory.makePOTemplate( distroseries=self.breezy_autotest, sourcepackagename=self.spr.sourcepackagename, path="po/pmount.pot", translation_domain=self.package_name) # Approve all translations in the queue with dbuser("translations_import_queue_gardener"): gardener = ImportQueueGardener( 'translations-import-queue-gardener', logger=self.logger, test_args=[]) gardener.main() # Import all approved translations with dbuser("poimport"): importer = TranslationsImport('poimport', logger=self.logger, test_args=[]) importer.main() # Test if all translations in the queue were successfully imported self.assertContentEqual( self._getImportableFilesFromTarball(), self._getQueuePaths(import_status=RosettaImportStatus.IMPORTED))
#!/usr/bin/python -S # # Copyright 2009 Canonical Ltd. This software is licensed under the # GNU Affero General Public License version 3 (see the file LICENSE). import _pythonpath from lp.services.config import config from lp.translations.scripts.po_import import TranslationsImport if __name__ == '__main__': script = TranslationsImport('rosetta-poimport', dbuser=config.poimport.dbuser) script.lock_and_run()
class TestTranslationsImport(TestCaseWithFactory): layer = LaunchpadScriptLayer def setUp(self): super(TestTranslationsImport, self).setUp() self.queue = TranslationImportQueue() self.script = TranslationsImport('poimport', test_args=[]) self.script.logger.setLevel(logging.FATAL) self.owner = self.factory.makePerson() def _makeProductSeries(self): """Make a product series called 'trunk'.""" return self.factory.makeProduct(owner=self.owner).getSeries('trunk') def _makeEntry(self, path, **kwargs): """Produce a queue entry.""" uploader = kwargs.pop('uploader', self.owner) return self.queue.addOrUpdateEntry(path, '# Nothing here', False, uploader, **kwargs) def _makeApprovedEntry(self, uploader): """Produce an approved queue entry.""" path = '%s.pot' % self.factory.getUniqueString() series = self.factory.makeProductSeries() template = self.factory.makePOTemplate(series) entry = self._makeEntry(path, uploader=uploader, potemplate=template, productseries=template.productseries) entry.status = RosettaImportStatus.APPROVED return entry def _getEmailRecipients(self): """List the recipients of all pending outgoing emails.""" return sum( [recipients for sender, recipients, text in stub.test_emails], []) def test_describeEntry_without_target(self): productseries = self._makeProductSeries() entry = self._makeEntry('foo.po', productseries=productseries) description = self.script._describeEntry(entry) pattern = "'foo.po' \(id [0-9]+\) in [A-Za-z0-9_-]+ trunk series$" self.assertNotEqual(None, re.match(pattern, description)) def test_describeEntry_for_pofile(self): productseries = self._makeProductSeries() template = self.factory.makePOTemplate(productseries=productseries) pofile = template.newPOFile('nl') entry = self._makeEntry('foo.po', productseries=productseries, potemplate=template, pofile=pofile) description = self.script._describeEntry(entry) pattern = "Dutch \(nl\) translation of .* in .* trunk \(id [0-9]+\)$" self.assertNotEqual(None, re.match(pattern, description)) def test_describeEntry_for_template(self): productseries = self._makeProductSeries() template = self.factory.makePOTemplate(productseries=productseries) entry = self._makeEntry('foo.pot', productseries=productseries, potemplate=template) description = self.script._describeEntry(entry) pattern = 'Template "[^"]+" in [A-Za-z0-9_-]+ trunk \(id [0-9]+\)$' self.assertNotEqual(None, re.match(pattern, description)) def test_checkEntry(self): productseries = self._makeProductSeries() template = self.factory.makePOTemplate(productseries=productseries) entry = self._makeEntry('foo.pot', productseries=productseries, potemplate=template) self.assertTrue(self.script._checkEntry(entry)) def test_checkEntry_without_target(self): productseries = self._makeProductSeries() entry = self._makeEntry('foo.pot', productseries=productseries) self.assertFalse(self.script._checkEntry(entry)) self.assertIn("Entry is approved but has no place to import to.", self.script.failures.keys()) def test_checkEntry_misapproved_product(self): productseries = self._makeProductSeries() template = self.factory.makePOTemplate() entry = self._makeEntry('foo.pot', productseries=productseries, potemplate=template) self.assertNotEqual(None, entry.import_into) self.assertFalse(self.script._checkEntry(entry)) self.assertIn("Entry was approved for the wrong productseries.", self.script.failures.keys()) def test_checkEntry_misapproved_package(self): package = self.factory.makeSourcePackage() other_series = self.factory.makeDistroSeries( distribution=package.distroseries.distribution) template = self.factory.makePOTemplate( distroseries=package.distroseries, sourcepackagename=package.sourcepackagename) entry = self._makeEntry('foo.pot', sourcepackagename=package.sourcepackagename, distroseries=other_series, potemplate=template) self.assertNotEqual(None, entry.import_into) self.assertFalse(self.script._checkEntry(entry)) self.assertIn("Entry was approved for the wrong distroseries.", self.script.failures.keys()) def test_handle_serious_error(self): productseries = self._makeProductSeries() template = self.factory.makePOTemplate(productseries=productseries) entry = self._makeEntry('snaf.pot', productseries=productseries, potemplate=template) entry.potemplate = template entry.status = RosettaImportStatus.APPROVED self.assertNotEqual(None, entry.import_into) message = "The system has exploded." self.script._importEntry = FakeMethod( failure=OutrageousSystemError(message)) self.assertRaises(OutrageousSystemError, self.script.main) self.assertEqual(RosettaImportStatus.FAILED, entry.status) self.assertEqual(message, entry.error_output) def test_handle_unexpected_exception(self): # Unexpected exceptions during import are caught and reported. productseries = self._makeProductSeries() template = self.factory.makePOTemplate(productseries=productseries) entry = self._makeEntry('foo.pot', productseries=productseries, potemplate=template) entry.potemplate = template entry.status = RosettaImportStatus.APPROVED self.assertNotEqual(None, entry.import_into) message = "Nobody expects the Spanish Inquisition!" self.script._importEntry = FakeMethod( failure=UnexpectedException(message)) self.script.main() self.assertEqual(RosettaImportStatus.FAILED, entry.status) self.assertEqual(message, entry.error_output) def test_main_leaves_oops_handling_alone(self): """Ensure that script.main is not altering oops reporting.""" self.script.main() default_reporting = errorlog.ErrorReportingUtility() default_reporting.configure('error_reports') self.assertEqual(default_reporting.oops_prefix, errorlog.globalErrorUtility.oops_prefix) def test_notifies_uploader(self): entry = self._makeApprovedEntry(self.owner) transaction.commit() self.script._importEntry(entry) transaction.commit() self.assertEqual([self.owner.preferredemail.email], self._getEmailRecipients()) def test_does_not_notify_vcs_imports(self): vcs_imports = getUtility(ILaunchpadCelebrities).vcs_imports entry = self._makeApprovedEntry(vcs_imports) transaction.commit() self.script._importEntry(entry) transaction.commit() self.assertEqual([], self._getEmailRecipients())