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