def test_no_parts(tmpdir):
crate = ROCrate()
out_path = tmpdir / 'ro_crate_out'
out_path.mkdir()
crate.write_crate(out_path)
crate = ROCrate(out_path)
assert not crate.root_dataset["hasPart"]
def test_bad_crate(test_data_dir, tmpdir):
# nonexistent dir
crate_dir = test_data_dir / uuid.uuid4().hex
with pytest.raises(ValueError):
ROCrate(crate_dir)
with pytest.raises(ValueError):
ROCrate(crate_dir, init=True)
# no metadata file
crate_dir = tmpdir / uuid.uuid4().hex
crate_dir.mkdir()
with pytest.raises(ValueError):
ROCrate(crate_dir)
def test_properties():
crate = ROCrate()
crate_name = "new crate"
crate.name = crate_name
assert crate.name == crate_name
crate_description = "this is a new crate"
crate.description = crate_description
assert crate.description == crate_description
assert crate.datePublished == crate.root_dataset.datePublished
assert isinstance(crate.root_dataset.datePublished, datetime.datetime)
assert isinstance(crate.root_dataset["datePublished"], str)
crate_datePublished = datetime.datetime.now().astimezone().replace(
microsecond=0)
crate.datePublished = crate_datePublished
assert crate.datePublished == crate_datePublished
new_person = crate.add(Person(crate, '#001', {'name': 'Lee Ritenour'}))
crate.creator = new_person
assert crate.creator is new_person
assert isinstance(crate.creator, Person)
assert crate.creator['name'] == 'Lee Ritenour'
assert crate.creator.type == 'Person'
new_person2 = crate.add(Person(crate, '#002', {'name': 'Lee Ritenour'}))
crate.creator = [new_person, new_person2]
assert isinstance(crate.creator, list)
assert crate.creator[0] is new_person
assert crate.creator[1] is new_person2
def test_test_suites_prop(test_data_dir):
top_dir = test_data_dir / "ro-crate-galaxy-sortchangecase"
wf_path = top_dir / "sort-and-change-case.ga"
crate = ROCrate()
wf = crate.add(ComputationalWorkflow(crate, str(wf_path), wf_path.name))
crate.mainEntity = wf
suites = set()
assert not crate.test_suites
s1 = crate.add(TestSuite(crate, "s1"))
suites.add(s1)
crate.root_dataset["mentions"] = [s1]
assert suites == set(crate.test_suites)
s2 = crate.add(TestSuite(crate, "s2"))
crate.root_dataset["about"] = [s2]
suites.add(s2)
assert suites == set(crate.test_suites)
test_dir = crate.add_directory(dest_path="test")
assert crate.test_dir is test_dir
assert suites == set(crate.test_suites) # no "about" yet
s3 = crate.add(TestSuite(crate, "s3"))
suites.add(s3)
test_dir["about"] = [s3]
assert suites == set(crate.test_suites)
# check for duplicates
crate.root_dataset["about"] = [s1, s2]
assert sum(_ is s1 for _ in crate.test_suites) == 1
def test_file_writing(self):
crate = ROCrate()
# dereference added files
sample_file = self.test_data_dir / 'sample_file.txt'
file_returned = crate.add_file(sample_file)
self.assertEqual(file_returned.id, 'sample_file.txt')
file_returned_subdir = crate.add_file(sample_file,
'subdir/sample_file2.csv')
self.assertEqual(file_returned_subdir.id, 'subdir/sample_file2.csv')
test_dir_path = self.test_data_dir / 'test_add_dir'
test_dir_entity = crate.add_directory(test_dir_path, 'test_add_dir')
self.assertTrue(test_dir_entity is None) # is this intended?
out_path = pathlib.Path(tempfile.gettempdir()) / 'ro_crate_out'
crate.name = 'Test crate'
new_person = crate.add_person('001', {'name': 'Lee Ritenour'})
crate.creator = new_person
out_path.mkdir(exist_ok=True)
crate.write_crate(out_path)
metadata_path = out_path / 'ro-crate-metadata.jsonld'
self.assertTrue(metadata_path.exists())
preview_path = out_path / 'ro-crate-preview.html'
self.assertTrue(preview_path.exists())
file1 = out_path / 'sample_file.txt'
file2 = out_path / 'subdir' / 'sample_file2.csv'
file_subdir = out_path / 'test_add_dir' / 'sample_file_subdir.txt'
self.assertTrue(file1.exists())
self.assertTrue(file2.exists())
self.assertTrue(file_subdir.exists())
def main(args):
wd = pathlib.Path(tempfile.mkdtemp(prefix="life_monitor_"))
crate_dir = wd / pathlib.Path(args.crate_dir).name
shutil.copytree(args.crate_dir, crate_dir)
crate = ROCrate(crate_dir)
check_workflow(crate, crate_dir)
shutil.rmtree(wd)
def test_add_test_suite(test_data_dir):
top_dir = test_data_dir / "ro-crate-galaxy-sortchangecase"
wf_path = top_dir / "sort-and-change-case.ga"
crate = ROCrate()
wf = crate.add(ComputationalWorkflow(crate, str(wf_path), wf_path.name))
crate.mainEntity = wf
suites = set()
assert not crate.test_suites
s1 = crate.add_test_suite()
assert s1["mainEntity"] is wf
suites.add(s1)
assert suites == set(crate.test_suites)
s2 = crate.add_test_suite(identifier="test1")
assert s2["mainEntity"] is wf
assert s2.id == "#test1"
suites.add(s2)
assert suites == set(crate.test_suites)
s3 = crate.add_test_suite(identifier="test2", name="Test 2")
assert s3["mainEntity"] is wf
assert s3.id == "#test2"
assert s3.name == "Test 2"
suites.add(s3)
assert suites == set(crate.test_suites)
wf2_path = top_dir / "README.md"
wf2 = crate.add(ComputationalWorkflow(crate, wf2_path, wf2_path.name))
s4 = crate.add_test_suite(identifier="test3", name="Foo", main_entity=wf2)
assert s4["mainEntity"] is wf2
assert s4.id == "#test3"
assert s4.name == "Foo"
suites.add(s4)
assert suites == set(crate.test_suites)
# check filtering in test_suites property
crate.root_dataset["mentions"] += [wf]
assert set(crate.root_dataset["mentions"]) > suites
assert suites == set(crate.test_suites)
def test_update(test_data_dir, tmpdir, helpers):
crate = ROCrate()
assert not crate.root_dataset["hasPart"]
wf_path = test_data_dir / "test_galaxy_wf.ga"
john = crate.add(Person(crate, '#john', {'name': 'John Doe'}))
file_ = crate.add_file(wf_path)
assert crate.root_dataset["hasPart"] == [file_]
file_["author"] = john
assert isinstance(file_, File)
assert crate.mainEntity is None
wf = crate.add_workflow(wf_path, main=True, lang="galaxy")
assert isinstance(wf, ComputationalWorkflow)
assert wf["author"] is None
assert crate.mainEntity is wf
assert crate.dereference(john.id) is john
assert crate.dereference(file_.id) is wf
assert crate.root_dataset["hasPart"] == [wf]
assert crate.root_dataset.properties()["hasPart"] == [{
"@id":
"test_galaxy_wf.ga"
}]
out_path = tmpdir / "ro_crate_out"
out_path.mkdir()
crate.write_crate(out_path)
json_entities = helpers.read_json_entities(out_path)
helpers.check_wf_crate(json_entities, wf.id)
def test_init(test_data_dir, tmpdir, helpers, override):
crate_dir = test_data_dir / "ro-crate-galaxy-sortchangecase"
if not override:
(crate_dir / helpers.METADATA_FILE_NAME).unlink()
crate = ROCrate(crate_dir, init=True)
assert crate.dereference("./") is not None
assert crate.dereference(helpers.METADATA_FILE_NAME) is not None
fpaths = [
"LICENSE", "README.md", "sort-and-change-case.ga",
"test/test1/input.bed", "test/test1/output_exp.bed",
"test/test1/sort-and-change-case-test.yml"
]
dpaths = [
"test/",
"test/test1/",
]
for p in fpaths:
assert isinstance(crate.dereference(p), File)
for p in dpaths:
assert isinstance(crate.dereference(p), Dataset)
out_path = tmpdir / 'ro_crate_out'
out_path.mkdir()
crate.write_crate(out_path)
assert (out_path / helpers.METADATA_FILE_NAME).exists()
json_entities = helpers.read_json_entities(out_path)
data_entity_ids = fpaths + dpaths
helpers.check_crate(json_entities, data_entity_ids=data_entity_ids)
for p in fpaths:
with open(crate_dir / p) as f1, open(out_path / p) as f2:
assert f1.read() == f2.read()
def test_delete(test_data_dir):
crate = ROCrate()
# fundamental entities
with pytest.raises(ValueError):
crate.delete(crate.root_dataset)
with pytest.raises(ValueError):
crate.delete(crate.metadata)
# preview
preview = crate.add(Preview(crate))
assert preview in crate.default_entities
crate.delete(preview)
assert preview not in crate.default_entities
assert crate.preview is None
# data entities
file1 = crate.add_file(test_data_dir / "sample_file.txt")
file2 = crate.add_file(test_data_dir / "sample_cwl_wf.cwl")
for f in file1, file2:
assert f in crate.root_dataset["hasPart"]
assert f in crate.data_entities
crate.delete(file1)
assert file1 not in crate.data_entities
assert file1 not in crate.root_dataset["hasPart"]
crate.delete(file2)
assert file2 not in crate.data_entities
assert crate.root_dataset["hasPart"] is None
crate.delete(file2) # no-op
# contextual entities
john = crate.add(Person(crate, '#john', {'name': 'John Doe'}))
assert john in crate.contextual_entities
crate.delete(john)
assert john not in crate.contextual_entities
crate.delete(john) # no-op
def test_contextual_entities(self):
crate = ROCrate()
new_person = crate.add_person('joe', {'name': 'Joe Pesci'})
person_dereference = crate.dereference('#joe')
person_prop = person_dereference.properties()
self.assertEqual(person_prop['@type'], 'Person')
self.assertEqual(person_prop['name'], 'Joe Pesci')
self.assertEqual(new_person.properties(), person_prop)
def test_uuid():
crate = ROCrate()
new_person = crate.add(Person(crate, properties={"name": "No Identifier"}))
jsonld = new_person.as_jsonld()
assert "Person" == jsonld["@type"]
assert jsonld["@id"].startswith("#")
# Check it made a valid UUIDv4
u = uuid.UUID(jsonld["@id"][1:])
assert 4 == u.version
def test_contextual_entities():
crate = ROCrate()
new_person = crate.add_person('#joe', {'name': 'Joe Pesci'})
person_dereference = crate.dereference('#joe')
assert person_dereference is new_person
assert person_dereference.type == 'Person'
person_prop = person_dereference.properties()
assert person_prop['@type'] == 'Person'
assert person_prop['name'] == 'Joe Pesci'
assert not new_person.datePublished
def test_no_parts(tmpdir, helpers):
crate = ROCrate()
out_path = tmpdir / 'ro_crate_out'
out_path.mkdir()
crate.write_crate(out_path)
json_entities = helpers.read_json_entities(out_path)
helpers.check_crate(json_entities)
assert "hasPart" not in json_entities["./"]
def test_self_delete(test_data_dir):
crate = ROCrate()
path = test_data_dir / "sample_file.txt"
f = crate.add_file(
path) # with this signature, the file's id will be its basename
assert f in crate.data_entities
assert f in crate.root_dataset["hasPart"]
f.delete()
assert f not in crate.data_entities
assert crate.root_dataset["hasPart"] is None
def test_dereferencing_equivalent_id(helpers):
crate = ROCrate()
root_dataset = crate.dereference('./')
assert crate.root_dataset is root_dataset
root_dataset = crate.dereference('')
assert crate.root_dataset is root_dataset
metadata_entity = crate.dereference(helpers.METADATA_FILE_NAME)
assert crate.metadata is metadata_entity
metadata_entity = crate.dereference(f'./{helpers.METADATA_FILE_NAME}')
assert crate.metadata is metadata_entity
def test_properties(self):
crate = ROCrate()
new_person = crate.add_person('001', {'name': 'Lee Ritenour'})
crate.creator = new_person
self.assertIsInstance(crate.creator, Person)
self.assertEqual(crate.creator['name'], 'Lee Ritenour')
new_person2 = crate.add_person('002', {'name': 'Lee Ritenour'})
crate.creator = [new_person, new_person2]
self.assertIsInstance(crate.creator, list)
def test_dereferencing_equivalent_id(self):
crate = ROCrate()
root_dataset = crate.dereference('./')
self.assertEqual(crate.root_dataset, root_dataset)
root_dataset = crate.dereference('')
self.assertEqual(crate.root_dataset, root_dataset)
metadata_entity = crate.dereference('./ro-crate-metadata.jsonld')
self.assertEqual(metadata_entity, crate.metadata)
metadata_entity = crate.dereference('ro-crate-metadata.jsonld')
self.assertEqual(metadata_entity, crate.metadata)
def test_no_zip_in_zip(test_data_dir, tmpdir):
crate_dir = test_data_dir / 'ro-crate-galaxy-sortchangecase'
crate = ROCrate(crate_dir)
zip_name = 'ro_crate_out.crate.zip'
zip_path = crate_dir / zip_name # within the crate dir
crate.write_zip(zip_path)
out_path = tmpdir / 'ro_crate_out'
with zipfile.ZipFile(zip_path, "r") as zf:
zf.extractall(out_path)
assert not (out_path / zip_name).exists()
def test_create():
crate = ROCrate()
test_service = TestService(crate, identifier=JENKINS)
crate.add(test_service)
test_service.name = "Jenkins"
test_service.url = {"@id": "https://www.jenkins.io"}
assert test_service.name == "Jenkins"
assert test_service.url == "https://www.jenkins.io"
test_instance = TestInstance(crate, identifier="#foo_instance_1")
crate.add(test_instance)
test_instance.name = "Foo Instance 1"
test_instance.url = {"@id": "http://example.org/foo"}
test_instance.resource = "job/foobar"
test_instance.runsOn = test_service
assert test_instance.name == "Foo Instance 1"
assert test_instance.url == "http://example.org/foo"
assert test_instance.resource == "job/foobar"
assert test_instance.runsOn is test_service
test_instance.runsOn = None
test_instance.service = test_service
assert test_instance.service is test_service
test_engine = SoftwareApplication(crate, identifier=PLANEMO)
crate.add(test_engine)
test_engine.name = "Planemo"
test_engine.url = {"@id": "https://github.com/galaxyproject/planemo"}
assert test_engine.name == "Planemo"
assert test_engine.url == "https://github.com/galaxyproject/planemo"
test_definition = TestDefinition(crate, dest_path="test/foo/bar.yml")
crate.add(test_definition)
test_definition.conformsTo = test_engine
assert test_definition.conformsTo is test_engine
test_definition.conformsTo = None
test_definition.engine = test_engine
test_definition.engineVersion = ">=0.70"
assert test_definition.engine is test_engine
assert test_definition.engineVersion == ">=0.70"
test_suite = TestSuite(crate, "#foosuite")
crate.add(test_suite)
assert test_suite.id == "#foosuite"
assert test_suite.type == "TestSuite"
test_suite.name = "Foo Suite"
test_suite.instance = [test_instance]
test_suite.definition = test_definition
assert test_suite.name == "Foo Suite"
assert len(test_suite.instance) == 1
assert test_suite.instance[0] is test_instance
assert test_suite.definition is test_definition
def test_missing_source(test_data_dir, fetch_remote, validate_url):
crate = ROCrate()
path = test_data_dir / uuid.uuid4().hex
with pytest.raises(ValueError):
crate.add_file(str(path),
fetch_remote=fetch_remote,
validate_url=validate_url)
with pytest.raises(ValueError):
crate.add_file(str(path),
path.name,
fetch_remote=fetch_remote,
validate_url=validate_url)
def test_dataset(test_data_dir, tmpdir):
crate = ROCrate()
path = test_data_dir / "a" / "b"
d1 = crate.add_dataset(str(path))
assert crate.dereference("b") is d1
d2 = crate.add_dataset(str(path), "a/b")
assert crate.dereference("a/b") is d2
out_path = tmpdir / 'ro_crate_out'
out_path.mkdir()
crate.write_crate(out_path)
assert (out_path / "b").is_dir()
assert (out_path / "a" / "b").is_dir()
def test_read(test_data_dir, helpers):
crate_dir = test_data_dir / 'ro-crate-galaxy-sortchangecase'
crate = ROCrate(crate_dir)
wf_id = 'sort-and-change-case.ga'
main_wf = crate.dereference(wf_id)
wf_prop = main_wf.properties()
assert wf_prop['@id'] == wf_id
assert wf_prop['@id'] == main_wf.id
assert set(wf_prop['@type']) == helpers.WORKFLOW_TYPES
test_service = crate.dereference(JENKINS)
assert test_service.id == JENKINS
assert test_service.type == "TestService"
assert test_service.name == "Jenkins"
assert test_service.url == "https://www.jenkins.io"
test_instance = crate.dereference("#test1_1")
assert test_instance.id == "#test1_1"
assert test_instance.type == "TestInstance"
assert test_instance.name == "test1_1"
assert test_instance.url == "http://example.org/jenkins"
assert test_instance.resource == "job/tests/"
assert test_instance.runsOn is test_service
assert test_instance.service is test_service
test_engine = crate.dereference(PLANEMO)
assert test_engine.id == PLANEMO
assert test_engine.type == "SoftwareApplication"
assert test_engine.name == "Planemo"
assert test_engine.url == "https://github.com/galaxyproject/planemo"
def_id = "test/test1/sort-and-change-case-test.yml"
test_definition = crate.dereference(def_id)
assert test_definition.id == def_id
assert set(test_definition.type) == {"File", "TestDefinition"}
assert test_definition.conformsTo is test_engine
assert test_definition.engine is test_engine
assert test_definition.engineVersion == ">=0.70"
test_suite = crate.dereference("#test1")
assert test_suite.id == "#test1"
assert test_suite.type == "TestSuite"
assert test_suite.name == "test1"
assert len(test_suite.instance) == 1
assert test_suite.instance[0] is test_instance
assert test_suite.definition is test_definition
assert test_suite["mainEntity"] is main_wf
assert set(crate.test_suites) == {test_suite}
def test_contextual_entities():
crate = ROCrate()
new_person = crate.add(Person(crate, '#joe', {'name': 'Joe Pesci'}))
person_dereference = crate.dereference('#joe')
assert person_dereference is new_person
assert person_dereference.type == 'Person'
person_prop = person_dereference.properties()
assert person_prop['@type'] == 'Person'
assert person_prop['name'] == 'Joe Pesci'
assert not new_person.datePublished
id_ = "https://orcid.org/0000-0002-1825-0097"
new_person = crate.add(Person(crate, id_, {'name': 'Josiah Carberry'}))
person_dereference = crate.dereference(id_)
assert person_dereference is new_person
def test_remote_uri_exceptions(tmpdir):
crate = ROCrate()
url = ('https://raw.githubusercontent.com/ResearchObject/ro-crate-py/'
f'master/test/test-data/{uuid.uuid4().hex}.foo')
crate.add_file(source=url, fetch_remote=True)
out_path = tmpdir / 'ro_crate_out_1'
out_path.mkdir()
with pytest.raises(URLError):
crate.write_crate(out_path)
crate = ROCrate()
url = ('https://raw.githubusercontent.com/ResearchObject/ro-crate-py/'
'master/test/test-data/sample_file.txt')
crate.add_file(source=url,
dest_path="a/sample_file.txt",
fetch_remote=True)
out_path = tmpdir / 'ro_crate_out_2'
out_path.mkdir()
(out_path / "a").mkdir(mode=0o444)
try:
crate.write_crate(out_path)
except PermissionError:
pass
def test_legacy_crate(test_data_dir, tmpdir, helpers):
crate_dir = test_data_dir / 'read_crate'
# Remove the metadata file, leaving only the legacy one
(crate_dir / helpers.METADATA_FILE_NAME).unlink()
crate = ROCrate(crate_dir)
md_prop = crate.metadata.properties()
assert crate.dereference(
helpers.LEGACY_METADATA_FILE_NAME) is crate.metadata
assert md_prop['conformsTo'] == {'@id': helpers.LEGACY_PROFILE}
main_wf = crate.dereference('test_galaxy_wf.ga')
wf_prop = main_wf.properties()
assert set(wf_prop['@type']) == helpers.LEGACY_WORKFLOW_TYPES
def test_dereferencing_equivalent_id(test_data_dir, name):
test_ids = [name, f'./{name}', f'.//{name}', f'./a/../{name}']
path = test_data_dir / name
if name.endswith("/"):
path.mkdir()
test_ids.extend([f"{name}/", f"{name}//"])
else:
path.touch()
for id_ in test_ids:
crate = ROCrate()
if name.endswith("/"):
entity = crate.add_directory(path, name)
else:
entity = crate.add_file(path, name)
deref_entity = crate.dereference(id_)
assert deref_entity is entity
def test_delete_refs(test_data_dir, tmpdir, helpers):
def_path = "test/test1/sort-and-change-case-test.yml"
crate = ROCrate(test_data_dir / 'ro-crate-galaxy-sortchangecase')
suite = crate.dereference("#test1")
definition = crate.dereference(def_path)
assert suite.definition is definition
crate.delete(definition)
assert suite.definition is not definition # so far, so good
assert suite.definition == str(def_path) # should probably be set to None
crate.write_crate("/tmp/crate_out")
# check json output
out_path = tmpdir / "ro_crate_out"
crate.write_crate(out_path)
json_entities = helpers.read_json_entities(out_path)
assert def_path not in json_entities # good
assert json_entities["#test1"]["definition"]["@id"] == def_path # not good
def test_dereferencing(self):
crate = ROCrate()
# verify default entities
root_dataset = crate.dereference('./')
self.assertEqual(crate.root_dataset, root_dataset)
metadata_entity = crate.dereference('./ro-crate-metadata.jsonld')
self.assertEqual(metadata_entity, crate.metadata)
# dereference added files
sample_file = self.test_data_dir / 'sample_file.txt'
file_returned = crate.add_file(sample_file)
self.assertIsInstance(file_returned, File)
dereference_file = crate.dereference("sample_file.txt")
self.assertIsInstance(dereference_file, File)
self.assertEqual(file_returned, dereference_file)
def test_dereferencing(test_data_dir, helpers):
crate = ROCrate()
# verify default entities
root_dataset = crate.dereference('./')
assert crate.root_dataset is root_dataset
metadata_entity = crate.dereference(helpers.METADATA_FILE_NAME)
assert crate.metadata is metadata_entity
preview_entity = crate.dereference(helpers.PREVIEW_FILE_NAME)
assert preview_entity is crate.preview
# dereference added files
sample_file = test_data_dir / 'sample_file.txt'
file_returned = crate.add_file(sample_file)
assert isinstance(file_returned, File)
dereference_file = crate.dereference("sample_file.txt")
assert file_returned is dereference_file
