def test_basic_deletion(self):
new_run = Run('test_basic_deletion')
new_job = Job({'job_id': '42'}, new_run)
models.commit()
new_job.delete()
models.commit()
assert not Job.filter_by(job_id='42').first()
def test_job_started_queued(self):
run_name = 'test_job_started_queued'
run = Run(run_name)
job_id = '42'
job = Job(dict(name=run_name, job_id=job_id, status='queued'), run)
job.update(dict(status='running'))
assert job.started is not None
def test_job_started_queued(self):
run_name = 'test_job_started_queued'
run = Run(run_name)
job_id = '42'
job = Job(dict(name=run_name, job_id=job_id, status='queued'), run)
job.update(dict(status='running'))
assert job.started is not None
def test_run_status_queued_to_running(self):
run_name = "run_status_queued_to_running"
new_run = Run(run_name)
job = Job(dict(job_id=1, status='queued'), new_run)
Job(dict(job_id=2, status='queued'), new_run)
job.update(dict(status='running'))
assert new_run.status == 'running'
def test_basic_deletion(self):
new_run = Run('test_basic_deletion')
new_job = Job({'job_id': '42'}, new_run)
models.commit()
new_job.delete()
models.commit()
assert not Job.filter_by(job_id='42').first()
def test_job_slice_valid_many(self):
run_name = 'test_job_slice_valid_many'
new_run = Run(run_name)
new_job = Job({'job_id': '9', 'description': 'describe the test'},
new_run)
job_slice = new_job.slice('description,job_id,href')
assert ('description' in job_slice and 'job_id' in job_slice and 'href'
in job_slice)
def test_job_slice_valid_many(self):
run_name = 'test_job_slice_valid_many'
new_run = Run(run_name)
new_job = Job({'job_id': '9', 'description': 'describe the test'},
new_run)
job_slice = new_job.slice('description,job_id,href')
assert ('description' in job_slice and 'job_id' in job_slice and 'href'
in job_slice)
def test_delete_empties_run(self):
new_run = Run('test_delete_empties_run')
new_job = Job(dict(job_id='42', status='queued'), new_run)
models.commit()
assert new_run.status == 'queued'
new_job.delete()
models.commit()
new_run_copy = Run.query.filter(Run.name == new_run.name).one()
assert not new_run_copy.status == 'empty'
def test_delete_empties_run(self):
new_run = Run('test_delete_empties_run')
new_job = Job(dict(job_id='42', status='queued'), new_run)
models.commit()
assert new_run.status == 'queued'
new_job.delete()
models.commit()
new_run_copy = Run.query.filter(Run.name == new_run.name).one()
assert not new_run_copy.status == 'empty'
def test_success_updates_status(self):
run_name = 'test_success_updates_status'
run = Run(run_name)
job_id = '27'
job = Job(dict(name=run_name, job_id=job_id, status='running'), run)
models.commit()
job.update(dict(success=True))
models.commit()
assert job.status == 'pass'
def test_jobs_count(self):
Run.query.delete()
Job.query.delete()
new_run = Run('test_jobs_count')
Job({}, new_run)
Job({}, new_run)
models.commit()
run_as_json = Run.get(1).__json__()
assert run_as_json['jobs_count'] == 2
def test_job_deletion(self):
run_name = 'test_job_deletion'
new_run = Run(run_name)
Job({'job_id': '42'}, new_run)
Job({'job_id': '9999'}, new_run)
models.commit()
new_run.delete()
models.commit()
assert not Job.filter_by(job_id='9999').first()
def test_success_updates_status(self):
run_name = 'test_success_updates_status'
run = Run(run_name)
job_id = '27'
job = Job(dict(name=run_name, job_id=job_id, status='running'), run)
models.commit()
job.update(dict(success=True))
models.commit()
assert job.status == 'pass'
def test_run_deletion(self):
run_name = 'test_run_deletion'
new_run = Run(run_name)
Job({'job_id': '42'}, new_run)
Job({'job_id': '120'}, new_run)
Job({'job_id': '4'}, new_run)
models.commit()
new_run.delete()
models.commit()
assert not Run.filter_by(name=run_name).first()
def test_status_dead_ignored_when_success_true(self):
run_name = 'test_status_dead_ignored_when_success_set'
run = Run(run_name)
job_id = '27'
job = Job(dict(name=run_name, job_id=job_id, status='running'), run)
models.commit()
job.update(dict(success=True))
models.commit()
job.update(dict(status='dead'))
models.commit()
assert job.status == 'pass'
def test_statsd_update(self, m_get_client):
m_client = Mock()
m_counter = Mock()
m_client.get_counter.return_value = m_counter
m_get_client.return_value = m_client
run_name = 'test_statsd_update'
run = Run(run_name)
job_id = '27'
job = Job(dict(name=run_name, job_id=job_id, status='running'), run)
models.commit()
job.update({'status': 'pass'})
models.commit()
assert job.status == 'pass'
assert m_get_client.called_once_with()
assert m_client.get_counter.called_once_with('jobs.status')
assert m_counter.increment.called_once_with('pass')
def test_statsd_update(self, m_get_client):
m_client = Mock()
m_counter = Mock()
m_client.get_counter.return_value = m_counter
m_get_client.return_value = m_client
run_name = 'test_statsd_update'
run = Run(run_name)
job_id = '27'
job = Job(dict(name=run_name, job_id=job_id, status='running'), run)
models.commit()
job.update({'status': 'pass'})
models.commit()
assert job.status == 'pass'
assert m_get_client.called_once_with()
assert m_client.get_counter.called_once_with('jobs.status')
assert m_counter.increment.called_once_with('pass')
def test_create_new_job(self):
self.app.post_json('/runs/', dict(name="foo"))
self.app.post_json('/runs/foo/jobs/', dict(
job_id=1,
))
new_job = Job.get(1)
assert new_job.job_id == '1'
def test_run_results(self):
run_name = 'teuthology-2014-03-27_00:00:00-x-x-x-x-x'
new_run = Run(run_name)
stats_in = {
'pass': 9,
'fail': 1,
'dead': 6,
'running': 5,
'sha1': None,
'waiting': 1,
'unknown': 1,
'queued': 1
}
statuses = stats_in.keys()
stats_in['total'] = sum(_ for _ in stats_in.values() if _)
stats_out = {}
for i in range(stats_in['total']):
for status in statuses:
count = stats_out.get(status, 0)
count += 1
if count <= stats_in[status]:
break
Job(dict(job_id=i, status=status), new_run)
stats_out[status] = count
assert new_run.get_results() == stats_in
def test_job_creates_node(self):
run_name = 'test_job_creates_node'
node_name = 'node.name'
targets = {'foo@' + node_name: ''}
new_run = Run(run_name)
Job(dict(targets=targets), new_run)
assert Node.get(1).name == node_name
def test_run_multi_machine_type(self):
run_name = 'teuthology-2014-10-06_19:30:01-upgrade:dumpling-firefly-x:stress-split-giant-distro-basic-multi'
new_run = Run(run_name)
machine_type = 'plana,mira,burnupi'
Job(dict(job_id=1, machine_type=machine_type), new_run)
models.commit()
assert new_run.machine_type == machine_type
def index_post(self):
"""
We create new jobs associated to this run here
"""
try:
data = request.json
job_id = data.get('job_id')
except ValueError:
rollback()
error('/errors/invalid/', 'could not decode JSON body')
# we allow empty data to be pushed
if not job_id:
error('/errors/invalid/', "could not find required key: 'job_id'")
job_id = data['job_id'] = str(job_id)
query = Job.query.options(load_only('id', 'job_id'))
query = query.filter_by(job_id=job_id, run=self.run)
if query.first():
error('/errors/invalid/',
"job with job_id %s already exists" % job_id)
else:
log.info("Creating job: %s/%s", data.get('name', '<no name!>'),
job_id)
self.job = Job(data, self.run)
return dict()
def test_updated(self):
run_name = 'test_updated'
new_run = Run(run_name)
for i in range(1, 5):
Job(dict(job_id=i), new_run)
models.commit()
new_run = Run.filter_by(name=run_name).first()
assert new_run.updated == new_run.get_jobs()[-1].updated
def test_job_creates_many_nodes(self):
run_name = 'test_job_creates_many_nodes'
node_names = ['node1.name', 'node2.name', 'node3.name']
targets = {}
for name in node_names:
targets['foo@' + name] = ''
new_run = Run(run_name)
Job(dict(targets=targets), new_run)
assert sorted([node.name for node in Node.query.all()]) == node_names
def test_run_suite_gets_corrected(self):
run_name = 'teuthology-2014-05-01_07:54:18-new-suite-name:new-subsuite:new-subsub-new-branch-testing-basic-plana' # noqa
suite_name = 'new-suite-name:new-subsuite:new-subsub'
branch_name = 'new-branch'
new_run = Run(run_name)
Job(dict(job_id='11', suite=suite_name, branch=branch_name), new_run)
models.commit()
assert new_run.suite == suite_name
assert new_run.branch == branch_name
def test_job_adds_node(self):
run_name = 'test_job_adds_node'
node_name = 'added_node'
assert Node.query.filter(Node.name == node_name).all() == []
node = Node(name=node_name)
targets = {'foo@' + node_name: ''}
new_run = Run(run_name)
job = Job(dict(targets=targets), new_run)
assert Node.query.filter(Node.name == node_name).one()
assert Job.query.filter(Job.target_nodes.contains(node)).one() == job
def test_force_updated_time(self):
run_name = 'test_force_updated_time'
run = Run(run_name)
time_stamp = '2014-03-31 21:25:43'
Job(dict(updated=time_stamp), run)
models.commit()
local_dt = datetime.strptime(time_stamp, '%Y-%m-%d %H:%M:%S')
utc_dt = local_datetime_to_utc(local_dt)
job = Run.query.filter(Run.name == run.name).one().jobs[0]
assert str(job.updated) == str(utc_dt)
def test_run_status_dead_to_running(self):
run_name = "run_status_dead_to_running"
new_run = Run(run_name)
jobs = []
job_count = 5
for i in range(job_count):
jobs.append(Job(dict(job_id=i+1, status='dead'), new_run))
for job in jobs:
job.update(dict(status='running'))
assert new_run.status == 'running'
def _create_job(self, job_id, data):
query = Job.query.options(load_only('id', 'job_id'))
query = query.filter_by(job_id=job_id, run=self.run)
if query.first():
error('/errors/invalid/',
"job with job_id %s already exists" % job_id)
else:
log.info("Creating job: %s/%s", data.get('name', '<no name!>'),
job_id)
self.job = Job(data, self.run)
Session.commit()
return self.job
def index(self, status='', fields=''):
job_query = Job.filter_by(run=self.run)
if status:
job_query = job_query.filter_by(status=status)
jobs = job_query.order_by(Job.posted.desc()).all()
if fields:
try:
return [job.slice(fields) for job in jobs]
except AttributeError:
rollback()
error('/errors/invalid/', 'an invalid field was specified')
else:
return jobs
def index(self, status='', fields=''):
job_query = Job.filter_by(run=self.run)
if status:
job_query = job_query.filter_by(status=status)
jobs = job_query.order_by(Job.posted.desc()).all()
if fields:
try:
return [job.slice(fields) for job in jobs]
except AttributeError:
rollback()
error('/errors/invalid/',
'an invalid field was specified')
else:
return jobs
def test_status_dead_ignored_when_success_true(self):
run_name = 'test_status_dead_ignored_when_success_set'
run = Run(run_name)
job_id = '27'
job = Job(dict(name=run_name, job_id=job_id, status='running'), run)
models.commit()
job.update(dict(success=True))
models.commit()
job.update(dict(status='dead'))
models.commit()
assert job.status == 'pass'
def test_run_status_queued(self):
run_name = "run_status_queued"
new_run = Run(run_name)
Job(dict(job_id=1, status='queued'), new_run)
Job(dict(job_id=2, status='queued'), new_run)
assert new_run.status == 'queued'
def test_run_status_running(self):
run_name = "run_status_running"
new_run = Run(run_name)
Job(dict(job_id=1, status='running'), new_run)
Job(dict(job_id=1, status='pass'), new_run)
assert new_run.status == 'running'
def test_create_new_job(self):
self.app.post_json('/runs/', dict(name="foo"))
self.app.post_json('/runs/foo/jobs/', dict(job_id=1, ))
new_job = Job.get(1)
assert new_job.job_id == '1'
def test_run_status_all_dead(self):
run_name = "run_status_all_dead"
new_run = Run(run_name)
Job(dict(job_id=1, status='dead'), new_run)
Job(dict(job_id=1, status='dead'), new_run)
assert new_run.status == 'finished dead'
def test_job_slice_valid(self):
run_name = 'test_job_slice_valid'
new_run = Run(run_name)
new_job = Job({'description': 'describe the test'}, new_run)
assert 'description' in new_job.slice('description')
def test_job_slice_invalid(self):
run_name = 'test_job_slice_invalid'
new_run = Run(run_name)
new_job = Job({}, new_run)
with pytest.raises(AttributeError):
new_job.slice('bullcrap')
def test_run_status_pass(self):
run_name = "run_status_pass"
new_run = Run(run_name)
Job(dict(job_id=1, status='pass'), new_run)
Job(dict(job_id=1, status='pass'), new_run)
assert new_run.status == 'finished pass'
def test_job_slice_invalid(self):
run_name = 'test_job_slice_invalid'
new_run = Run(run_name)
new_job = Job({}, new_run)
with pytest.raises(AttributeError):
new_job.slice('bullcrap')
def test_relationship_works(self):
new_run = Run('test_relationship_works')
id_ = Job({}, new_run).id
models.commit()
new_job = Job.get(id_)
assert new_job.run.name == 'test_relationship_works'
def test_basic_creation(self):
new_run = Run('test_basic_creation')
Job({}, new_run)
models.commit()
assert Job.get(1)
def test_job_updated(self):
new_run = Run('test_job_updated')
Job({}, new_run)
models.commit()
new_job = Job.get(1)
assert isinstance(new_job.updated, datetime)
def test_job_slice_valid(self):
run_name = 'test_job_slice_valid'
new_run = Run(run_name)
new_job = Job({'description': 'describe the test'}, new_run)
assert 'description' in new_job.slice('description')
