def test_async_import(self): """ Basic asynchronous import test with default large chunk size. """ res = self._do_import("account.move.csv", use_queue=True) self.assertFalse(res, repr(res)) # no moves should be created yet move_count = self.move_obj.search([("name", "in", ("TEST-1", "TEST-2", "TEST-3"))]) self.assertEqual(len(move_count), 0) # but we must have one job to split the file split_job = self.job_obj.search([]) self.assertEqual(len(split_job), 1) # job names are important self.assertEqual(split_job.name, "Import Account Entry from file account.move.csv") # perform job Job.load(self.env, split_job.uuid).perform() # check one job has been generated to load the file (one chunk) load_job = self.job_obj.search([("id", "!=", split_job.id)]) self.assertEqual(len(load_job), 1) self.assertEqual( load_job.name, "Import Account Entry from file account.move.csv - #0 - lines 2 to 10", ) # perform job Job.load(self.env, load_job.uuid).perform() self._check_import_result()
def test_30_export_all_categories(self): queue_job = self.env['queue.job'] existing_jobs = queue_job.search([]) # a job is created to export all products self.shopinvader_backend.export_all_category() new_jobs = queue_job.search([]) new_job = new_jobs - existing_jobs self.assertEqual(1, len(new_job)) job = Job.load(self.env, new_job.uuid) self.assertEqual(_('Prepare a batch export of indexes'), job.description) existing_jobs = new_jobs # perform the job job.perform() new_jobs = queue_job.search([]) new_job = new_jobs - existing_jobs self.assertEqual(1, len(new_job)) job = Job.load(self.env, new_job.uuid) count = self.env['shopinvader.category'].search_count([]) self.assertEqual( _("Export %d records of %d for index 'algolia-category'") % (count, count), job.description) # the last job is the one performing the export job = Job.load(self.env, new_job.uuid) with mock_api(self.env) as mocked_api: job.perform() self.assertTrue('algolia-category' in mocked_api.index) index = mocked_api.index['algolia-category'] self.assertEqual(1, len(index._calls), "All categories must be exported in 1 call") method, values = index._calls[0] self.assertEqual('add_objects', method) self.assertEqual(count, len(values), "All categories should be exported")
def test_batch(self): self.cr.execute('delete from queue_job') batch = self.env['queue.job.batch'].get_new_batch('TEST') self.assertFalse(batch.job_ids) model = self.env['test.queue.job'].with_context(job_batch=batch) job_1 = model.with_delay().testing_method() self.assertEqual(job_1.db_record().state, 'pending') job_2 = model.with_delay().testing_method() self.assertEqual(job_2.db_record().state, 'pending') batch.refresh() jobs = job_1.db_record() jobs |= job_2.db_record() self.assertEqual(jobs, batch.job_ids) batch.set_read() self.assertTrue(batch.is_read) self.assertEqual(batch.state, 'draft') self.assertEqual(job_2.state, 'pending') self.assertEqual(job_2.state, 'pending') batch.enqueue() self.assertEqual(batch.state, 'enqueued') self.assertEqual(job_2.state, 'pending') self.assertEqual(job_2.state, 'pending') job_domain = [ ('uuid', '!=', job_1.uuid), ('uuid', '!=', job_2.uuid), ] update = self.env['queue.job'].search(job_domain) self.assertFalse(update) job = Job.load(self.env, job_1.uuid) job.perform() job.set_done() job.store() update = self.env['queue.job'].search(job_domain) self.assertTrue(update) self.assertEqual(1, len(update)) job = Job.load(self.env, update.uuid) job.perform() job.set_done() job.store() batch.refresh() self.assertEqual(batch.state, 'progress') self.assertEqual(batch.completeness, 0.5) job_domain.append(('uuid', '!=', update.uuid)) update = self.env['queue.job'].search(job_domain) self.assertFalse(update) job = Job.load(self.env, job_2.uuid) job.perform() job.set_done() job.store() update = self.env['queue.job'].search(job_domain) self.assertTrue(update) self.assertEqual(1, len(update)) job = Job.load(self.env, update.uuid) job.perform() job.set_done() job.store() batch.refresh() self.assertEqual(batch.state, 'finished') self.assertEqual(batch.completeness, 1) self.assertFalse(batch.is_read)
def test_async_import(self): """ Basic asynchronous import test with default large chunk size. """ res = self._do_import('account.move.csv', use_queue=True) self.assertFalse(res, repr(res)) # no moves should be created yet move_count = self.move_obj.search([('name', 'in', ('TEST-1', 'TEST-2', 'TEST-3'))]) self.assertEqual(len(move_count), 0) # but we must have one job to split the file split_job = self.job_obj.search([]) self.assertEqual(len(split_job), 1) # job names are important self.assertEqual(split_job.name, "Import Journal Entries from file account.move.csv") # perform job Job.load(self.env, split_job.uuid).perform() # check one job has been generated to load the file (one chunk) load_job = self.job_obj.search([('id', '!=', split_job.id)]) self.assertEqual(len(load_job), 1) self.assertEqual( load_job.name, "Import Journal Entries from file account.move.csv - " "#0 - lines 2 to 10") # perform job Job.load(self.env, load_job.uuid).perform() self._check_import_result()
def test_batch_processing(self): wiz = self.wiz_obj.create( {"batch_processing": True, "date_end": self.nextmonth} ) # I check if this asset is draft self.assertEqual(self.asset01.state, "draft") # I confirm this asset self.asset01.validate() # I check if this asset is running self.assertEqual(self.asset01.state, "open") self.asset01.compute_depreciation_board() # I check that there is no depreciation line depreciation_line = self.asset01.depreciation_line_ids.filtered( lambda r: r.type == "depreciate" and r.move_id ) self.assertTrue(len(depreciation_line) == 0) wiz.with_context(test_queue_job_no_delay=False).asset_compute() depreciation_line = self.asset01.depreciation_line_ids.filtered( lambda r: r.type == "depreciate" and r.move_id ) self.assertTrue(len(depreciation_line) == 0) job_name = "Creating jobs to create moves for assets to %s" % (self.nextmonth) jobs = self.env["queue.job"].search( [("name", "=", job_name)], order="date_created desc", limit=1 ) self.assertEqual( jobs.job_function_id, self.env.ref( "account_asset_batch_compute." "job_function_account_asset_compute_asset_compute" ), ) self.assertTrue(len(jobs) == 1) job = Job.load(self.env, jobs.uuid) # perform job job.perform() depreciation_line = self.asset01.depreciation_line_ids.filtered( lambda r: r.type == "depreciate" and r.move_id ) self.assertTrue(len(depreciation_line) == 0) job_name = "Creating move for asset with id {} to {}".format( self.asset01.id, self.nextmonth, ) jobs = self.env["queue.job"].search( [("name", "=", job_name)], order="date_created desc", limit=1 ) self.assertTrue(len(jobs) == 1) self.assertEqual( jobs.job_function_id, self.env.ref( "account_asset_batch_compute.job_function_account_asset_compute_entries" ), ) job = Job.load(self.env, jobs.uuid) job.perform() depreciation_line = self.asset01.depreciation_line_ids.filtered( lambda r: r.type == "depreciate" and r.move_id ) self.assertEqual(len(depreciation_line), 1)
def test_job_unlinked(self): test_job = Job(self.method, args=("o", "k"), kwargs={"c": "!"}) test_job.store() stored = self.queue_job.search([("uuid", "=", test_job.uuid)]) stored.unlink() with self.assertRaises(NoSuchJobError): Job.load(self.env, test_job.uuid)
def test_export_jobs(self): queue_job_model = self.env['queue.job'] existing_jobs = queue_job_model.search([]) with mock_api(self.env) as mocked_api: self.assertFalse(self.se_index.name in mocked_api.index) self.se_index_model.export_all_index(delay=True) # by default the export method create 2 jobs # the first one to split the bindings to export into batch # the second one to export each batch new_jobs = queue_job_model.search([]) new_job = new_jobs - existing_jobs self.assertEqual(1, len(new_job)) job = Job.load(self.env, new_job.uuid) self.assertEqual(_('Prepare a batch export of indexes'), job.description) # at this stage the mocked_api is not yet called self.assertFalse(self.se_index.name in mocked_api.index) # perform the job existing_jobs = new_jobs job.perform() new_jobs = queue_job_model.search([]) new_job = new_jobs - existing_jobs self.assertEqual(1, len(new_job)) job = Job.load(self.env, new_job.uuid) count = self.env['res.partner'].search_count([]) self.assertEqual( _("Export %d records of %d for index 'partner index'") % (count, count), job.description) self.assertFalse(self.se_index.name in mocked_api.index) # the last job is the one performing the export job = Job.load(self.env, new_job.uuid) with mock_api(self.env) as mocked_api: job.perform() self.assertTrue(self.se_index.name in mocked_api.index)
def test_job_unlinked(self): test_job = Job(self.method, args=('o', 'k'), kwargs={'c': '!'}) test_job.store() stored = self.queue_job.search([('uuid', '=', test_job.uuid)]) stored.unlink() with self.assertRaises(NoSuchJobError): Job.load(self.env, test_job.uuid)
def test_batch(self): self.cr.execute("delete from queue_job") batch = self.env["queue.job.batch"].get_new_batch("TEST") self.assertFalse(batch.job_ids) model = self.env["test.queue.job"].with_context(job_batch=batch) job_1 = model.with_delay().testing_method() self.assertEqual(job_1.db_record().state, "pending") job_2 = model.with_delay().testing_method() self.assertEqual(job_2.db_record().state, "pending") batch.refresh() jobs = job_1.db_record() jobs |= job_2.db_record() self.assertEqual(jobs, batch.job_ids) batch.set_read() self.assertTrue(batch.is_read) self.assertEqual(batch.state, "draft") self.assertEqual(job_2.state, "pending") self.assertEqual(job_2.state, "pending") batch.enqueue() self.assertEqual(batch.state, "enqueued") self.assertEqual(job_2.state, "pending") self.assertEqual(job_2.state, "pending") job_domain = [ ("uuid", "!=", job_1.uuid), ("uuid", "!=", job_2.uuid), ] update = self.env["queue.job"].search(job_domain) self.assertFalse(update) job = Job.load(self.env, job_1.uuid) job.perform() job.set_done() job.store() update = self.env["queue.job"].search(job_domain) self.assertTrue(update) self.assertEqual(1, len(update)) job = Job.load(self.env, update.uuid) job.perform() job.set_done() job.store() batch.refresh() self.assertEqual(batch.state, "progress") self.assertEqual(batch.completeness, 0.5) job_domain.append(("uuid", "!=", update.uuid)) update = self.env["queue.job"].search(job_domain) self.assertFalse(update) job = Job.load(self.env, job_2.uuid) job.perform() job.set_done() job.store() update = self.env["queue.job"].search(job_domain) self.assertTrue(update) self.assertEqual(1, len(update)) job = Job.load(self.env, update.uuid) job.perform() job.set_done() job.store() batch.refresh() self.assertEqual(batch.state, "finished") self.assertEqual(batch.completeness, 1) self.assertFalse(batch.is_read)
def test_read(self): eta = datetime.now() + timedelta(hours=5) test_job = Job( self.method, args=("o", "k"), kwargs={"c": "!"}, priority=15, eta=eta, description="My description", ) test_job.user_id = 1 test_job.worker_pid = 99999 # normally set on "set_start" test_job.company_id = self.env.ref("base.main_company").id test_job.store() job_read = Job.load(self.env, test_job.uuid) self.assertEqual(test_job.uuid, job_read.uuid) self.assertEqual(test_job.model_name, job_read.model_name) self.assertEqual(test_job.func, job_read.func) self.assertEqual(test_job.args, job_read.args) self.assertEqual(test_job.kwargs, job_read.kwargs) self.assertEqual(test_job.method_name, job_read.method_name) self.assertEqual(test_job.description, job_read.description) self.assertEqual(test_job.state, job_read.state) self.assertEqual(test_job.priority, job_read.priority) self.assertEqual(test_job.exc_info, job_read.exc_info) self.assertEqual(test_job.result, job_read.result) self.assertEqual(test_job.user_id, job_read.user_id) self.assertEqual(test_job.company_id, job_read.company_id) self.assertEqual(test_job.worker_pid, 99999) delta = timedelta(seconds=1) # DB does not keep milliseconds self.assertAlmostEqual(test_job.date_created, job_read.date_created, delta=delta) self.assertAlmostEqual(test_job.date_started, job_read.date_started, delta=delta) self.assertAlmostEqual(test_job.date_enqueued, job_read.date_enqueued, delta=delta) self.assertAlmostEqual(test_job.date_done, job_read.date_done, delta=delta) self.assertAlmostEqual(test_job.eta, job_read.eta, delta=delta) test_date = datetime(2015, 3, 15, 21, 7, 0) job_read.date_enqueued = test_date job_read.date_started = test_date job_read.date_done = test_date job_read.store() job_read = Job.load(self.env, test_job.uuid) self.assertAlmostEqual(job_read.date_started, test_date, delta=delta) self.assertAlmostEqual(job_read.date_enqueued, test_date, delta=delta) self.assertAlmostEqual(job_read.date_done, test_date, delta=delta)
def test_reset_expired_password(self): # Simulate cron call # Check if one job is created per backend with activated validity delay # Run the job and check if reset password is done self._init_job_counter() self.backend._launch_reset_expired_password() self._check_nbr_job_created(1) created_job = self.created_jobs self._init_job_counter() Job.load(self.env, created_job.uuid).perform() # The reset password job + the export to locomotive self._check_nbr_job_created(2)
def test_job(self): self.assertEqual( self.sales.mapped("state"), ["draft", "draft", "draft", "draft", "draft", "sale"], ) jobs = self.env["queue.job"].search([]) self.assertEqual(len(jobs), 5) for job in jobs: Job.load(self.env, job.uuid).perform() self.assertEqual(set(self.sales.mapped("state")), {"sale"}) self._close_session() self._check_closing_session()
def test_async_import_smaller_aligned_chunks(self): """ Chunks aligned on record boundaries. Last chunk ends exactly at file end. """ res = self._do_import('account.move.csv', use_queue=True, chunk_size=3) self.assertFalse(res, repr(res)) # but we must have one job to split the file split_job = self.job_obj.search([]) self.assertEqual(len(split_job), 1) # perform job Job.load(self.env, split_job.uuid).perform() # check one job has been generated to load the file (three chunks) load_jobs = self.job_obj.search([('id', '!=', split_job.id)], order='name') self.assertEqual(len(load_jobs), 3) self.assertEqual( load_jobs[0].name, "Import Journal Entries from file account.move.csv - " "#0 - lines 2 to 4") self.assertEqual( load_jobs[1].name, "Import Journal Entries from file account.move.csv - " "#1 - lines 5 to 7") self.assertEqual( load_jobs[2].name, "Import Journal Entries from file account.move.csv - " "#2 - lines 8 to 10") # perform job Job.load(self.env, load_jobs[0].uuid).perform() Job.load(self.env, load_jobs[1].uuid).perform() Job.load(self.env, load_jobs[2].uuid).perform() self._check_import_result()
def test_async_import_smaller_misaligned_chunks(self): """ Chunk size smaller than record. """ res = self._do_import("account.move.csv", use_queue=True, chunk_size=2) self.assertFalse(res, repr(res)) # but we must have one job to split the file split_job = self.job_obj.search([]) self.assertEqual(len(split_job), 1) # perform job Job.load(self.env, split_job.uuid).perform() # check one job has been generated to load the file (three chunks) load_jobs = self.job_obj.search([("id", "!=", split_job.id)], order="name") self.assertEqual(len(load_jobs), 3) self.assertEqual( load_jobs[0].name, "Import Account Entry from file account.move.csv - #0 - lines 2 to 4", ) self.assertEqual( load_jobs[1].name, "Import Account Entry from file account.move.csv - #1 - lines 5 to 7", ) self.assertEqual( load_jobs[2].name, "Import Account Entry from file account.move.csv - #2 - lines 8 to 10", ) # perform job Job.load(self.env, load_jobs[0].uuid).perform() Job.load(self.env, load_jobs[1].uuid).perform() Job.load(self.env, load_jobs[2].uuid).perform() self._check_import_result()
def test_02_delete_move_before_job_run(self): """ Create a move and call the validate account move wizard to post it, and then delete the move. """ move = self.create_account_move(3000) wizard = self.create_move_validate_wizard('mark', eta=1000) wizard.with_context({ 'active_ids': [move.id], 'automated_test_execute_now': True, }).validate_move() job_uuid = move.post_job_uuid self.assertTrue( bool(job_uuid), msg="The job has not been created.") move.unlink() post_job = Job.load(self.env, job_uuid) post_job.perform() self.assertEquals( post_job.result, u'Nothing to do because the record has been deleted')
def test_channel_on_job(self): self.env['queue.job.function'].search([]).unlink() self.env['queue.job.channel'].search([('name', '!=', 'root')]).unlink() method = self.env['test.queue.channel'].job_a self.env['queue.job.function']._register_job(method) path_a = '<%s>.%s' % (method.im_class._name, method.__name__) job_func = self.function_model.search([('name', '=', path_a)]) self.assertEquals(job_func.channel, 'root') test_job = Job(method) test_job.store() stored = self.env['queue.job'].search([('uuid', '=', test_job.uuid)]) self.assertEquals(stored.channel, 'root') job_read = Job.load(self.env, test_job.uuid) self.assertEquals(job_read.channel, 'root') channel = self.channel_model.create({ 'name': 'sub', 'parent_id': self.root_channel.id }) job_func.channel_id = channel test_job = Job(method) test_job.store() stored = self.env['queue.job'].search([('uuid', '=', test_job.uuid)]) self.assertEquals(stored.channel, 'root.sub') # it's also possible to override the channel test_job = Job(method, channel='root.sub.sub.sub') test_job.store() stored = self.env['queue.job'].search([('uuid', '=', test_job.uuid)]) self.assertEquals(stored.channel, test_job.channel)
def test_channel_on_job(self): method = self.env["test.queue.channel"].job_a path_a = self.env["queue.job.function"].job_function_name( "test.queue.channel", "job_a") job_func = self.function_model.search([("name", "=", path_a)]) self.assertEqual(job_func.channel, "root") test_job = Job(method) test_job.store() stored = test_job.db_record() self.assertEqual(stored.channel, "root") job_read = Job.load(self.env, test_job.uuid) self.assertEqual(job_read.channel, "root") sub_channel = self.env.ref("test_queue_job.channel_sub") job_func.channel_id = sub_channel test_job = Job(method) test_job.store() stored = test_job.db_record() self.assertEqual(stored.channel, "root.sub") # it's also possible to override the channel test_job = Job(method, channel="root.sub") test_job.store() stored = test_job.db_record() self.assertEqual(stored.channel, test_job.channel)
def test_channel_on_job(self): self.env["queue.job.function"].search([]).unlink() self.env["queue.job.channel"].search([("name", "!=", "root")]).unlink() method = self.env["test.queue.channel"].job_a self.env["queue.job.function"]._register_job( self.env["test.queue.channel"], method ) path_a = "<{}>.{}".format(method.__self__.__class__._name, method.__name__) job_func = self.function_model.search([("name", "=", path_a)]) self.assertEquals(job_func.channel, "root") test_job = Job(method) test_job.store() stored = self.env["queue.job"].search([("uuid", "=", test_job.uuid)]) self.assertEquals(stored.channel, "root") job_read = Job.load(self.env, test_job.uuid) self.assertEquals(job_read.channel, "root") channel = self.channel_model.create( {"name": "sub", "parent_id": self.root_channel.id} ) job_func.channel_id = channel test_job = Job(method) test_job.store() stored = self.env["queue.job"].search([("uuid", "=", test_job.uuid)]) self.assertEquals(stored.channel, "root.sub") # it's also possible to override the channel test_job = Job(method, channel="root.sub.sub.sub") test_job.store() stored = self.env["queue.job"].search([("uuid", "=", test_job.uuid)]) self.assertEquals(stored.channel, test_job.channel)
def test_01_wizard_asynchronous_post(self): """ Create a move and call the validate account move wizard to post it. """ move = self.create_account_move(1000) self.assertEqual(move.state, 'draft') wizard = self.create_move_validate_wizard('mark') wizard.with_context({ 'active_ids': [move.id], 'automated_test_execute_now': True, }).validate_move() move.invalidate_cache() job_uuid = move.post_job_uuid self.assertTrue(move.to_post, msg="Move should be marked as 'to post'.") self.assertTrue(bool(job_uuid), msg="A job should have been assigned to the move.") post_job = Job.load(self.env, job_uuid) post_job.perform() self.assertEqual(move.state, 'posted', msg="Move should be posted.")
def test_job_execute_after_closing(self): self.assertEqual( self.sales.mapped("state"), ["draft", "draft", "draft", "draft", "draft", "sale"], ) jobs = self.env["queue.job"].search([]) self.assertEqual(len(jobs), 5) for job in jobs[:4]: Job.load(self.env, job.uuid).perform() self.assertEqual( self.sales.mapped("state"), ["draft", "sale", "sale", "sale", "sale", "sale"], ) self._close_session() self._check_closing_session() Job.load(self.env, jobs[0].uuid).perform()
def test_store_env_su_sudo(self): demo_user = self.env.ref("base.user_demo") self.env = self.env(user=demo_user) delayable = self.env["test.queue.job"].sudo().with_delay() test_job = delayable.testing_method() stored = test_job.db_record() job_instance = Job.load(self.env, stored.uuid) self.assertTrue(job_instance.recordset.env.su) self.assertTrue(job_instance.user_id, demo_user)
def test_job_identity_key_str(self): id_key = 'e294e8444453b09d59bdb6efbfec1323' test_job_1 = Job(self.method, priority=15, description="Test I am the first one", identity_key=id_key) test_job_1.store() job1 = Job.load(self.env, test_job_1.uuid) self.assertEqual(job1.identity_key, id_key)
def test_2(self): wiz = self.wiz_obj.create({ 'batch_processing': True, 'date_end': self.nextmonth }) # I check if this asset is draft self.assertEqual(self.asset01.state, 'draft') # I confirm this asset self.asset01.validate() # I check if this asset is running self.assertEqual(self.asset01.state, 'open') self.asset01.compute_depreciation_board() # I check that there is no depreciation line depreciation_line = self.asset01.depreciation_line_ids\ .filtered(lambda r: r.type == 'depreciate' and r.move_id) self.assertTrue(len(depreciation_line) == 0) wiz.with_context(test_queue_job_no_delay=False).asset_compute() depreciation_line = self.asset01.depreciation_line_ids \ .filtered(lambda r: r.type == 'depreciate' and r.move_id) self.assertTrue(len(depreciation_line) == 0) job_name = "Creating jobs to create moves for assets to %s" % ( self.nextmonth) jobs = self.env['queue.job'].search([('name', '=', job_name)], order='date_created desc', limit=1) self.assertTrue(len(jobs) == 1) job = Job.load(self.env, jobs.uuid) # perform job job.perform() depreciation_line = self.asset01.depreciation_line_ids \ .filtered(lambda r: r.type == 'depreciate' and r.move_id) self.assertTrue(len(depreciation_line) == 0) job_name = "Creating move for asset with id %s to %s" % ( self.asset01.id, self.nextmonth) jobs = self.env['queue.job'].search([('name', '=', job_name)], order='date_created desc', limit=1) self.assertTrue(len(jobs) == 1) job = Job.load(self.env, jobs.uuid) job.perform() depreciation_line = self.asset01.depreciation_line_ids \ .filtered(lambda r: r.type == 'depreciate' and r.move_id) self.assertEquals(len(depreciation_line), 1)
def test_accented_bytestring(self): test_job = Job(self.method, args=('öô¿‽', 'ñě'), kwargs={'c': 'ßø'}, priority=15, description="My dé^Wdescription") test_job.store() job_read = Job.load(self.env, test_job.uuid) self.assertEqual(job_read.args, ('öô¿‽', 'ñě')) self.assertEqual(job_read.kwargs, {'c': 'ßø'}) self.assertEqual(job_read.description, "My dé^Wdescription")
def test_async_import_small_misaligned_chunks(self): """ Chunk size larger than record. """ res = self._do_import('account.move.csv', use_queue=True, chunk_size=4) self.assertFalse(res, repr(res)) # but we must have one job to split the file split_job = self.job_obj.search([]) self.assertEqual(len(split_job), 1) # perform job Job.load(self.env, split_job.uuid).perform() # check one job has been generated to load the file (two chunks) load_jobs = self.job_obj.search([('id', '!=', split_job.id)], order='name') self.assertEqual(len(load_jobs), 2) self.assertEqual( load_jobs[0].name, "Import Account Entry from file account.move.csv - " "#0 - lines 2 to 7") self.assertEqual( load_jobs[1].name, "Import Account Entry from file account.move.csv - " "#1 - lines 8 to 10") # perform job Job.load(self.env, load_jobs[0].uuid).perform() Job.load(self.env, load_jobs[1].uuid).perform() self._check_import_result()
def test_accented_bytestring(self): test_job = Job( self.method, args=("öô¿‽", "ñě"), kwargs={"c": "ßø"}, priority=15, description="My dé^Wdescription", ) test_job.store() job_read = Job.load(self.env, test_job.uuid) self.assertEqual(job_read.args, ("öô¿‽", "ñě")) self.assertEqual(job_read.kwargs, {"c": "ßø"}) self.assertEqual(job_read.description, "My dé^Wdescription")
def test_unicode(self): test_job = Job(self.method, args=(u'öô¿‽', u'ñě'), kwargs={'c': u'ßø'}, priority=15, description=u"My dé^Wdescription") test_job.store() job_read = Job.load(self.env, test_job.uuid) self.assertEqual(test_job.args, job_read.args) self.assertEqual(job_read.args, (u'öô¿‽', u'ñě')) self.assertEqual(test_job.kwargs, job_read.kwargs) self.assertEqual(job_read.kwargs, {'c': u'ßø'}) self.assertEqual(test_job.description, job_read.description) self.assertEqual(job_read.description, u"My dé^Wdescription")
def test_accented_bytestring(self): test_job = Job(self.method, args=('öô¿‽', 'ñě'), kwargs={'c': 'ßø'}, priority=15, description="My dé^Wdescription") test_job.user_id = 1 test_job.store() job_read = Job.load(self.env, test_job.uuid) # the job's args and description have been created as bytestring but # are decoded to utf8 by the ORM so make them comparable self.assertEqual(job_read.args, ('öô¿‽'.decode('utf8'), 'ñě'.decode('utf8'))) self.assertEqual(job_read.kwargs, {'c': 'ßø'.decode('utf8')}) self.assertEqual(job_read.description, "My dé^Wdescription".decode('utf8'))
def test_unicode(self): test_job = Job( self.method, args=(u"öô¿‽", u"ñě"), kwargs={"c": u"ßø"}, priority=15, description=u"My dé^Wdescription", ) test_job.store() job_read = Job.load(self.env, test_job.uuid) self.assertEqual(test_job.args, job_read.args) self.assertEqual(job_read.args, (u"öô¿‽", u"ñě")) self.assertEqual(test_job.kwargs, job_read.kwargs) self.assertEqual(job_read.kwargs, {"c": u"ßø"}) self.assertEqual(test_job.description, job_read.description) self.assertEqual(job_read.description, u"My dé^Wdescription")
def _cancel_post_jobs(self): """ Find moves where the mark has been removed and cancel the jobs. For the moves that are posted already it's too late: we skip them. """ moves = self.search([ ('to_post', '=', False), ('post_job_uuid', '!=', False), ('state', '=', 'draft'), ]) for move in moves: job_rec = Job.load(self.env, move.post_job_uuid) if job_rec.state in ('pending', 'enqueued'): job_rec.set_done(result=_("Task set to Done because the " "user unmarked the move.")) job_rec.store()