def test_obsolete_runs(fscls, database, tmpdir):
"""Test deleting runs that were created before a given date."""
# -- Setup ----------------------------------------------------------------
fs = fscls(env=Config().basedir(tmpdir))
# Create two runs (one SUCCESS and one ERROR) before a timestamp t1
_, _, run_1, _ = success_run(database, fs, tmpdir)
_, _, run_2 = error_run(database, fs, ['There were errors'])
time.sleep(1)
t1 = util.utc_now()
# Create another SUCCESS run after timestamp t1
_, _, run_3, _ = success_run(database, fs, tmpdir)
# -- Test delete run with state filter ------------------------------------
with database.session() as session:
runs = RunManager(session=session, fs=fs)
assert runs.delete_obsolete_runs(date=t1, state=st.STATE_ERROR) == 1
# After deleting the error run the two success runs still exist.
runs.get_run(run_id=run_1)
with pytest.raises(err.UnknownRunError):
runs.get_run(run_id=run_2)
runs.get_run(run_id=run_3)
# -- Test delete all runs prior to a given date ---------------------------
with database.session() as session:
runs = RunManager(session=session, fs=fs)
assert runs.delete_obsolete_runs(date=t1) == 1
# After deleting the run the only one success runs still exist.
with pytest.raises(err.UnknownRunError):
runs.get_run(run_id=run_1)
runs.get_run(run_id=run_3)
def test_cancel_run(fscls, database, tmpdir):
"""Test setting run state to canceled."""
# -- Setup ----------------------------------------------------------------
fs = fscls(env=Config().basedir(tmpdir))
with database.session() as session:
user_id = model.create_user(session, active=True)
workflow_id = model.create_workflow(session)
group_id = model.create_group(session, workflow_id, users=[user_id])
# -- Test set run to error state ------------------------------------------
with database.session() as session:
groups = WorkflowGroupManager(session=session, fs=fs)
runs = RunManager(session=session, fs=fs)
run = runs.create_run(group=groups.get_group(group_id))
run_id = run.run_id
state = run.state()
runs.update_run(run_id=run_id, state=state.cancel())
with database.session() as session:
runs = RunManager(session=session, fs=fs)
run = runs.get_run(run_id)
state = run.state()
assert not state.is_active()
assert not state.is_pending()
assert not state.is_running()
assert state.is_canceled()
assert not state.is_error()
assert not state.is_success()
assert len(state.messages) == 1
def test_run_parameters(database, tmpdir):
"""Test creating run with template arguments."""
# -- Setup ----------------------------------------------------------------
fs = FileSystemStorage(basedir=tmpdir)
with database.session() as session:
user_id = model.create_user(session, active=True)
workflow_id = model.create_workflow(session)
group_id = model.create_group(session, workflow_id, users=[user_id])
# Prepare run arguments
filename = os.path.join(str(tmpdir), 'results.json')
util.write_object(filename=filename, obj={'A': 1})
arguments = [{'id': 'A', 'value': 10}, {'id': 'B', 'value': True}]
# -- Test create run with arguments ---------------------------------------
with database.session() as session:
groups = WorkflowGroupManager(session=session, fs=fs)
runs = RunManager(session=session, fs=fs)
run = runs.create_run(
group=groups.get_group(group_id),
arguments=arguments
)
run_id = run.run_id
with database.session() as session:
runs = RunManager(session=session, fs=fs)
run = runs.get_run(run_id)
assert run.arguments == arguments
def test_run_serialization(database, tmpdir):
"""Test serialization of run handles and run listings."""
config = Config().basedir(tmpdir)
view = RunSerializer()
fs = FileSystemStore(config)
# Setup temporary run folder.
tmprundir = os.path.join(tmpdir, 'tmprun')
tmpresultsdir = os.path.join(tmprundir, 'run', 'results')
os.makedirs(tmprundir)
os.makedirs(tmpresultsdir)
f1 = os.path.join(tmprundir, 'A.json')
util.write_object(f1, {'A': 1})
# Create runs.
with database.session() as session:
user_id = model.create_user(session, active=True)
workflow_id = model.create_workflow(session)
group_id = model.create_group(session, workflow_id, users=[user_id])
# Create successful run.
groups = WorkflowGroupManager(session=session, fs=fs)
runs = RunManager(session=session, fs=fs)
run = runs.create_run(group=groups.get_group(group_id))
run_id = run.run_id
state = run.state()
runs.update_run(
run_id,
state.start().success(files=['A.json', 'run/results/B.json']),
rundir=tmprundir)
run = runs.get_run(run_id)
doc = view.run_handle(run)
validator('RunHandle').validate(doc)
# Create error run.
run = runs.create_run(group=groups.get_group(group_id))
run_id = run.run_id
state = run.state()
runs.update_run(run_id=run_id, state=state)
messages = ['There', 'were', 'many errors']
runs.update_run(run_id=run_id, state=state.error(messages))
run = runs.get_run(run_id)
doc = view.run_handle(run)
validator('RunHandle').validate(doc)
# Validate run listing.
doc = view.run_listing(runs=runs.list_runs(group_id))
validator('RunListing').validate(doc)
assert len(doc[labels.RUN_LIST]) == 2
def test_error_run(fscls, database, tmpdir):
"""Test setting run state to error."""
# -- Setup ----------------------------------------------------------------
fs = fscls(env=Config().basedir(tmpdir))
messages = ['There', 'were', 'many errors']
_, _, run_id = error_run(database, fs, messages)
with database.session() as session:
runs = RunManager(session=session, fs=fs)
run = runs.get_run(run_id)
state = run.state()
assert not state.is_active()
assert not state.is_pending()
assert not state.is_running()
assert not state.is_canceled()
assert state.is_error()
assert not state.is_success()
assert state.messages == messages
def test_success_run(database, tmpdir):
"""Test life cycle for a successful run."""
# -- Setup ----------------------------------------------------------------
fs = FileSystemStorage(basedir=tmpdir)
workflow_id, _, run_id, _ = success_run(database, fs, tmpdir)
with database.session() as session:
runs = RunManager(session=session, fs=fs)
run = runs.get_run(run_id)
state = run.state()
assert not state.is_active()
assert not state.is_pending()
assert not state.is_running()
assert not state.is_canceled()
assert not state.is_error()
assert state.is_success()
assert len(state.files) == 2
with runs.get_runfile(run_id=run_id, key='A.json').open() as f:
assert json.load(f) == {'A': 1}
with runs.get_runfile(run_id=run_id, key='results/B.json').open() as f:
assert json.load(f) == {'B': 1}
def test_success_run(fscls, database, tmpdir):
"""Test life cycle for a successful run."""
# -- Setup ----------------------------------------------------------------
fs = fscls(env=Config().basedir(tmpdir))
workflow_id, _, run_id, _ = success_run(database, fs, tmpdir)
rundir = fs.run_basedir(workflow_id=workflow_id, run_id=run_id)
with database.session() as session:
runs = RunManager(session=session, fs=fs)
run = runs.get_run(run_id)
state = run.state()
assert not state.is_active()
assert not state.is_pending()
assert not state.is_running()
assert not state.is_canceled()
assert not state.is_error()
assert state.is_success()
assert len(state.files) == 2
key = run.get_file(by_key='A.json').key
f = fs.load_file(key=os.path.join(rundir, key)).open()
assert json.load(f) == {'A': 1}
key = run.get_file(by_key='run/results/B.json').key
f = fs.load_file(key=os.path.join(rundir, key)).open()
assert json.load(f) == {'B': 1}