def update_github_metadata( self, dandiset_ids: Sequence[str], exclude: Optional[re.Pattern[str]], ) -> None: ds_stats: List[DandisetStats] = [] for d in self.get_dandisets(dandiset_ids, exclude=exclude): ds = Dataset(self.target_path / d.identifier) repo = self.get_github_repo_for_dataset(ds) log.info("Setting metadata for %s ...", repo.full_name) stats = self.get_dandiset_stats(ds) repo.edit( homepage=f"https://identifiers.org/DANDI:{d.identifier}", description=self.describe_dandiset(d, stats), ) ds_stats.append(stats) if not dandiset_ids and exclude is None: superds = Dataset(self.target_path) self.set_superds_description(superds, ds_stats)
def test_drop_after(self, path): ds = Dataset(path).create(force=True) ds.repo.set_gitattributes([('a*', {'annex.largefiles': 'nothing'})]) # make some files go to git, so we could test that we do not blow # while trying to drop what is in git not annex res = ds.addurls(self.json_file, '{url}', '{name}', drop_after=True) assert_result_count(res, 3, action='addurl', status='ok') # a, b, c even if a goes to git assert_result_count(res, 2, action='drop', status='ok') # b, c
def test_addurls_stdin_input_command_line(self, path): # The previous test checks all the cases, but it overrides sys.stdin. # Do a simple check that's closer to a command line call. Dataset(path).create(force=True) runner = WitlessRunner(cwd=path) with open(self.json_file) as jfh: runner.run(["datalad", "addurls", '-', '{url}', '{name}'], stdin=jfh) for fname in ["a", "b", "c"]: ok_exists(op.join(path, fname))
def test_zip_archive(path): ds = Dataset(opj(path, 'ds')).create(force=True, no_annex=True) ds.add('.') with chpwd(path): ds.export_archive(filename='my', archivetype='zip') assert_true(os.path.exists('my.zip')) custom1_md5 = md5sum('my.zip') time.sleep(1.1) ds.export_archive(filename='my', archivetype='zip') assert_equal(md5sum('my.zip'), custom1_md5)
def check_integration1(login, keyring, path, organization=None, kwargs={}, oauthtokens=None): kwargs = kwargs.copy() if organization: kwargs['github_organization'] = organization ds = Dataset(path).create() config_patch = {} if oauthtokens: config_patch['hub.oauthtoken'] = tuple(ensure_list(oauthtokens)) # so we do not pick up local repo configuration/token repo_name = 'test_integration1' # ATM all the github goodness does not care about "this dataset" # so patch the global config with patch_config(config_patch): # everything works just nice, no conflicts etc res = ds.create_sibling_github(repo_name, **kwargs) if organization: url_fmt = 'https://{login}@github.com/{organization}/{repo_name}.git' else: url_fmt = 'https://github.com/{login}/{repo_name}.git' assert_in_results(res, path=ds.path, url=url_fmt.format(**locals()), preexisted=False) # but if we rerun - should kaboom since already has this sibling: assert_in_results( ds.create_sibling_github(repo_name, on_failure='ignore', **kwargs), message=('already has a configured sibling "%s"', 'github'), status='error', ) # but we can give it a new name, but it should kaboom since the remote one # exists already assert_in_results( ds.create_sibling_github(repo_name, name="github2", on_failure='ignore', **kwargs), message=('repository "%s" already exists on Github', 'test_integration1'), status='error', ) # we should not leave the broken sibling behind assert_not_in('github2', ds.repo.get_remotes()) # If we ask to reconfigure - should proceed normally ds.create_sibling_github(repo_name, existing='reconfigure', **kwargs)
def test_archive(path): ds = Dataset(opj(path, 'ds')).create(force=True) ds.add('.') committed_date = ds.repo.get_commit_date() default_outname = opj(path, 'datalad_{}.tar.gz'.format(ds.id)) with chpwd(path): res = list(ds.export_archive()) assert_status('ok', res) assert_result_count(res, 1) assert (isabs(res[0]['path'])) assert_true(os.path.exists(default_outname)) custom_outname = opj(path, 'myexport.tar.gz') # feed in without extension ds.export_archive(filename=custom_outname[:-7]) assert_true(os.path.exists(custom_outname)) custom1_md5 = md5sum(custom_outname) # encodes the original archive filename -> different checksum, despit # same content assert_not_equal(md5sum(default_outname), custom1_md5) # should really sleep so if they stop using time.time - we know time.sleep(1.1) ds.export_archive(filename=custom_outname) # should not encode mtime, so should be identical assert_equal(md5sum(custom_outname), custom1_md5) def check_contents(outname, prefix): with tarfile.open(outname) as tf: nfiles = 0 for ti in tf: # any annex links resolved assert_false(ti.issym()) ok_startswith(ti.name, prefix + '/') assert_equal(ti.mtime, committed_date) if '.datalad' not in ti.name: # ignore any files in .datalad for this test to not be # susceptible to changes in how much we generate a meta info nfiles += 1 # we have exactly four files (includes .gitattributes for default # MD5E backend), and expect no content for any directory assert_equal(nfiles, 4) check_contents(default_outname, 'datalad_%s' % ds.id) check_contents(custom_outname, 'myexport') # now loose some content if ds.repo.is_direct_mode(): # in direct mode the add() aove commited directly to the annex/direct/master # branch, hence drop will have no effect (notneeded) # this might be undesired behavior (or not), but this is not the place to test # for it return ds.drop('file_up', check=False) assert_raises(IOError, ds.export_archive, filename=opj(path, 'my')) ds.export_archive(filename=opj(path, 'partial'), missing_content='ignore') assert_true(os.path.exists(opj(path, 'partial.tar.gz')))
def test_download_url_dataset(toppath=None, topurl=None, path=None): # Non-dataset directory. file1_fullpath = opj(path, "file1.txt") with chpwd(path): download_url(topurl + "file1.txt") ok_exists(file1_fullpath) os.remove(file1_fullpath) files_tosave = ['file1.txt', 'file2.txt'] urls_tosave = [topurl + f for f in files_tosave] ds = Dataset(opj(path, "ds")).create() # By default, files are saved when called in a dataset. ds.download_url(urls_tosave) for fname in files_tosave: ok_(ds.repo.file_has_content(fname)) eq_(ds.repo.get_urls("file1.txt"), [urls_tosave[0]]) eq_(ds.repo.get_urls("file2.txt"), [urls_tosave[1]]) ds.download_url([topurl + "file3.txt"], save=False) assert_false(ds.repo.file_has_content("file3.txt")) # Leading paths for target are created if needed. subdir_target = opj("l1", "l2", "f") ds.download_url([opj(topurl, "file1.txt")], path=subdir_target) ok_(ds.repo.file_has_content(subdir_target)) subdir_path = opj(ds.path, "subdir", "") os.mkdir(subdir_path) with chpwd(subdir_path): download_url(topurl + "file4.txt") download_url(topurl + "file5.txt", path="five.txt") ds.download_url(topurl + "file6.txt") download_url(topurl + "file7.txt", dataset=ds.path) # download_url calls within a subdirectory save the file there ok_(ds.repo.file_has_content(opj("subdir", "file4.txt"))) ok_(ds.repo.file_has_content(opj("subdir", "five.txt"))) # ... unless the dataset instance is provided ok_(ds.repo.file_has_content("file6.txt")) # ... but a string for the dataset (as it would be from the command line) # still uses CWD semantics ok_(ds.repo.file_has_content(opj("subdir", "file7.txt"))) with chpwd(path): # We're in a non-dataset path and pass in a string as the dataset. The # path is taken as relative to the current working directory, so we get # an error when trying to save it. assert_in_results(download_url(topurl + "file8.txt", dataset=ds.path, on_failure="ignore"), status="error", action="status") assert_false((ds.pathobj / "file8.txt").exists())
def test_create_alias(ds_path, ria_path, clone_path): ds_path = Path(ds_path) clone_path = Path(clone_path) ds_path.mkdir() dsa = Dataset(ds_path / "a").create() res = dsa.create_sibling_ria(url="ria+file://{}".format(ria_path), name="origin", alias="ds-a") assert_result_count(res, 1, status='ok', action='create-sibling-ria') eq_(len(res), 1) ds_clone = clone(source="ria+file://{}#~ds-a".format(ria_path), path=clone_path / "a") assert_repo_status(ds_clone.path) # multiple datasets in a RIA store with different aliases work dsb = Dataset(ds_path / "b").create() res = dsb.create_sibling_ria(url="ria+file://{}".format(ria_path), name="origin", alias="ds-b") assert_result_count(res, 1, status='ok', action='create-sibling-ria') eq_(len(res), 1) ds_clone = clone(source="ria+file://{}#~ds-b".format(ria_path), path=clone_path / "b") assert_repo_status(ds_clone.path) # second dataset in a RIA store with the same alias emits a warning dsc = Dataset(ds_path / "c").create() with swallow_logs(logging.WARNING) as cml: res = dsc.create_sibling_ria(url="ria+file://{}".format(ria_path), name="origin", alias="ds-a") assert_in( "Alias 'ds-a' already exists in the RIA store, not adding an alias", cml.out) assert_result_count(res, 1, status='ok', action='create-sibling-ria') eq_(len(res), 1)
def test_bf2458(src=None, dst=None): ds = Dataset(src).create(force=True) ds.save(to_git=False) # no clone (empty) into new dst clone = install(source=ds.path, path=dst) # content is not here eq_(clone.repo.whereis('dummy'), [ds.config.get('annex.uuid')]) # check that plain metadata access does not `get` stuff clone.metadata('.', on_failure='ignore') eq_(clone.repo.whereis('dummy'), [ds.config.get('annex.uuid')])
def test_add_archive_single_file(repo_path=None): ds = Dataset(repo_path).create(force=True) with chpwd(repo_path): archives = glob('archives/*') ds.save(archives, message='Added archives') for archive in archives: archive_name = os.path.splitext(archive)[0] archive_content = os.path.basename(archive_name) ds.add_archive_content(archive) ok_file_has_content(archive_name, archive_content)
def test_addurls_subdataset(self=None, path=None): ds = Dataset(path).create(force=True) for save in True, False: label = "save" if save else "nosave" with swallow_outputs() as cmo: ds.addurls(self.json_file, "{url}", "{subdir}-" + label + "//{name}", save=save, cfg_proc=["yoda"]) # The custom result renderer transforms the subdataset # action=create results into something more informative than # "create(ok): . (dataset)"... assert_in("create(ok): foo-{} (dataset)".format(label), cmo.out) # ... and that doesn't lose the standard summary. assert_in("create (ok: 2)", cmo.out) subdirs = [ op.join(ds.path, "{}-{}".format(d, label)) for d in ["foo", "bar"] ] subdir_files = dict(zip(subdirs, [["a", "c"], ["b"]])) for subds, fnames in subdir_files.items(): for fname in fnames: ok_exists(op.join(subds, fname)) # cfg_proc was applied generated subdatasets. ok_exists(op.join(subds, "code")) if save: assert_repo_status(path) else: # The datasets are create but not saved (since asked not to) assert_repo_status(path, untracked=subdirs) # but the downloaded files aren't. for subds, fnames in subdir_files.items(): assert_repo_status(subds, added=fnames) # Now save the "--nosave" changes and check that we have # all the subdatasets. ds.save() eq_( set(subdatasets(dataset=ds, recursive=True, result_xfm="relpaths")), {"foo-save", "bar-save", "foo-nosave", "bar-nosave"}) # We don't try to recreate existing subdatasets. with swallow_logs(new_level=logging.DEBUG) as cml: ds.addurls(self.json_file, "{url}", "{subdir}-nosave//{name}", result_renderer='disabled') assert_in("Not creating subdataset at existing path", cml.out)
def test_custom_commit_date(tmp_path: Path) -> None: ds = Dataset(tmp_path) ds.create(cfg_proc="text2git") (tmp_path / "file.txt").write_text("This is test text.\n") with custom_commit_date( datetime(2021, 6, 1, 12, 34, 56, tzinfo=timezone.utc)): ds.save(message="Add a file") repo = GitRepo(tmp_path) assert repo.get_commit_date("HEAD") == "2021-06-01T12:34:56+00:00" assert repo.get_commit_author( "HEAD") == "DANDI User <*****@*****.**>"
def test_addurls_invalid_input(self=None, path=None): ds = Dataset(path).create(force=True) in_file = op.join(path, "in") for in_type in au.INPUT_TYPES: with assert_raises(IncompleteResultsError) as exc: ds.addurls(in_file, "{url}", "{name}", input_type=in_type, result_renderer='disabled') assert_in("Failed to read", str(exc.value))
def create_study(json_data): study_id = json_data["name"] folder_name = studies_folder + "/" + study_id if not os.path.isdir(folder_name): os.makedirs(folder_name) datalad_dataset = Dataset(folder_name) file_name = studies_folder + "/" + study_id + "/" + study_id + ".json" with open(file_name, 'w') as f: json.dump(json_data, f, ensure_ascii=False, indent=4) datalad_dataset.save(file_name, message="new file " + file_name + " for study")
def test_addurls_repindex(self, path): ds = Dataset(path).create(force=True) with assert_raises(IncompleteResultsError) as raised: ds.addurls(self.json_file, "{url}", "{subdir}") assert_in("There are file name collisions", str(raised.exception)) ds.addurls(self.json_file, "{url}", "{subdir}-{_repindex}") for fname in ["foo-0", "bar-0", "foo-1"]: ok_exists(op.join(ds.path, fname))
def test_addurls(self, path): ds = Dataset(path).rev_create(force=True) def get_annex_commit_counts(): return int( ds.repo.repo.git.rev_list("--count", "git-annex").strip()) n_annex_commits = get_annex_commit_counts() with chpwd(path): ds.addurls(self.json_file, "{url}", "{name}") filenames = ["a", "b", "c"] for fname in filenames: ok_exists(fname) for (fname, meta), subdir in zip(ds.repo.get_metadata(filenames), ["foo", "bar", "foo"]): assert_dict_equal(meta, {"subdir": [subdir], "name": [fname]}) # Ignore this check if we're faking dates because that disables # batch mode. if not os.environ.get('DATALAD_FAKE__DATES'): # We should have two new commits on the git-annex: one for the # added urls and one for the added metadata. eq_(n_annex_commits + 2, get_annex_commit_counts()) # Add to already existing links, overwriting. with swallow_logs(new_level=logging.DEBUG) as cml: ds.addurls(self.json_file, "{url}", "{name}", ifexists="overwrite") for fname in filenames: assert_in("Removing {}".format(os.path.join(path, fname)), cml.out) # Add to already existing links, skipping. assert_in_results( ds.addurls(self.json_file, "{url}", "{name}", ifexists="skip"), action="addurls", status="notneeded") # Add to already existing links works, as long content is the same. ds.addurls(self.json_file, "{url}", "{name}") # But it fails if something has changed. ds.unlock("a") with open("a", "w") as ofh: ofh.write("changed") ds.rev_save("a") assert_raises(IncompleteResultsError, ds.addurls, self.json_file, "{url}", "{name}")
def test_addurls_no_rows(self=None, path=None): ds = Dataset(path).create(force=True) for fname in ["in.csv", "in.tsv", "in.json"]: with swallow_logs(new_level=logging.WARNING) as cml: assert_in_results(ds.addurls(fname, "{url}", "{name}", result_renderer='disabled'), action="addurls", status="notneeded") cml.assert_logged("No rows", regex=False)
def test_dont_trip_over_missing_subds(path): ds1 = Dataset(opj(path, 'ds1')).create() ds2 = Dataset(opj(path, 'ds2')).create() subds2 = ds1.install(source=ds2.path, path='subds2', result_xfm='datasets', return_type='item-or-list') assert_true(subds2.is_installed()) assert_in('subds2', ds1.subdatasets(result_xfm='relpaths')) subds2.uninstall() assert_in('subds2', ds1.subdatasets(result_xfm='relpaths')) assert_false(subds2.is_installed()) # see if it wants to talk to github (and fail), or if it trips over something # before assert_raises(gh.BadCredentialsException, ds1.create_sibling_github, 'bogus', recursive=True, github_login='******') # inject remote config prior run assert_not_in('github', ds1.repo.get_remotes()) # fail on existing ds1.repo.add_remote('github', 'http://nothere') assert_raises(ValueError, ds1.create_sibling_github, 'bogus', recursive=True, github_login='******') # talk to github when existing is OK assert_raises(gh.BadCredentialsException, ds1.create_sibling_github, 'bogus', recursive=True, github_login='******', existing='reconfigure') # return happy emptiness when all is skipped assert_equal( ds1.create_sibling_github('bogus', recursive=True, github_login='******', existing='skip'), [])
def setUp(self): pt = Path.cwd() / 'ephy_testing_data' if pt.exists(): self.dataset = Dataset(pt) else: self.dataset = install( 'https://gin.g-node.org/NeuralEnsemble/ephy_testing_data') # Must pin to previous dataset version # See https://github.com/SpikeInterface/spikeextractors/pull/675 self.dataset.repo.call_git( ['checkout', '17e8f37674d70af84cdba6acd83df964a8e09f0c']) self.savedir = Path(tempfile.mkdtemp())
def test_get_metadata_with_README(path): ds = Dataset(path).create(force=True) meta = MetadataParser(ds, []).get_metadata(True, False)[0] del meta['@context'] dump = dumps(meta, sort_keys=True, indent=2, ensure_ascii=False) assert_equal( dump, u"""\ { "conformsto": "http://bids.neuroimaging.io", "description": "A very detailed\\ndescription с юникодом", "name": "test" }""")
def test_ensure_datalad_remote_maybe_enable(path=None, *, autoenable): path = Path(path) ds_a = Dataset(path / "a").create(force=True) init_datalad_remote(ds_a.repo, DATALAD_SPECIAL_REMOTE, autoenable=autoenable) ds_b = clone(source=ds_a.path, path=path / "b") repo = ds_b.repo if not autoenable: assert_not_in("datalad", repo.get_remotes()) ensure_datalad_remote(repo) assert_in("datalad", repo.get_remotes())
def get_sourcerepo(): srcrepopath = normpath(opj(dirname(datalad_neuroimaging.__file__), pardir)) srcrepo = Dataset(srcrepopath) if not srcrepo.is_installed(): srcrepo = install( source='https://github.com/datalad/datalad-neuroimaging.git', path=opj(appdirs.user_cache_dir, 'datalad_neuroimaging_srcrepo')) # this will eventually show us if we can properly upgrade submodules srcrepo.update(merge=True) # TODO we might want to try to check out a tag that corresponds to the # installed version return srcrepo
def test_ephemeral(ds_path=None, store_path=None, clone_path=None): dspath = Path(ds_path) store = Path(store_path) file_test = Path('file1.txt') file_testsub = Path('sub') / 'other.txt' # create the original dataset ds = Dataset(dspath) ds.create(force=True) ds.save() # put into store: ds.create_sibling_ria("ria+{}".format(store.as_uri()), "riastore", new_store_ok=True) ds.push(to="riastore", data="anything") # now, get an ephemeral clone from the RIA store: eph_clone = clone('ria+{}#{}'.format(store.as_uri(), ds.id), clone_path, reckless="ephemeral") # ephemeral clone was properly linked (store has bare repos!): clone_annex = (eph_clone.repo.dot_git / 'annex') assert_true(clone_annex.is_symlink()) assert_true(clone_annex.resolve().samefile(store / ds.id[:3] / ds.id[3:] / 'annex')) if not eph_clone.repo.is_managed_branch(): # TODO: We can't properly handle adjusted branch yet # we don't need to get files in order to access them: assert_equal((eph_clone.pathobj / file_test).read_text(), "some") assert_equal((eph_clone.pathobj / file_testsub).read_text(), "other") # can we unlock those files? eph_clone.unlock(file_test) # change content (eph_clone.pathobj / file_test).write_text("new content") eph_clone.save() # new content should already be in store # (except the store doesn't know yet) res = eph_clone.repo.fsck(remote="riastore-storage", fast=True) assert_equal(len(res), 2) assert_result_count(res, 1, success=True, file=file_test.as_posix()) assert_result_count(res, 1, success=True, file=file_testsub.as_posix()) # push back git history eph_clone.push(to=DEFAULT_REMOTE, data="nothing") # get an update in origin ds.update(merge=True, reobtain_data=True) assert_equal((ds.pathobj / file_test).read_text(), "new content")
def release( datasetter: DandiDatasetter, dandiset: str, version: str, commitish: Optional[str], push: bool, ) -> None: dandiset_obj = datasetter.dandi_client.get_dandiset(dandiset, version) dataset = Dataset(datasetter.target_path / dandiset) datasetter.mkrelease(dandiset_obj, dataset, commitish=commitish, push=push) if push: dataset.push(to="github", jobs=datasetter.config.jobs)
def test_dicom(path): ds = Dataset(path).create() ds.config.add('datalad.metadata.nativetype', 'dicom', where='dataset') copy( opj(dirname(dirname(dirname(__file__))), 'tests', 'data', 'dicom.dcm'), path) ds.add('.') ok_clean_git(ds.path) res = ds.aggregate_metadata() assert_status('ok', res) # query for the file metadata res = ds.metadata('dicom.dcm') assert_result_count(res, 1) # from this extractor meta = res[0]['metadata']['dicom'] assert_in('@context', meta) # no point in testing ALL keys, but we got plenty assert (len(meta.keys()) > 70) eq_(meta['SeriesDate'], '20070205') # now ask for the dataset metadata, which should have both the unique props # and a list of imageseries (one in this case, but a list) res = ds.metadata(reporton='datasets') assert_result_count(res, 1) dsmeta = res[0]['metadata']['dicom'] # same context assert_dict_equal(meta['@context'], dsmeta['@context']) meta.pop('@context') eq_(dsmeta['Series'], [meta]) # for this artificial case pretty much the same info also comes out as # unique props, but wrapped in lists ucp = res[0]['metadata']["datalad_unique_content_properties"]['dicom'] assert_dict_equal( { k: [v] for k, v in dsmeta['Series'][0].items() if k not in DicomExtractor._unique_exclude and k in ucp }, { k: v for k, v in ucp.items() if k not in DicomExtractor._unique_exclude }) # buuuut, if we switch of file-based metadata storage ds.config.add('datalad.metadata.aggregate-content-dicom', 'false', where='dataset') ds.aggregate_metadata() res = ds.metadata(reporton='datasets') # the auto-uniquified bits are gone but the Series description stays assert_not_in("datalad_unique_content_properties", res[0]['metadata']) eq_(dsmeta['Series'], [meta])
def setup(self): repo_path = tempfile.mkdtemp(**get_tempfile_kwargs(prefix="tree")) create_tree(repo_path, {'1.tar': { 'file.txt': 'load', '1.dat': 'load2' }}) self.ds = ds = Dataset(repo_path) ds.create(force=True) self.annex = ds.repo # Let's add first archive to the annex so we could test ds.save('1.tar', message="added 1.tar")
def test_dont_trip_over_missing_subds(path): ds1 = Dataset(opj(path, 'ds1')).create() ds2 = Dataset(opj(path, 'ds2')).create() subds2 = ds1.install(source=ds2.path, path='subds2') assert_true(subds2.is_installed()) assert_in('subds2', ds1.get_subdatasets()) subds2.uninstall(remove_handles=True, remove_history=True) assert_in('subds2', ds1.get_subdatasets()) assert_false(subds2.is_installed()) # this will deinit the submodule ds1.save(files=['subds2']) # see if it wants to talk to github (and fail), or if it trips over something # before assert_raises(gh.BadCredentialsException, ds1.create_sibling_github, 'bogus', recursive=True, github_user='') # inject remote config prior run assert_not_in('github', ds1.repo.get_remotes()) # fail on existing ds1.repo.add_remote('github', 'http://nothere') assert_raises(ValueError, ds1.create_sibling_github, 'bogus', recursive=True, github_user='') # talk to github when existing is OK assert_raises(gh.BadCredentialsException, ds1.create_sibling_github, 'bogus', recursive=True, github_user='', existing='reconfigure') # return happy emptiness when all is skipped assert_equal( ds1.create_sibling_github('bogus', recursive=True, github_user='', existing='skip'), [])
def test_container_files(ds_path, local_file, url): # setup things to add # # Note: Since "adding" as a container doesn't actually call anything or use # the container in some way, but simply registers it, for testing any file # is sufficient. local_file = get_local_file_url(op.join(local_file, 'some_container.img')) # prepare dataset: ds = Dataset(ds_path).create() # non-default location: ds.config.add("datalad.containers.location", value=op.join(".datalad", "test-environments"), where='dataset') ds.save(message="Configure container mountpoint") # no containers yet: res = ds.containers_list(**RAW_KWDS) assert_result_count(res, 0) # add first "image": must end up at the configured default location target_path = op.join(ds.path, ".datalad", "test-environments", "first", "image") res = ds.containers_add(name="first", url=local_file) ok_clean_git(ds.repo) assert_result_count(res, 1, status="ok", type="file", path=target_path, action="containers_add") ok_(op.lexists(target_path)) res = ds.containers_list(**RAW_KWDS) assert_result_count(res, 1) assert_result_count(res, 1, name='first', type='file', action='containers', status='ok', path=target_path) # and kill it again # but needs name assert_raises(TypeError, ds.containers_remove) res = ds.containers_remove('first', remove_image=True) assert_status('ok', res) assert_result_count(ds.containers_list(**RAW_KWDS), 0) # image removed assert (not op.lexists(target_path))
def test_addurls_metafail(self, path): ds = Dataset(path).create(force=True) # Force failure by passing a non-existent file name to annex. fn = ds.repo.set_metadata_ def set_meta(_, **kwargs): for i in fn("wreaking-havoc-and-such", **kwargs): yield i with patch.object(ds.repo, 'set_metadata_', set_meta): with assert_raises(IncompleteResultsError): ds.addurls(self.json_file, "{url}", "{name}")
def test_invalid_calls(path): ds = Dataset(path).create() # no argument: assert_raises(TypeError, ds.create_sibling_ria) # same name for git- and special remote: assert_raises(ValueError, ds.create_sibling_ria, 'ria+file:///some/where', name='some', ria_remote_name='some')