def test_ingest_running_to_retry_to_success_sample_job(
test_repository, failure_classifications, sample_data, sample_push,
mock_log_parser, ingestion_cycles):
# verifies that retries to success work, no matter how jobs are batched
store_push_data(test_repository, sample_push)
job_datum = copy.deepcopy(sample_data.job_data[0])
job_datum['revision'] = sample_push[0]['revision']
job = job_datum['job']
job_guid_root = job['job_guid']
job_data = []
for (state, result,
job_guid) in [('running', 'unknown', job_guid_root),
('completed', 'retry',
job_guid_root + "_" + str(job['end_timestamp'])[-5:]),
('completed', 'success', job_guid_root)]:
new_job_datum = copy.deepcopy(job_datum)
new_job_datum['job']['state'] = state
new_job_datum['job']['result'] = result
new_job_datum['job']['job_guid'] = job_guid
job_data.append(new_job_datum)
for (i, j) in ingestion_cycles:
store_job_data(test_repository, job_data[i:j])
assert Job.objects.count() == 2
assert Job.objects.get(id=1).result == 'retry'
assert Job.objects.get(id=2).result == 'success'
assert JobLog.objects.count() == 2
def test_ingest_running_to_retry_to_success_sample_job(test_repository,
failure_classifications,
sample_data,
sample_push,
mock_log_parser,
ingestion_cycles):
# verifies that retries to success work, no matter how jobs are batched
store_push_data(test_repository, sample_push)
job_datum = copy.deepcopy(sample_data.job_data[0])
job_datum['revision'] = sample_push[0]['revision']
job = job_datum['job']
job_guid_root = job['job_guid']
job_data = []
for (state, result, job_guid) in [
('running', 'unknown', job_guid_root),
('completed', 'retry',
job_guid_root + "_" + str(job['end_timestamp'])[-5:]),
('completed', 'success', job_guid_root)]:
new_job_datum = copy.deepcopy(job_datum)
new_job_datum['job']['state'] = state
new_job_datum['job']['result'] = result
new_job_datum['job']['job_guid'] = job_guid
job_data.append(new_job_datum)
for (i, j) in ingestion_cycles:
store_job_data(test_repository, job_data[i:j])
assert Job.objects.count() == 2
assert Job.objects.get(id=1).result == 'retry'
assert Job.objects.get(id=2).result == 'success'
assert JobLog.objects.count() == 2
def test_ingest_running_to_retry_sample_job(jm, sample_data, sample_resultset,
test_repository, mock_log_parser,
same_ingestion_cycle):
"""Process a single job structure in the job_data.txt file"""
jm.store_result_set_data(sample_resultset)
job_data = copy.deepcopy(sample_data.job_data[:1])
job = job_data[0]['job']
job_data[0]['revision'] = sample_resultset[0]['revision']
job['state'] = 'running'
job['result'] = 'unknown'
def _simulate_retry_job(job):
job['state'] = 'completed'
job['result'] = 'retry'
# convert the job_guid to what it would be on a retry
job['job_guid'] = job['job_guid'] + "_" + str(
job['end_timestamp'])[-5:]
return job
if same_ingestion_cycle:
# now we simulate the complete version of the job coming in (on the
# same push)
new_job_datum = copy.deepcopy(job_data[0])
new_job_datum['job'] = _simulate_retry_job(new_job_datum['job'])
job_data.append(new_job_datum)
jm.store_job_data(job_data)
initial_job_id = jm.get_job_list(0, 1)[0]["id"]
else:
# store the job in the initial state
jm.store_job_data(job_data)
initial_job_id = jm.get_job_list(0, 1)[0]["id"]
# now we simulate the complete version of the job coming in and
# ingest a second time
job = _simulate_retry_job(job)
jm.store_job_data(job_data)
jl = jm.get_job_list(0, 10)
assert len(jl) == 1
assert jl[0]['result'] == 'retry'
assert jl[0]['id'] == initial_job_id
assert Job.objects.count() == 1
assert JobLog.objects.count() == 1
intermediary_job = Job.objects.all()[0]
assert intermediary_job.project_specific_id == initial_job_id
# intermediary guid should be the retry one
assert intermediary_job.guid == job_data[-1]['job']['job_guid']
def test_ingest_running_to_retry_sample_job(jm, sample_data,
sample_resultset, test_repository,
mock_log_parser,
same_ingestion_cycle):
"""Process a single job structure in the job_data.txt file"""
jm.store_result_set_data(sample_resultset)
job_data = copy.deepcopy(sample_data.job_data[:1])
job = job_data[0]['job']
job_data[0]['revision'] = sample_resultset[0]['revision']
job['state'] = 'running'
job['result'] = 'unknown'
def _simulate_retry_job(job):
job['state'] = 'completed'
job['result'] = 'retry'
# convert the job_guid to what it would be on a retry
job['job_guid'] = job['job_guid'] + "_" + str(job['end_timestamp'])[-5:]
return job
if same_ingestion_cycle:
# now we simulate the complete version of the job coming in (on the
# same push)
new_job_datum = copy.deepcopy(job_data[0])
new_job_datum['job'] = _simulate_retry_job(new_job_datum['job'])
job_data.append(new_job_datum)
jm.store_job_data(job_data)
initial_job_id = jm.get_job_list(0, 1)[0]["id"]
else:
# store the job in the initial state
jm.store_job_data(job_data)
initial_job_id = jm.get_job_list(0, 1)[0]["id"]
# now we simulate the complete version of the job coming in and
# ingest a second time
job = _simulate_retry_job(job)
jm.store_job_data(job_data)
jl = jm.get_job_list(0, 10)
assert len(jl) == 1
assert jl[0]['result'] == 'retry'
assert jl[0]['id'] == initial_job_id
assert Job.objects.count() == 1
assert JobLog.objects.count() == 1
intermediary_job = Job.objects.all()[0]
assert intermediary_job.project_specific_id == initial_job_id
# intermediary guid should be the retry one
assert intermediary_job.guid == job_data[-1]['job']['job_guid']
def test_ingest_running_to_retry_sample_job(
test_repository,
failure_classifications,
sample_data,
sample_push,
mock_log_parser,
same_ingestion_cycle,
):
"""Process a single job structure in the job_data.txt file"""
store_push_data(test_repository, sample_push)
job_data = copy.deepcopy(sample_data.job_data[:1])
job = job_data[0]['job']
job_data[0]['revision'] = sample_push[0]['revision']
job['state'] = 'running'
job['result'] = 'unknown'
def _simulate_retry_job(job):
job['state'] = 'completed'
job['result'] = 'retry'
# convert the job_guid to what it would be on a retry
job['job_guid'] = job['job_guid'] + "_" + str(
job['end_timestamp'])[-5:]
return job
if same_ingestion_cycle:
# now we simulate the complete version of the job coming in (on the
# same push)
new_job_datum = copy.deepcopy(job_data[0])
new_job_datum['job'] = _simulate_retry_job(new_job_datum['job'])
job_data.append(new_job_datum)
store_job_data(test_repository, job_data)
else:
# store the job in the initial state
store_job_data(test_repository, job_data)
# now we simulate the complete version of the job coming in and
# ingest a second time
job = _simulate_retry_job(job)
store_job_data(test_repository, job_data)
assert Job.objects.count() == 1
job = Job.objects.get(id=1)
assert job.result == 'retry'
# guid should be the retry one
assert job.guid == job_data[-1]['job']['job_guid']
def test_ingest_running_to_retry_to_success_sample_job_multiple_retries(
jm, sample_data, sample_resultset, test_repository, mock_log_parser,
ingestion_cycles):
# this verifies that if we try to ingest multiple retries:
# (1) nothing errors out
# (2) we only end up with two jobs (the original + a retry job)
# should work but doesn't (generates 3 jobs): [(0, 2), (2, 4)],
jm.store_result_set_data(sample_resultset)
job_datum = copy.deepcopy(sample_data.job_data[0])
job_datum['revision'] = sample_resultset[0]['revision']
job = job_datum['job']
job_guid_root = job['job_guid']
job_data = []
for (state, result,
job_guid) in [('running', 'unknown', job_guid_root),
('completed', 'retry',
job_guid_root + "_" + str(job['end_timestamp'])[-5:]),
('completed', 'retry', job_guid_root + "_12345"),
('completed', 'success', job_guid_root)]:
new_job_datum = copy.deepcopy(job_datum)
new_job_datum['job']['state'] = state
new_job_datum['job']['result'] = result
new_job_datum['job']['job_guid'] = job_guid
job_data.append(new_job_datum)
for (i, j) in ingestion_cycles:
ins = job_data[i:j]
jm.store_job_data(ins)
print Job.objects.all()
print Job.objects.all()
jl = jm.get_job_list(0, 10)
assert len(jl) == 2
assert jl[0]['result'] == 'retry'
assert jl[1]['result'] == 'success'
assert Job.objects.count() == 2
assert JobLog.objects.count() == 2
assert set(Job.objects.values_list('id', flat=True)) == set(
[j['id'] for j in jl])
def test_ingest_running_to_retry_to_success_sample_job_multiple_retries(
test_repository,
failure_classifications,
sample_data,
sample_push,
mock_log_parser,
ingestion_cycles,
):
# this verifies that if we ingest multiple retries:
# (1) nothing errors out
# (2) we end up with three jobs (the original + 2 retry jobs)
store_push_data(test_repository, sample_push)
job_datum = copy.deepcopy(sample_data.job_data[0])
job_datum['revision'] = sample_push[0]['revision']
job = job_datum['job']
job_guid_root = job['job_guid']
job_data = []
for (state, result, job_guid) in [
('running', 'unknown', job_guid_root),
('completed', 'retry',
job_guid_root + "_" + str(job['end_timestamp'])[-5:]),
('completed', 'retry', job_guid_root + "_12345"),
('completed', 'success', job_guid_root),
]:
new_job_datum = copy.deepcopy(job_datum)
new_job_datum['job']['state'] = state
new_job_datum['job']['result'] = result
new_job_datum['job']['job_guid'] = job_guid
job_data.append(new_job_datum)
for (i, j) in ingestion_cycles:
ins = job_data[i:j]
store_job_data(test_repository, ins)
assert Job.objects.count() == 3
assert Job.objects.get(id=1).result == 'retry'
assert Job.objects.get(id=2).result == 'retry'
assert Job.objects.get(id=3).result == 'success'
assert JobLog.objects.count() == 3
def test_ingest_running_to_retry_to_success_sample_job_multiple_retries(
jm, sample_data, sample_resultset, test_repository,
mock_log_parser, ingestion_cycles):
# this verifies that if we try to ingest multiple retries:
# (1) nothing errors out
# (2) we only end up with two jobs (the original + a retry job)
# should work but doesn't (generates 3 jobs): [(0, 2), (2, 4)],
jm.store_result_set_data(sample_resultset)
job_datum = copy.deepcopy(sample_data.job_data[0])
job_datum['revision'] = sample_resultset[0]['revision']
job = job_datum['job']
job_guid_root = job['job_guid']
job_data = []
for (state, result, job_guid) in [
('running', 'unknown', job_guid_root),
('completed', 'retry',
job_guid_root + "_" + str(job['end_timestamp'])[-5:]),
('completed', 'retry',
job_guid_root + "_12345"),
('completed', 'success', job_guid_root)]:
new_job_datum = copy.deepcopy(job_datum)
new_job_datum['job']['state'] = state
new_job_datum['job']['result'] = result
new_job_datum['job']['job_guid'] = job_guid
job_data.append(new_job_datum)
for (i, j) in ingestion_cycles:
ins = job_data[i:j]
jm.store_job_data(ins)
print Job.objects.all()
print Job.objects.all()
jl = jm.get_job_list(0, 10)
assert len(jl) == 2
assert jl[0]['result'] == 'retry'
assert jl[1]['result'] == 'success'
assert Job.objects.count() == 2
assert JobLog.objects.count() == 2
assert set(Job.objects.values_list('id', flat=True)) == set([j['id'] for j in jl])
def test_ingest_running_to_retry_sample_job(test_repository,
failure_classifications,
sample_data,
sample_push,
mock_log_parser,
same_ingestion_cycle):
"""Process a single job structure in the job_data.txt file"""
store_push_data(test_repository, sample_push)
job_data = copy.deepcopy(sample_data.job_data[:1])
job = job_data[0]['job']
job_data[0]['revision'] = sample_push[0]['revision']
job['state'] = 'running'
job['result'] = 'unknown'
def _simulate_retry_job(job):
job['state'] = 'completed'
job['result'] = 'retry'
# convert the job_guid to what it would be on a retry
job['job_guid'] = job['job_guid'] + "_" + str(job['end_timestamp'])[-5:]
return job
if same_ingestion_cycle:
# now we simulate the complete version of the job coming in (on the
# same push)
new_job_datum = copy.deepcopy(job_data[0])
new_job_datum['job'] = _simulate_retry_job(new_job_datum['job'])
job_data.append(new_job_datum)
store_job_data(test_repository, job_data)
else:
# store the job in the initial state
store_job_data(test_repository, job_data)
# now we simulate the complete version of the job coming in and
# ingest a second time
job = _simulate_retry_job(job)
store_job_data(test_repository, job_data)
assert Job.objects.count() == 1
job = Job.objects.get(id=1)
assert job.result == 'retry'
# guid should be the retry one
assert job.guid == job_data[-1]['job']['job_guid']
def test_ingest_running_to_retry_to_success_sample_job(jm, sample_data,
sample_resultset,
test_repository,
mock_log_parser,
ingestion_cycles):
# verifies that retries to success work, no matter how jobs are batched
# should work but doesn't (retries not generated): [(0, 3)], [(0, 1), (1, 3)],
jm.store_result_set_data(sample_resultset)
job_datum = copy.deepcopy(sample_data.job_data[0])
job_datum['revision'] = sample_resultset[0]['revision']
job = job_datum['job']
job_guid_root = job['job_guid']
job_data = []
for (state, result,
job_guid) in [('running', 'unknown', job_guid_root),
('completed', 'retry',
job_guid_root + "_" + str(job['end_timestamp'])[-5:]),
('completed', 'success', job_guid_root)]:
new_job_datum = copy.deepcopy(job_datum)
new_job_datum['job']['state'] = state
new_job_datum['job']['result'] = result
new_job_datum['job']['job_guid'] = job_guid
job_data.append(new_job_datum)
for (i, j) in ingestion_cycles:
jm.store_job_data(job_data[i:j])
jl = jm.get_job_list(0, 10)
assert len(jl) == 2
assert jl[0]['result'] == 'retry'
assert jl[1]['result'] == 'success'
assert Job.objects.count() == 2
assert JobLog.objects.count() == 2
assert set(Job.objects.values_list('id', flat=True)) == set(
[j['id'] for j in jl])
def test_ingest_running_to_retry_to_success_sample_job(jm, sample_data,
sample_resultset,
test_repository,
mock_log_parser,
ingestion_cycles):
# verifies that retries to success work, no matter how jobs are batched
# should work but doesn't (retries not generated): [(0, 3)], [(0, 1), (1, 3)],
jm.store_result_set_data(sample_resultset)
job_datum = copy.deepcopy(sample_data.job_data[0])
job_datum['revision'] = sample_resultset[0]['revision']
job = job_datum['job']
job_guid_root = job['job_guid']
job_data = []
for (state, result, job_guid) in [
('running', 'unknown', job_guid_root),
('completed', 'retry',
job_guid_root + "_" + str(job['end_timestamp'])[-5:]),
('completed', 'success', job_guid_root)]:
new_job_datum = copy.deepcopy(job_datum)
new_job_datum['job']['state'] = state
new_job_datum['job']['result'] = result
new_job_datum['job']['job_guid'] = job_guid
job_data.append(new_job_datum)
for (i, j) in ingestion_cycles:
jm.store_job_data(job_data[i:j])
jl = jm.get_job_list(0, 10)
assert len(jl) == 2
assert jl[0]['result'] == 'retry'
assert jl[1]['result'] == 'success'
assert Job.objects.count() == 2
assert JobLog.objects.count() == 2
assert set(Job.objects.values_list('id', flat=True)) == set([j['id'] for j in jl])
def test_ingest_running_to_retry_to_success_sample_job_multiple_retries(
test_repository, failure_classifications, sample_data, sample_push,
mock_log_parser, ingestion_cycles):
# this verifies that if we ingest multiple retries:
# (1) nothing errors out
# (2) we end up with three jobs (the original + 2 retry jobs)
store_push_data(test_repository, sample_push)
job_datum = copy.deepcopy(sample_data.job_data[0])
job_datum['revision'] = sample_push[0]['revision']
job = job_datum['job']
job_guid_root = job['job_guid']
job_data = []
for (state, result, job_guid) in [
('running', 'unknown', job_guid_root),
('completed', 'retry',
job_guid_root + "_" + str(job['end_timestamp'])[-5:]),
('completed', 'retry',
job_guid_root + "_12345"),
('completed', 'success', job_guid_root)]:
new_job_datum = copy.deepcopy(job_datum)
new_job_datum['job']['state'] = state
new_job_datum['job']['result'] = result
new_job_datum['job']['job_guid'] = job_guid
job_data.append(new_job_datum)
for (i, j) in ingestion_cycles:
ins = job_data[i:j]
store_job_data(test_repository, ins)
assert Job.objects.count() == 3
assert Job.objects.get(id=1).result == 'retry'
assert Job.objects.get(id=2).result == 'retry'
assert Job.objects.get(id=3).result == 'success'
assert JobLog.objects.count() == 3
