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_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_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_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_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_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_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_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_add_test_instance(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
suite = crate.add_test_suite()
instances = set()
assert crate.dereference(JENKINS) is None
assert crate.dereference(TRAVIS) is None
i1 = crate.add_test_instance(suite, "http://example.com")
assert crate.dereference(JENKINS) is i1.service
assert crate.dereference(TRAVIS) is None
assert i1.url == "http://example.com"
instances.add(i1)
assert instances == set(suite.instance)
i2 = crate.add_test_instance(suite.id, "http://example.com")
assert i2.url == "http://example.com"
instances.add(i2)
assert instances == set(suite.instance)
i3 = crate.add_test_instance(suite, "http://example.com", resource="jobs")
assert i3.url == "http://example.com"
assert i3.resource == "jobs"
instances.add(i3)
assert instances == set(suite.instance)
i4 = crate.add_test_instance(suite, "http://example.com", service="travis")
assert i4.url == "http://example.com"
assert i4.service.id == TRAVIS
assert i4.service is crate.dereference(TRAVIS)
instances.add(i4)
assert instances == set(suite.instance)
i5 = crate.add_test_instance(suite,
"http://example.com",
identifier="test_1_1")
assert i5.url == "http://example.com"
assert i5.id == "#test_1_1"
instances.add(i5)
assert instances == set(suite.instance)
i6 = crate.add_test_instance(suite,
"http://example.com",
name="Test 1 Instance 1")
assert i6.url == "http://example.com"
assert i6.name == "Test 1 Instance 1"
instances.add(i6)
assert instances == set(suite.instance)
def test_add_test_definition(test_data_dir, engine, engine_version):
top_dir = test_data_dir / "ro-crate-galaxy-sortchangecase"
wf_path = top_dir / "sort-and-change-case.ga"
def_path = top_dir / "test" / "test1" / "sort-and-change-case-test.yml"
crate = ROCrate()
wf = crate.add(ComputationalWorkflow(crate, str(wf_path), wf_path.name))
crate.mainEntity = wf
suite = crate.add_test_suite()
assert crate.dereference(PLANEMO) is None
kwargs = {"source": def_path}
if engine:
kwargs["engine"] = engine
if engine_version:
kwargs["engine_version"] = engine_version
d = crate.add_test_definition(suite, **kwargs)
assert crate.dereference(PLANEMO) is d.engine
if engine_version:
assert d.engineVersion == engine_version
def test_file_writing(test_data_dir, tmpdir, helpers, gen_preview, to_zip):
crate = ROCrate(gen_preview=gen_preview)
crate_name = 'Test crate'
crate.name = crate_name
creator_id = '001'
creator_name = 'Lee Ritenour'
new_person = Person(crate, creator_id, {'name': creator_name})
crate.add(new_person)
crate.creator = new_person
sample_file_id = 'sample_file.txt'
sample_file2_id = 'a/b/sample_file2.csv'
test_dir_id = 'test_add_dir/'
data_entity_ids = [sample_file_id, sample_file2_id, test_dir_id]
file_subdir_id = 'sample_file_subdir.txt'
sample_file = test_data_dir / sample_file_id
file_returned = crate.add_file(sample_file)
assert file_returned.id == sample_file_id
file_returned_subdir = crate.add_file(sample_file, sample_file2_id)
assert file_returned_subdir.id == sample_file2_id
test_dir_path = test_data_dir / test_dir_id
test_dir_entity = crate.add_directory(test_dir_path, test_dir_id)
assert isinstance(test_dir_entity, Dataset)
out_path = tmpdir / 'ro_crate_out'
if to_zip:
zip_path = tmpdir / 'ro_crate_out.crate.zip'
crate.write_zip(zip_path)
with zipfile.ZipFile(zip_path, "r") as zf:
zf.extractall(out_path)
else:
out_path.mkdir()
crate.write_crate(out_path)
metadata_path = out_path / helpers.METADATA_FILE_NAME
assert metadata_path.exists()
preview_path = out_path / helpers.PREVIEW_FILE_NAME
if gen_preview:
assert preview_path.exists()
else:
assert not preview_path.exists()
file1 = out_path / sample_file_id
file2 = out_path / sample_file2_id
file_subdir = out_path / test_dir_id / file_subdir_id
assert file1.exists()
with open(sample_file) as f1, open(file1) as f2:
sample_file_content = f1.read()
assert sample_file_content == f2.read()
assert file2.exists()
with open(file2) as f:
assert sample_file_content == f.read()
assert file_subdir.exists()
with open(test_dir_path / file_subdir_id) as f1, open(file_subdir) as f2:
assert f1.read() == f2.read()
json_entities = helpers.read_json_entities(out_path)
helpers.check_crate(json_entities, data_entity_ids=data_entity_ids)
root = json_entities["./"]
assert root["name"] == crate_name
assert "datePublished" in root
formatted_creator_id = f"#{creator_id}"
assert root["creator"] == {"@id": formatted_creator_id}
assert formatted_creator_id in json_entities
assert json_entities[formatted_creator_id]["name"] == creator_name
if gen_preview:
assert helpers.PREVIEW_FILE_NAME in json_entities
