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_access_run_result_files_local(database, tmpdir):
"""Test accessing run result files."""
# -- Setup ----------------------------------------------------------------
env = Config().basedir(tmpdir).auth()
fs = FS(env=env)
workflow_id, group_id, run_id, user_id = success_run(database, fs, tmpdir)
local_service = LocalAPIFactory(env=env, db=database, engine=StateEngine())
# -- Read result files ----------------------------------------------------
with local_service(user_id=user_id) as api:
# Map file names to file handles.
r = api.runs().get_run(run_id=run_id)
files = dict()
for fh in r['files']:
files[fh['name']] = fh['id']
# Read content of result files.
fh = api.runs().get_result_file(run_id=run_id,
file_id=files['run/results/B.json'])
results = util.read_object(fh.open())
assert results == {'B': 1}
# -- Error when user 2 attempts to read file ------------------------------
with database.session() as session:
user_2 = create_user(session, active=True)
with local_service(user_id=user_2) as api:
with pytest.raises(err.UnauthorizedAccessError):
api.runs().get_result_file(run_id=run_id,
file_id=files['run/results/B.json'])
# -- With an open access policy user 2 can read the data file -------------
env = Config().basedir(tmpdir).open_access()
local_service = LocalAPIFactory(env=env, db=database, engine=StateEngine())
with local_service(user_id=user_2) as api:
api.runs().get_result_file(run_id=run_id,
file_id=files['run/results/B.json'])
def test_result_archive_local(database, tmpdir):
"""Test getting an archive of run results."""
# -- Setup ----------------------------------------------------------------
env = Config().basedir(tmpdir).auth()
fs = FS(env=env)
workflow_id, group_id, run_id, user_id = success_run(database, fs, tmpdir)
local_service = LocalAPIFactory(env=env, db=database, engine=StateEngine())
# -- Get result archive ---------------------------------------------------
with local_service(user_id=user_id) as api:
archive = api.runs().get_result_archive(run_id=run_id)
tar = tarfile.open(fileobj=archive.open(), mode='r:gz')
members = [t.name for t in tar.getmembers()]
assert len(members) == 2
assert 'A.json' in members
assert 'run/results/B.json' in members
def test_delete_run(fscls, database, tmpdir):
"""Test deleting a run."""
# -- Setup ----------------------------------------------------------------
fs = fscls(env=Config().basedir(tmpdir))
_, _, run_id, _ = success_run(database, fs, tmpdir)
# -- Test delete run ------------------------------------------------------
with database.session() as session:
runs = RunManager(session=session, fs=fs)
runs.delete_run(run_id)
# -- Error cases ----------------------------------------------------------
with database.session() as session:
# Error when deleting an unknown run.
runs = RunManager(session=session, fs=fs)
with pytest.raises(err.UnknownRunError):
runs.delete_run(run_id)
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}