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_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 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_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_remote_uri(self):
crate = ROCrate()
url = ('https://raw.githubusercontent.com/ResearchObject/ro-crate-py/'
'master/test/test-data/sample_file.txt')
file_returned = crate.add_file(source=url, fetch_remote=True)
self.assertEqual(file_returned.id, 'sample_file.txt')
file_returned = crate.add_file(source=url, fetch_remote=False)
self.assertEqual(file_returned.id, url)
out_path = pathlib.Path(tempfile.gettempdir()) / 'ro_crate_out'
out_path.mkdir(exist_ok=True)
crate.write_crate(out_path)
metadata_path = out_path / 'ro-crate-metadata.jsonld'
self.assertTrue(metadata_path.exists())
file1 = out_path / 'sample_file.txt'
self.assertTrue(file1.exists())
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(test_data_dir, helpers):
crate = ROCrate(gen_preview=True)
# 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
readme_url = f'{RAW_REPO_URL}/master/README.md'
readme_entity = crate.add_file(readme_url)
assert crate.dereference(readme_url) is readme_entity
def make_crate(crate_dir, target_owner, planemo_version):
wf_id = get_wf_id(crate_dir)
planemo_id, planemo_source = get_planemo_id(crate_dir, wf_id)
crate = ROCrate(gen_preview=False)
wf_source = Path(crate_dir) / wf_id
with open(wf_source) as f:
code = json.load(f)
workflow = crate.add_workflow(wf_source,
wf_id,
main=True,
lang="galaxy",
gen_cwl=False)
handle_creator(code, crate, workflow)
workflow["name"] = crate.root_dataset["name"] = get_workflow_name(
crate_dir)
try:
workflow["version"] = code["release"]
except KeyError:
pass
wf_url = f"https://github.com/{target_owner}/{crate_dir.name}"
workflow["url"] = crate.root_dataset["isBasedOn"] = wf_url
try:
crate.root_dataset["license"] = code["license"]
except KeyError:
pass
readme_source = Path(crate_dir) / "README.md"
if readme_source.is_file():
crate.add_file(readme_source, "README.md")
suite = crate.add_test_suite(identifier="#test1")
resource = f"repos/{target_owner}/{crate_dir.name}/actions/workflows/{CI_WORKFLOW.name}"
crate.add_test_instance(suite,
GH_API_URL,
resource=resource,
service="github",
identifier="test1_1")
crate.add_test_definition(suite,
source=planemo_source,
dest_path=planemo_id,
engine="planemo",
engine_version=planemo_version)
crate.metadata.write(crate_dir)
def test_remote_uri(tmpdir, helpers, fetch_remote):
crate = ROCrate()
url = ('https://raw.githubusercontent.com/ResearchObject/ro-crate-py/'
'master/test/test-data/sample_file.txt')
if fetch_remote:
file_returned = crate.add_file(source=url,
dest_path="a/b/sample_file.txt",
fetch_remote=fetch_remote)
assert file_returned.id == 'a/b/sample_file.txt'
else:
file_returned = crate.add_file(source=url, fetch_remote=fetch_remote)
assert file_returned.id == url
out_path = tmpdir / 'ro_crate_out'
out_path.mkdir()
crate.write_crate(out_path)
metadata_path = out_path / helpers.METADATA_FILE_NAME
assert metadata_path.exists()
file1 = out_path / 'a/b/sample_file.txt'
if fetch_remote:
assert file1.exists()
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_write_zip(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?
# write to zip
zip_path = tempfile.NamedTemporaryFile(mode='w',
delete=False,
suffix='.zip')
crate.write_zip(zip_path.name)
zip_path.close()
read_zip = zipfile.ZipFile(zip_path.name, mode='r')
self.assertEqual(read_zip.getinfo('sample_file.txt').file_size, 12)
self.assertEqual(
read_zip.getinfo('test_add_dir/sample_file_subdir.txt').file_size,
18)
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_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_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
def test_file_stringio(tmpdir, helpers):
crate = ROCrate()
test_file_id = 'test_file.txt'
file_content = 'This will be the content of the file'
file_stringio = io.StringIO(file_content)
file_returned = crate.add_file(file_stringio, test_file_id)
assert file_returned.id == test_file_id
out_path = tmpdir / 'ro_crate_out'
out_path.mkdir()
crate.write_crate(out_path)
metadata_path = out_path / helpers.METADATA_FILE_NAME
assert metadata_path.exists()
file1 = out_path / test_file_id
assert file1.exists()
with open(file1) as f:
assert f.read() == file_content
def test_file_stringio(self):
crate = ROCrate()
# dereference added files
file_content = 'This will be the content of the file'
file_stringio = io.StringIO(file_content)
file_returned = crate.add_file(file_stringio, 'test_file.txt')
self.assertEqual(file_returned.id, 'test_file.txt')
out_path = pathlib.Path(tempfile.gettempdir()) / 'ro_crate_out'
crate.name = 'Test crate'
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 / 'test_file.txt'
self.assertTrue(file1.exists())
self.assertEqual(file1.stat().st_size, 36)
def test_stringio_no_dest(test_data_dir, fetch_remote, validate_url):
crate = ROCrate()
with pytest.raises(ValueError):
crate.add_file(io.StringIO("foo"))
def test_no_source_no_dest(test_data_dir, fetch_remote, validate_url):
crate = ROCrate()
with pytest.raises(ValueError):
crate.add_file()
def test_file_writing(test_data_dir, tmpdir, helpers, to_zip):
crate = ROCrate()
crate_name = 'Test crate'
crate.name = crate_name
creator_id = '001'
creator_name = 'Lee Ritenour'
new_person = crate.add_person(creator_id, {'name': creator_name})
crate.creator = new_person
sample_file_id = 'sample_file.txt'
sample_file2_id = 'subdir/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
assert 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
assert helpers.PREVIEW_FILE_NAME in json_entities
preview = json_entities[helpers.PREVIEW_FILE_NAME]
assert preview["@type"] == "CreativeWork"
assert preview["about"] == {"@id": "./"}
