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_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')
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')
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 _create_failed_job(self):
method = self.env["res.users"].with_user(self.other_user_a).mapped
test_job = Job(method)
test_job.store()
test_job_record = self.env["queue.job"].search([("uuid", "=", test_job.uuid)])
test_job_record.write({"state": "failed"})
return test_job_record
def _create_failed_job(self):
method = self.env['res.users'].mapped
test_job = Job(method)
test_job.store()
test_job_record = self.env['queue.job'].search([('uuid', '=',
test_job.uuid)])
test_job_record.write({'state': 'failed'})
return test_job_record
def test_store_extra_data(self):
test_job = Job(self.method)
test_job.store()
stored = self.queue_job.search([("uuid", "=", test_job.uuid)])
self.assertEqual(stored.additional_info, "JUST_TESTING")
test_job.set_failed(exc_info="failed test", exc_name="FailedTest")
test_job.store()
stored.invalidate_cache()
self.assertEqual(stored.additional_info, "JUST_TESTING_BUT_FAILED")
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_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_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_old_jobs_are_deleted(self):
"""
Old jobs are deleted by the autovacuum cron job.
"""
test_job = Job(self.method)
test_job.set_done(result='ok')
test_job.date_done = datetime.datetime.now() - datetime.timedelta(
days=self.queue_job._removal_interval + 1)
test_job.store()
self.cron_job.method_direct_trigger()
self.assertFalse(test_job.db_record().exists())
def test_store_related_action(self):
""" Call the related action on the model """
job = Job(self.model.testing_related_action__store,
args=('Discworld', ))
job.store()
stored_job = self.env['queue.job'].search([('uuid', '=', job.uuid)])
self.assertEqual(len(stored_job), 1)
expected = {
'type': 'ir.actions.act_url',
'target': 'new',
'url': 'https://en.wikipedia.org/wiki/Discworld',
}
self.assertEquals(stored_job.open_related_action(), expected)
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 test_job_identity_key_func_exact(self):
hasher = hashlib.sha1()
hasher.update('test.queue.job'.encode('utf-8'))
hasher.update('testing_method'.encode('utf-8'))
hasher.update(str(sorted([])).encode('utf-8'))
hasher.update(str((1, 'foo')).encode('utf-8'))
hasher.update(str(sorted({'bar': 'baz'}.items())).encode('utf-8'))
expected_key = hasher.hexdigest()
test_job_1 = Job(self.method,
args=[1, 'foo'],
kwargs={'bar': 'baz'},
identity_key=identity_exact)
self.assertEqual(test_job_1.identity_key, expected_key)
test_job_1.store()
job1 = Job.load(self.env, test_job_1.uuid)
self.assertEqual(job1.identity_key, expected_key)
def test_company_simple(self):
company = self.env.ref("base.main_company")
eta = datetime.now() + timedelta(hours=5)
test_job = Job(
self.method,
args=("o", "k"),
kwargs={"return_context": 1},
priority=15,
eta=eta,
description="My description",
)
test_job.worker_pid = 99999 # normally set on "set_start"
test_job.company_id = company.id
test_job.store()
job_read = Job.load(self.env, test_job.uuid)
self.assertEqual(test_job.func, job_read.func)
result_ctx = test_job.func(*tuple(test_job.args), **test_job.kwargs)
self.assertEqual(result_ctx.get("allowed_company_ids"), company.ids)
def test_job_identity_key_func_exact(self):
hasher = hashlib.sha1()
hasher.update(b"test.queue.job")
hasher.update(b"testing_method")
hasher.update(str(sorted([])).encode("utf-8"))
hasher.update(str((1, "foo")).encode("utf-8"))
hasher.update(str(sorted({"bar": "baz"}.items())).encode("utf-8"))
expected_key = hasher.hexdigest()
test_job_1 = Job(
self.method,
args=[1, "foo"],
kwargs={"bar": "baz"},
identity_key=identity_exact,
)
self.assertEqual(test_job_1.identity_key, expected_key)
test_job_1.store()
job1 = Job.load(self.env, test_job_1.uuid)
self.assertEqual(job1.identity_key, expected_key)
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_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_company_complex(self):
company1 = self.env.ref("base.main_company")
company2 = company1.create({"name": "Queue job company"})
companies = company1 | company2
self.env.user.write({"company_ids": [(6, False, companies.ids)]})
# Ensure the main company still the first
self.assertEqual(self.env.user.company_id, company1)
eta = datetime.now() + timedelta(hours=5)
test_job = Job(
self.method,
args=("o", "k"),
kwargs={"return_context": 1},
priority=15,
eta=eta,
description="My description",
)
test_job.worker_pid = 99999 # normally set on "set_start"
test_job.company_id = company2.id
test_job.store()
job_read = Job.load(self.env, test_job.uuid)
self.assertEqual(test_job.func, job_read.func)
result_ctx = test_job.func(*tuple(test_job.args), **test_job.kwargs)
self.assertEqual(result_ctx.get("allowed_company_ids"), company2.ids)
def test_default_channel_no_xml(self):
"""Channel on job is root if there is no queue.job.function record"""
test_job = Job(self.env["res.users"].browse)
test_job.store()
stored = test_job.db_record()
self.assertEqual(stored.channel, "root")
def test_store(self):
test_job = Job(self.method)
test_job.store()
stored = self.queue_job.search([("uuid", "=", test_job.uuid)])
self.assertEqual(len(stored), 1)
def _create_job(self):
test_job = Job(self.method)
test_job.store()
stored = Job.db_record_from_uuid(self.env, test_job.uuid)
self.assertEqual(len(stored), 1)
return stored
