def test_worker_default_queue(self):
self.enqueue()
self.enqueue(queue=u'my_queue')
jobs.Worker().work(burst=True)
all_jobs = self.all_jobs()
assert_equal(len(all_jobs), 1)
assert_equal(jobs.remove_queue_name_prefix(all_jobs[0].origin),
u'my_queue')
def test_worker_multiple_queues(self):
self.enqueue()
self.enqueue(queue=u'queue1')
self.enqueue(queue=u'queue2')
jobs.Worker([u'queue1', u'queue2']).work(burst=True)
all_jobs = self.all_jobs()
assert_equal(len(all_jobs), 1)
assert_equal(jobs.remove_queue_name_prefix(all_jobs[0].origin),
jobs.DEFAULT_QUEUE_NAME)
def test_worker_exception_logging(self):
u'''
Test that exceptions in a job are logged.
'''
self.enqueue(failing_job)
worker = jobs.Worker()
# Prevent worker from forking so that we can capture log
# messages from within the job
def execute_job(*args, **kwargs):
return worker.perform_job(*args, **kwargs)
worker.execute_job = execute_job
with recorded_logs(u'ckanext.rq.jobs') as logs:
worker.work(burst=True)
logs.assert_log(u'error', u'JOB FAILURE')
def test_worker_database_access(self):
u'''
Test database access from within the worker.
'''
# See https://github.com/ckan/ckan/issues/3243
pkg_name = u'test-worker-database-access'
try:
pkg_dict = call_action(u'package_show', id=pkg_name)
except ObjectNotFound:
pkg_dict = call_action(u'package_create', name=pkg_name)
pkg_dict[u'title'] = u'foo'
pkg_dict = call_action(u'package_update', **pkg_dict)
titles = u'1 2 3'.split()
for title in titles:
self.enqueue(database_job, args=[pkg_dict[u'id'], title])
jobs.Worker().work(burst=True)
# Aside from ensuring that the jobs succeeded, this also checks
# that database access still works in the main process.
pkg_dict = call_action(u'package_show', id=pkg_name)
assert_equal(pkg_dict[u'title'], u'foo' + u''.join(titles))
def test_worker_logging_lifecycle(self):
u'''
Test that a logger's lifecycle is logged.
'''
queue = u'my_queue'
job = self.enqueue(queue=queue)
with recorded_logs(u'ckanext.rq.jobs') as logs:
worker = jobs.Worker([queue])
worker.work(burst=True)
messages = logs.messages[u'info']
# We expect 4 log messages: Worker start, job start, job end,
# worker end.
assert_equal(len(messages), 4)
ok_(worker.key in messages[0])
ok_(queue in messages[0])
ok_(worker.key in messages[1])
ok_(job.id in messages[1])
ok_(worker.key in messages[2])
ok_(job.id in messages[2])
ok_(worker.key in messages[3])
def test_fork_within_a_transaction(self):
u'''
Test forking a worker horse within a database transaction.
The original instances should be unchanged but their session
must be closed.
'''
pkg_name = u'test-fork-within-a-transaction'
model.repo.new_revision()
pkg = model.Package.get(pkg_name)
if not pkg:
pkg = model.Package(name=pkg_name)
pkg.title = u'foo'
pkg.save()
pkg.title = u'bar'
self.enqueue(database_job, [pkg.id, u'foo'])
jobs.Worker().work(burst=True)
assert_equal(pkg.title, u'bar') # Original instance is unchanged
# The original session has been closed, `pkg.Session` uses the new
# session in which `pkg` is not registered.
assert_false(pkg in pkg.Session)
pkg = model.Package.get(pkg.id) # Get instance from new session
assert_equal(pkg.title, u'foofoo') # Worker only saw committed changes