privatevoid.net/depot
1
1
Fork 0
Code Issues 21 Pull requests 4 Projects 3 Releases Packages Wiki Activity Actions
depot/patches/base/dvc/md5-to-sha256.patch

1893 lines
70 KiB
Diff
Raw Blame History

commit 31347d4f51e60c708cb7baf8cb3360c7cdbda2e2
Author: Max <max@privatevoid.net>
Date: Sat Dec 17 13:39:54 2022 +0100
md5 to sha256 for 2.17.0
diff --git a/dvc/api/data.py b/dvc/api/data.py
index a063612f..71fd715b 100644
--- a/dvc/api/data.py
+++ b/dvc/api/data.py
@@ -28,9 +28,9 @@ def get_url(path, repo=None, rev=None, remote=None):
raise OutputNotFoundError(path, repo)
dvc_repo = info["repo"]
- md5 = dvc_info["md5"]
+ sha256 = dvc_info["sha256"]
- return dvc_repo.cloud.get_url_for(remote, checksum=md5)
+ return dvc_repo.cloud.get_url_for(remote, checksum=sha256)
class _OpenContextManager(GCM):
diff --git a/dvc/fs/data.py b/dvc/fs/data.py
index c3612aed..dec0d386 100644
--- a/dvc/fs/data.py
+++ b/dvc/fs/data.py
@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
class DataFileSystem(FileSystem):
protocol = "local"
- PARAM_CHECKSUM = "md5"
+ PARAM_CHECKSUM = "sha256"
def _prepare_credentials(self, **config):
return config
diff --git a/dvc/fs/dvc.py b/dvc/fs/dvc.py
index 87a9ad50..fc997e9f 100644
--- a/dvc/fs/dvc.py
+++ b/dvc/fs/dvc.py
@@ -56,8 +56,8 @@ def _merge_info(repo, fs_info, dvc_info):
ret["dvc_info"] = dvc_info
ret["type"] = dvc_info["type"]
ret["size"] = dvc_info["size"]
- if not fs_info and "md5" in dvc_info:
- ret["md5"] = dvc_info["md5"]
+ if not fs_info and "sha256" in dvc_info:
+ ret["sha256"] = dvc_info["sha256"]
if fs_info:
ret["type"] = fs_info["type"]
@@ -443,7 +443,7 @@ class _DvcFileSystem(AbstractFileSystem): # pylint:disable=abstract-method
class DvcFileSystem(FileSystem):
protocol = "local"
- PARAM_CHECKSUM = "md5"
+ PARAM_CHECKSUM = "sha256"
def _prepare_credentials(self, **config):
return config
diff --git a/dvc/lock.py b/dvc/lock.py
index 3360001c..706a1f10 100644
--- a/dvc/lock.py
+++ b/dvc/lock.py
@@ -181,7 +181,7 @@ class HardlinkLock(flufl.lock.Lock, LockBase):
if self._tmp_dir is not None:
# Under Windows file path length is limited so we hash it
- filename = hashlib.md5(self._claimfile.encode()).hexdigest()
+ filename = hashlib.sha256(self._claimfile.encode()).hexdigest()
self._claimfile = os.path.join(self._tmp_dir, filename + ".lock")
diff --git a/dvc/output.py b/dvc/output.py
index fb7c0be5..f763468b 100644
--- a/dvc/output.py
+++ b/dvc/output.py
@@ -59,7 +59,7 @@ CASE_SENSITIVE_CHECKSUM_SCHEMA = Any(
# NOTE: currently there are only 3 possible checksum names:
#
-# 1) md5 (LOCAL, SSH);
+# 1) sha256 (LOCAL, SSH);
# 2) etag (S3, GS, OSS, AZURE, HTTP);
# 3) checksum (HDFS);
#
@@ -844,7 +844,7 @@ class Output:
odb,
from_info,
from_fs,
- "md5",
+ "sha256",
upload=upload,
no_progress_bar=no_progress_bar,
)
diff --git a/dvc/repo/__init__.py b/dvc/repo/__init__.py
index eb63e41b..b084cd74 100644
--- a/dvc/repo/__init__.py
+++ b/dvc/repo/__init__.py
@@ -117,7 +117,7 @@ class Repo:
def _get_database_dir(self, db_name):
# NOTE: by default, store SQLite-based remote indexes and state's
- # `links` and `md5s` caches in the repository itself to avoid any
+ # `links` and `sha256s` caches in the repository itself to avoid any
# possible state corruption in 'shared cache dir' scenario, but allow
# user to override this through config when, say, the repository is
# located on a mounted volume — see
@@ -513,7 +513,7 @@ class Repo:
try:
if remote:
remote_odb = self.cloud.get_remote_odb(name=remote)
- oid = fs.info(fs_path)["dvc_info"]["md5"]
+ oid = fs.info(fs_path)["dvc_info"]["sha256"]
fs = remote_odb.fs
fs_path = remote_odb.oid_to_path(oid)
diff --git a/dvc/repo/diff.py b/dvc/repo/diff.py
index 648a837e..f4264496 100644
--- a/dvc/repo/diff.py
+++ b/dvc/repo/diff.py
@@ -143,7 +143,7 @@ def _output_paths(repo, targets):
repo.odb.repo,
output.fs_path,
repo.odb.repo.fs,
- "md5",
+ "sha256",
dry_run=True,
ignore=output.dvcignore,
)
diff --git a/dvc/repo/imp_url.py b/dvc/repo/imp_url.py
index 35a684f6..ed6328f9 100644
--- a/dvc/repo/imp_url.py
+++ b/dvc/repo/imp_url.py
@@ -78,7 +78,7 @@ def imp_url(
remote_odb = self.cloud.get_remote_odb(remote, "import-url")
stage.outs[0].transfer(url, odb=remote_odb, jobs=jobs)
stage.save_deps()
- stage.md5 = stage.compute_md5()
+ stage.sha256 = stage.compute_sha256()
else:
stage.run(jobs=jobs)
diff --git a/dvc/repo/index.py b/dvc/repo/index.py
index 9e3fa1a0..a6919abd 100644
--- a/dvc/repo/index.py
+++ b/dvc/repo/index.py
@@ -13,7 +13,7 @@ from typing import (
from funcy import cached_property, nullcontext
-from dvc.utils import dict_md5
+from dvc.utils import dict_sha256
if TYPE_CHECKING:
from networkx import DiGraph
@@ -308,7 +308,7 @@ class Index:
Currently, it is unique to the platform (windows vs posix).
"""
- return dict_md5(self.dumpd())
+ return dict_sha256(self.dumpd())
if __name__ == "__main__":
diff --git a/dvc/stage/__init__.py b/dvc/stage/__init__.py
index 5f4f02f7..f763d4eb 100644
--- a/dvc/stage/__init__.py
+++ b/dvc/stage/__init__.py
@@ -28,7 +28,7 @@ from .utils import (
check_missing_outputs,
check_no_externals,
check_stage_path,
- compute_md5,
+ compute_sha256,
fill_stage_dependencies,
fill_stage_outputs,
get_dump,
@@ -133,7 +133,7 @@ class Stage(params.StageParams):
wdir=os.curdir,
deps=None,
outs=None,
- md5=None,
+ sha256=None,
locked=False, # backward compatibility
frozen=False,
always_changed=False,
@@ -153,7 +153,7 @@ class Stage(params.StageParams):
self.wdir = wdir
self.outs = outs
self.deps = deps
- self.md5 = md5
+ self.sha256 = sha256
self.frozen = locked or frozen
self.always_changed = always_changed
self._stage_text = stage_text
@@ -347,7 +347,7 @@ class Stage(params.StageParams):
return False
def changed_stage(self):
- changed = self.md5 != self.compute_md5()
+ changed = self.sha256 != self.compute_sha256()
if changed:
logger.debug(self._changed_stage_entry())
return changed
@@ -355,7 +355,7 @@ class Stage(params.StageParams):
@rwlocked(read=["deps", "outs"])
def changed(self):
is_changed = (
- # Short-circuit order: stage md5 is fast,
+ # Short-circuit order: stage sha256 is fast,
# deps are expected to change
self.changed_stage()
or self.changed_deps()
@@ -446,19 +446,19 @@ class Stage(params.StageParams):
def dumpd(self):
return get_dump(self)
- def compute_md5(self):
- # `dvc add`ed files don't need stage md5
+ def compute_sha256(self):
+ # `dvc add`ed files don't need stage sha256
if self.is_data_source and not (self.is_import or self.is_repo_import):
m = None
else:
- m = compute_md5(self)
- logger.debug("Computed %s md5: '%s'", self, m)
+ m = compute_sha256(self)
+ logger.debug("Computed %s sha256: '%s'", self, m)
return m
def save(self, allow_missing=False):
self.save_deps(allow_missing=allow_missing)
self.save_outs(allow_missing=allow_missing)
- self.md5 = self.compute_md5()
+ self.sha256 = self.compute_sha256()
self.repo.stage_cache.save(self)
@@ -491,7 +491,7 @@ class Stage(params.StageParams):
return [str(entry) for entry in entries if entry.workspace_status()]
def _changed_stage_entry(self):
- return f"'md5' of {self} changed."
+ return f"'sha256' of {self} changed."
def changed_entries(self):
changed_deps = self._changed_entries(self.deps)
diff --git a/dvc/stage/params.py b/dvc/stage/params.py
index c43a75b1..961a8168 100644
--- a/dvc/stage/params.py
+++ b/dvc/stage/params.py
@@ -1,5 +1,5 @@
class StageParams:
- PARAM_MD5 = "md5"
+ PARAM_MD5 = "sha256"
PARAM_CMD = "cmd"
PARAM_WDIR = "wdir"
PARAM_DEPS = "deps"
diff --git a/dvc/stage/utils.py b/dvc/stage/utils.py
index abd63020..f140d808 100644
--- a/dvc/stage/utils.py
+++ b/dvc/stage/utils.py
@@ -172,26 +172,26 @@ def check_missing_outputs(stage):
raise MissingDataSource(paths)
-def compute_md5(stage):
+def compute_sha256(stage):
from dvc.output import Output
- from ..utils import dict_md5
+ from ..utils import dict_sha256
d = stage.dumpd()
- # Remove md5 and meta, these should not affect stage md5
+ # Remove sha256 and meta, these should not affect stage sha256
d.pop(stage.PARAM_MD5, None)
d.pop(stage.PARAM_META, None)
d.pop(stage.PARAM_DESC, None)
# Ignore the wdir default value. In this case DVC file w/o
- # wdir has the same md5 as a file with the default value specified.
+ # wdir has the same sha256 as a file with the default value specified.
# It's important for backward compatibility with pipelines that
# didn't have WDIR in their DVC files.
if d.get(stage.PARAM_WDIR) == ".":
del d[stage.PARAM_WDIR]
- return dict_md5(
+ return dict_sha256(
d,
exclude=[
stage.PARAM_LOCKED, # backward compatibility
@@ -226,7 +226,7 @@ def get_dump(stage):
key: value
for key, value in {
stage.PARAM_DESC: stage.desc,
- stage.PARAM_MD5: stage.md5,
+ stage.PARAM_MD5: stage.sha256,
stage.PARAM_CMD: stage.cmd,
stage.PARAM_WDIR: resolve_wdir(stage.wdir, stage.path),
stage.PARAM_FROZEN: stage.frozen,
diff --git a/dvc/testing/test_workspace.py b/dvc/testing/test_workspace.py
index 0b883a7b..088e5795 100644
--- a/dvc/testing/test_workspace.py
+++ b/dvc/testing/test_workspace.py
@@ -12,14 +12,14 @@ class TestImport:
assert dvc.status() == {}
@pytest.fixture
- def stage_md5(self):
+ def stage_sha256(self):
pytest.skip()
@pytest.fixture
- def dir_md5(self):
+ def dir_sha256(self):
pytest.skip()
- def test_import_dir(self, tmp_dir, dvc, workspace, stage_md5, dir_md5):
+ def test_import_dir(self, tmp_dir, dvc, workspace, stage_sha256, dir_sha256):
from dvc.odbmgr import ODBManager
workspace.gen(
@@ -43,17 +43,17 @@ class TestImport:
assert dvc.status() == {}
- if stage_md5 is not None and dir_md5 is not None:
+ if stage_sha256 is not None and dir_sha256 is not None:
assert (tmp_dir / "dir.dvc").read_text() == (
- f"md5: {stage_md5}\n"
+ f"sha256: {stage_sha256}\n"
"frozen: true\n"
"deps:\n"
- f"- md5: {dir_md5}\n"
+ f"- sha256: {dir_sha256}\n"
" size: 11\n"
" nfiles: 2\n"
" path: remote://workspace/dir\n"
"outs:\n"
- "- md5: b6dcab6ccd17ca0a8bf4a215a37d14cc.dir\n"
+ "- sha256: b6dcab6ccd17ca0a8bf4a215a37d14cc.dir\n"
" size: 11\n"
" nfiles: 2\n"
" path: dir\n"
diff --git a/dvc/utils/__init__.py b/dvc/utils/__init__.py
index e9c1dfa1..b3ecf520 100644
--- a/dvc/utils/__init__.py
+++ b/dvc/utils/__init__.py
@@ -43,8 +43,8 @@ def dict_hash(d, typ, exclude=()):
return bytes_hash(byts, typ)
-def dict_md5(d, **kwargs):
- return dict_hash(d, "md5", **kwargs)
+def dict_sha256(d, **kwargs):
+ return dict_hash(d, "sha256", **kwargs)
def dict_sha256(d, **kwargs):
diff --git a/scripts/innosetup/dvc.ico.dvc b/scripts/innosetup/dvc.ico.dvc
index e8ca30f5..78b76603 100644
--- a/scripts/innosetup/dvc.ico.dvc
+++ b/scripts/innosetup/dvc.ico.dvc
@@ -1,3 +1,3 @@
outs:
-- md5: 90104d9e83cfb825cf45507e90aadd27
+- sha256: 90104d9e83cfb825cf45507e90aadd27
path: dvc.ico
diff --git a/scripts/innosetup/dvc_left.bmp.dvc b/scripts/innosetup/dvc_left.bmp.dvc
index be60334b..c97e16f8 100644
--- a/scripts/innosetup/dvc_left.bmp.dvc
+++ b/scripts/innosetup/dvc_left.bmp.dvc
@@ -1,3 +1,3 @@
outs:
-- md5: 9106cda08aa427e73492389a0f17c72d
+- sha256: 9106cda08aa427e73492389a0f17c72d
path: dvc_left.bmp
diff --git a/scripts/innosetup/dvc_up.bmp.dvc b/scripts/innosetup/dvc_up.bmp.dvc
index 7fb5ae55..59df4a87 100644
--- a/scripts/innosetup/dvc_up.bmp.dvc
+++ b/scripts/innosetup/dvc_up.bmp.dvc
@@ -1,3 +1,3 @@
outs:
-- md5: 94614d6650e062655f9f77507dc9c1f2
+- sha256: 94614d6650e062655f9f77507dc9c1f2
path: dvc_up.bmp
diff --git a/tests/func/test_add.py b/tests/func/test_add.py
index b096bbf5..b2c3fa23 100644
--- a/tests/func/test_add.py
+++ b/tests/func/test_add.py
@@ -37,7 +37,7 @@ from dvc.testing.test_workspace import TestAdd
from dvc.utils import LARGE_DIR_SIZE, relpath
from dvc.utils.fs import path_isin
from dvc.utils.serialize import YAMLFileCorruptedError, load_yaml
-from dvc_data.hashfile.hash import file_md5
+from dvc_data.hashfile.hash import file_sha256
from dvc_data.hashfile.hash_info import HashInfo
from tests.basic_env import TestDvc
from tests.utils import get_gitignore_content
@@ -45,7 +45,7 @@ from tests.utils import get_gitignore_content
def test_add(tmp_dir, dvc):
(stage,) = tmp_dir.dvc_gen({"foo": "foo"})
- md5 = file_md5("foo", dvc.fs)
+ sha256 = file_sha256("foo", dvc.fs)
assert stage is not None
@@ -54,13 +54,13 @@ def test_add(tmp_dir, dvc):
assert len(stage.outs) == 1
assert len(stage.deps) == 0
assert stage.cmd is None
- assert stage.outs[0].hash_info == HashInfo("md5", md5)
- assert stage.md5 is None
+ assert stage.outs[0].hash_info == HashInfo("sha256", sha256)
+ assert stage.sha256 is None
assert (tmp_dir / "foo.dvc").parse() == {
"outs": [
{
- "md5": "acbd18db4cc2f85cedef654fccc4a4d8",
+ "sha256": "acbd18db4cc2f85cedef654fccc4a4d8",
"path": "foo",
"size": 3,
}
@@ -78,7 +78,7 @@ def test_add_executable(tmp_dir, dvc):
assert (tmp_dir / "foo.dvc").parse() == {
"outs": [
{
- "md5": "acbd18db4cc2f85cedef654fccc4a4d8",
+ "sha256": "acbd18db4cc2f85cedef654fccc4a4d8",
"path": "foo",
"size": 3,
"isexec": True,
@@ -296,7 +296,7 @@ def test_add_filtered_files_in_dir(
class TestAddExternal(TestAdd):
@pytest.fixture
def hash_name(self):
- return "md5"
+ return "sha256"
@pytest.fixture
def hash_value(self):
@@ -317,7 +317,7 @@ def test_add_external_relpath(tmp_dir, dvc, local_cloud):
dvc.add(rel, external=True)
assert (tmp_dir / "file.dvc").read_text() == (
"outs:\n"
- "- md5: 8c7dd922ad47494fc02c388e12c00eac\n"
+ "- sha256: 8c7dd922ad47494fc02c388e12c00eac\n"
" size: 4\n"
f" path: {rel}\n"
)
@@ -379,7 +379,7 @@ class TestDoubleAddUnchanged(TestDvc):
def test_should_update_state_entry_for_file_after_add(mocker, dvc, tmp_dir):
- file_md5_counter = mocker.spy(dvc_data.hashfile.hash, "file_md5")
+ file_sha256_counter = mocker.spy(dvc_data.hashfile.hash, "file_sha256")
tmp_dir.gen("foo", "foo")
ret = main(["config", "cache.type", "copy"])
@@ -387,30 +387,30 @@ def test_should_update_state_entry_for_file_after_add(mocker, dvc, tmp_dir):
ret = main(["add", "foo"])
assert ret == 0
- assert file_md5_counter.mock.call_count == 1
+ assert file_sha256_counter.mock.call_count == 1
ret = main(["status"])
assert ret == 0
- assert file_md5_counter.mock.call_count == 1
+ assert file_sha256_counter.mock.call_count == 1
ret = main(["run", "--single-stage", "-d", "foo", "echo foo"])
assert ret == 0
- assert file_md5_counter.mock.call_count == 1
+ assert file_sha256_counter.mock.call_count == 1
os.rename("foo", "foo.back")
ret = main(["checkout"])
assert ret == 0
- assert file_md5_counter.mock.call_count == 1
+ assert file_sha256_counter.mock.call_count == 1
ret = main(["status"])
assert ret == 0
- assert file_md5_counter.mock.call_count == 1
+ assert file_sha256_counter.mock.call_count == 1
def test_should_update_state_entry_for_directory_after_add(
mocker, dvc, tmp_dir
):
- file_md5_counter = mocker.spy(dvc_data.hashfile.hash, "file_md5")
+ file_sha256_counter = mocker.spy(dvc_data.hashfile.hash, "file_sha256")
tmp_dir.gen({"data/data": "foo", "data/data_sub/sub_data": "foo"})
@@ -419,27 +419,27 @@ def test_should_update_state_entry_for_directory_after_add(
ret = main(["add", "data"])
assert ret == 0
- assert file_md5_counter.mock.call_count == 5
+ assert file_sha256_counter.mock.call_count == 5
ret = main(["status"])
assert ret == 0
- assert file_md5_counter.mock.call_count == 6
+ assert file_sha256_counter.mock.call_count == 6
ls = "dir" if os.name == "nt" else "ls"
ret = main(
["run", "--single-stage", "-d", "data", "{} {}".format(ls, "data")]
)
assert ret == 0
- assert file_md5_counter.mock.call_count == 8
+ assert file_sha256_counter.mock.call_count == 8
os.rename("data", "data" + ".back")
ret = main(["checkout"])
assert ret == 0
- assert file_md5_counter.mock.call_count == 8
+ assert file_sha256_counter.mock.call_count == 8
ret = main(["status"])
assert ret == 0
- assert file_md5_counter.mock.call_count == 10
+ assert file_sha256_counter.mock.call_count == 10
class TestAddCommit(TestDvc):
@@ -917,7 +917,7 @@ def test_add_preserve_fields(tmp_dir, dvc):
- path: foo # out comment
desc: out desc
remote: testremote
- md5: acbd18db4cc2f85cedef654fccc4a4d8
+ sha256: acbd18db4cc2f85cedef654fccc4a4d8
size: 3
meta: some metadata
"""
diff --git a/tests/func/test_checkout.py b/tests/func/test_checkout.py
index 44e636c1..69811c2e 100644
--- a/tests/func/test_checkout.py
+++ b/tests/func/test_checkout.py
@@ -991,7 +991,7 @@ def test_checkout_dir_compat(tmp_dir, dvc):
textwrap.dedent(
f"""\
outs:
- - md5: {stage.outs[0].hash_info.value}
+ - sha256: {stage.outs[0].hash_info.value}
path: data
"""
),
diff --git a/tests/func/test_commit.py b/tests/func/test_commit.py
index b1b40ce4..0a067d58 100644
--- a/tests/func/test_commit.py
+++ b/tests/func/test_commit.py
@@ -62,7 +62,7 @@ def test_commit_preserve_fields(tmp_dir, dvc):
- path: foo # out comment
desc: out desc
remote: testremote
- md5: acbd18db4cc2f85cedef654fccc4a4d8
+ sha256: acbd18db4cc2f85cedef654fccc4a4d8
size: 3
meta: some metadata
"""
@@ -88,19 +88,19 @@ def test_commit_with_deps(tmp_dir, dvc, run_copy, run_kw):
assert not stage.outs[0].changed_cache()
-def test_commit_changed_md5(tmp_dir, dvc):
+def test_commit_changed_sha256(tmp_dir, dvc):
tmp_dir.gen({"file": "file content"})
(stage,) = dvc.add("file", no_commit=True)
stage_file_content = (tmp_dir / stage.path).parse()
- stage_file_content["md5"] = "1111111111"
+ stage_file_content["sha256"] = "1111111111"
(tmp_dir / stage.path).dump(stage_file_content)
with pytest.raises(StageCommitError):
dvc.commit(stage.path)
dvc.commit(stage.path, force=True)
- assert "md5" not in (tmp_dir / stage.path).parse()
+ assert "sha256" not in (tmp_dir / stage.path).parse()
def test_commit_no_exec(tmp_dir, dvc):
diff --git a/tests/func/test_data_cloud.py b/tests/func/test_data_cloud.py
index 192e350f..012e6921 100644
--- a/tests/func/test_data_cloud.py
+++ b/tests/func/test_data_cloud.py
@@ -131,7 +131,7 @@ def test_warn_on_outdated_stage(tmp_dir, dvc, local_remote, caplog):
stage_file_path = stage.relpath
content = (tmp_dir / stage_file_path).parse()
- del content["outs"][0]["md5"]
+ del content["outs"][0]["sha256"]
(tmp_dir / stage_file_path).dump(content)
with caplog.at_level(logging.WARNING, logger="dvc"):
@@ -148,7 +148,7 @@ def test_warn_on_outdated_stage(tmp_dir, dvc, local_remote, caplog):
def test_hash_recalculation(mocker, dvc, tmp_dir, local_remote):
tmp_dir.gen({"foo": "foo"})
- test_file_md5 = mocker.spy(dvc_data.hashfile.hash, "file_md5")
+ test_file_sha256 = mocker.spy(dvc_data.hashfile.hash, "file_sha256")
ret = main(["config", "cache.type", "hardlink"])
assert ret == 0
ret = main(["add", "foo"])
@@ -157,7 +157,7 @@ def test_hash_recalculation(mocker, dvc, tmp_dir, local_remote):
assert ret == 0
ret = main(["run", "--single-stage", "-d", "foo", "echo foo"])
assert ret == 0
- assert test_file_md5.mock.call_count == 1
+ assert test_file_sha256.mock.call_count == 1
def test_missing_cache(tmp_dir, dvc, local_remote, caplog):
@@ -170,8 +170,8 @@ def test_missing_cache(tmp_dir, dvc, local_remote, caplog):
"Some of the cache files do not exist "
"neither locally nor on remote. Missing cache files:\n"
)
- foo = "name: bar, md5: 37b51d194a7513e45b56f6524f2d51f2\n"
- bar = "name: foo, md5: acbd18db4cc2f85cedef654fccc4a4d8\n"
+ foo = "name: bar, sha256: 37b51d194a7513e45b56f6524f2d51f2\n"
+ bar = "name: foo, sha256: acbd18db4cc2f85cedef654fccc4a4d8\n"
caplog.clear()
dvc.push()
@@ -207,7 +207,7 @@ def test_verify_hashes(
remove("dir")
remove(dvc.odb.local.path)
- hash_spy = mocker.spy(dvc_data.hashfile.hash, "file_md5")
+ hash_spy = mocker.spy(dvc_data.hashfile.hash, "file_sha256")
dvc.pull()
assert hash_spy.call_count == 0
diff --git a/tests/func/test_diff.py b/tests/func/test_diff.py
index 5b93815f..7de8e775 100644
--- a/tests/func/test_diff.py
+++ b/tests/func/test_diff.py
@@ -9,7 +9,7 @@ from dvc.utils.fs import remove
def digest(text):
- return hashlib.md5(bytes(text, "utf-8")).hexdigest()
+ return hashlib.sha256(bytes(text, "utf-8")).hexdigest()
def test_no_scm(tmp_dir, dvc):
diff --git a/tests/func/test_external_repo.py b/tests/func/test_external_repo.py
index 0f034f88..c1a76b3f 100644
--- a/tests/func/test_external_repo.py
+++ b/tests/func/test_external_repo.py
@@ -206,7 +206,7 @@ def test_subrepos_are_ignored(tmp_dir, erepo_dir):
repo.odb.local,
"dir",
repo.dvcfs,
- "md5",
+ "sha256",
ignore=repo.dvcignore,
)
transfer(
diff --git a/tests/func/test_gc.py b/tests/func/test_gc.py
index 27a2e9f6..40b0a357 100644
--- a/tests/func/test_gc.py
+++ b/tests/func/test_gc.py
@@ -24,9 +24,9 @@ class TestGC(TestDvcGit):
raw_dir_hash = stages[0].outs[0].hash_info.as_raw().value
self.good_cache = [
- self.dvc.odb.local.oid_to_path(md5)
- for md5 in self.dvc.odb.local.all()
- if md5 != raw_dir_hash
+ self.dvc.odb.local.oid_to_path(sha256)
+ for sha256 in self.dvc.odb.local.all()
+ if sha256 != raw_dir_hash
]
self.bad_cache = [self.dvc.odb.local.oid_to_path(raw_dir_hash)]
diff --git a/tests/func/test_import_url.py b/tests/func/test_import_url.py
index 33e79e40..78550df5 100644
--- a/tests/func/test_import_url.py
+++ b/tests/func/test_import_url.py
@@ -120,11 +120,11 @@ def test_import_url_with_no_exec(tmp_dir, dvc, erepo_dir):
class TestImport(_TestImport):
@pytest.fixture
- def stage_md5(self):
+ def stage_sha256(self):
return "dc24e1271084ee317ac3c2656fb8812b"
@pytest.fixture
- def dir_md5(self):
+ def dir_sha256(self):
return "b6dcab6ccd17ca0a8bf4a215a37d14cc.dir"
@pytest.fixture
@@ -155,15 +155,15 @@ def test_import_url_preserve_meta(tmp_dir, dvc):
desc: top desc
deps:
- path: foo # dep comment
- md5: acbd18db4cc2f85cedef654fccc4a4d8
+ sha256: acbd18db4cc2f85cedef654fccc4a4d8
size: 3
outs:
- path: bar # out comment
desc: out desc
- md5: acbd18db4cc2f85cedef654fccc4a4d8
+ sha256: acbd18db4cc2f85cedef654fccc4a4d8
size: 3
meta: some metadata
- md5: be7ade0aa89cc8d56e320867a9de9740
+ sha256: be7ade0aa89cc8d56e320867a9de9740
frozen: true
"""
)
@@ -229,7 +229,7 @@ def test_import_url_to_remote_directory(tmp_dir, dvc, workspace, local_remote):
for file_part in file_parts:
with open(
- local_remote.oid_to_path(file_part["md5"]), encoding="utf-8"
+ local_remote.oid_to_path(file_part["sha256"]), encoding="utf-8"
) as fobj:
assert fobj.read() == file_part["relpath"]
@@ -258,7 +258,7 @@ def test_import_url_to_remote_status(tmp_dir, dvc, local_cloud, local_remote):
local_cloud.gen("foo", "foo")
stage = dvc.imp_url(str(local_cloud / "foo"), to_remote=True)
- assert stage.md5 is not None
+ assert stage.sha256 is not None
status = dvc.status()
assert status["foo.dvc"] == [{"changed outs": {"foo": "not in cache"}}]
diff --git a/tests/func/test_install.py b/tests/func/test_install.py
index a4a800c9..fb5ddbfe 100644
--- a/tests/func/test_install.py
+++ b/tests/func/test_install.py
@@ -6,7 +6,7 @@ import pytest
from git import GitCommandError
from dvc.exceptions import DvcException
-from dvc_data.hashfile.hash import file_md5
+from dvc_data.hashfile.hash import file_sha256
from tests.func.parsing.test_errors import escape_ansi
@@ -76,7 +76,7 @@ class TestInstall:
conf["core"]["remote"] = "store"
tmp_dir.dvc_gen("file", "file_content", "commit message")
- file_checksum = file_md5("file", dvc.fs)
+ file_checksum = file_sha256("file", dvc.fs)
expected_storage_path = (
storage_path / file_checksum[:2] / file_checksum[2:]
)
@@ -117,7 +117,7 @@ def test_merge_driver_no_ancestor(tmp_dir, scm, dvc):
assert (tmp_dir / "data").read_text() == {"bar": "bar"}
assert (tmp_dir / "data.dvc").read_text() == (
"outs:\n"
- "- md5: 5ea40360f5b4ec688df672a4db9c17d1.dir\n"
+ "- sha256: 5ea40360f5b4ec688df672a4db9c17d1.dir\n"
" size: 6\n"
" nfiles: 2\n"
" path: data\n"
@@ -154,7 +154,7 @@ def test_merge_driver(tmp_dir, scm, dvc):
assert (tmp_dir / "data").read_text() == {"master": "master", "two": "two"}
assert (tmp_dir / "data.dvc").read_text() == (
"outs:\n"
- "- md5: 839ef9371606817569c1ee0e5f4ed233.dir\n"
+ "- sha256: 839ef9371606817569c1ee0e5f4ed233.dir\n"
" size: 12\n"
" nfiles: 3\n"
" path: data\n"
diff --git a/tests/func/test_lockfile.py b/tests/func/test_lockfile.py
index 93974978..3fb2f1a1 100644
--- a/tests/func/test_lockfile.py
+++ b/tests/func/test_lockfile.py
@@ -48,12 +48,12 @@ def test_deps_outs_are_sorted_by_path(tmp_dir, dvc, run_head):
# lock stage key order:
assert list(lock.keys()) == ["cmd", "deps", "outs"]
- # `path` key appear first and then the `md5`
+ # `path` key appear first and then the `sha256`
assert all(
- list(dep.keys()) == ["path", "md5", "size"] for dep in lock["deps"]
+ list(dep.keys()) == ["path", "sha256", "size"] for dep in lock["deps"]
)
assert all(
- list(out.keys()) == ["path", "md5", "size"] for out in lock["outs"]
+ list(out.keys()) == ["path", "sha256", "size"] for out in lock["outs"]
)
# deps are always sorted by the file path naming
@@ -167,7 +167,7 @@ def test_params_dump(tmp_dir, dvc, run_head):
def v1_repo_lock(tmp_dir, dvc):
"""Generates a repo having v1 format lockfile"""
size = 5 if os.name == "nt" else 4
- hi = HashInfo(name="md5", value="c157a79031e1c40f85931829bc5fc552")
+ hi = HashInfo(name="sha256", value="c157a79031e1c40f85931829bc5fc552")
v1_lockdata = {
"foo": {"cmd": "echo foo"},
"bar": {
diff --git a/tests/func/test_merge_driver.py b/tests/func/test_merge_driver.py
index 113984f9..218e524a 100644
--- a/tests/func/test_merge_driver.py
+++ b/tests/func/test_merge_driver.py
@@ -118,11 +118,11 @@ def test_merge_different_output_options(tmp_dir, dvc, caplog):
(tmp_dir / "ancestor").touch()
(tmp_dir / "our").write_text(
- "outs:\n- md5: f123456789.dir\n path: path\n"
+ "outs:\n- sha256: f123456789.dir\n path: path\n"
)
(tmp_dir / "their").write_text(
- "outs:\n- md5: f987654321.dir\n path: path\n cache: false\n"
+ "outs:\n- sha256: f987654321.dir\n path: path\n cache: false\n"
)
assert (
@@ -149,10 +149,10 @@ def test_merge_file(tmp_dir, dvc, caplog):
(tmp_dir / "ancestor").touch()
(tmp_dir / "our").write_text(
- "outs:\n- md5: f123456789.dir\n path: path\n"
+ "outs:\n- sha256: f123456789.dir\n path: path\n"
)
- (tmp_dir / "their").write_text("outs:\n- md5: f987654321\n path: path\n")
+ (tmp_dir / "their").write_text("outs:\n- sha256: f987654321\n path: path\n")
assert (
main(
@@ -179,13 +179,13 @@ def test_merge_non_dvc_add(tmp_dir, dvc, caplog):
(tmp_dir / "our").write_text(
"outs:\n"
- "- md5: f123456789.dir\n"
+ "- sha256: f123456789.dir\n"
" path: path\n"
- "- md5: ff123456789.dir\n"
+ "- sha256: ff123456789.dir\n"
" path: another\n"
)
- (tmp_dir / "their").write_text("outs:\n- md5: f987654321\n path: path\n")
+ (tmp_dir / "their").write_text("outs:\n- sha256: f987654321\n path: path\n")
assert (
main(
diff --git a/tests/func/test_move.py b/tests/func/test_move.py
index aad2003a..3e28e628 100644
--- a/tests/func/test_move.py
+++ b/tests/func/test_move.py
@@ -261,7 +261,7 @@ def test_move_meta(tmp_dir, dvc):
assert res == textwrap.dedent(
"""\
outs:
- - md5: acbd18db4cc2f85cedef654fccc4a4d8
+ - sha256: acbd18db4cc2f85cedef654fccc4a4d8
size: 3
path: bar
meta:
diff --git a/tests/func/test_odb.py b/tests/func/test_odb.py
index c2ded255..501814de 100644
--- a/tests/func/test_odb.py
+++ b/tests/func/test_odb.py
@@ -12,17 +12,17 @@ from dvc_objects.errors import ObjectFormatError
def test_cache(tmp_dir, dvc):
- cache1_md5 = "123"
- cache2_md5 = "234"
+ cache1_sha256 = "123"
+ cache2_sha256 = "234"
cache1 = os.path.join(
dvc.odb.local.path,
- cache1_md5[0:2],
- cache1_md5[2:],
+ cache1_sha256[0:2],
+ cache1_sha256[2:],
)
cache2 = os.path.join(
dvc.odb.local.path,
- cache2_md5[0:2],
- cache2_md5[2:],
+ cache2_sha256[0:2],
+ cache2_sha256[2:],
)
tmp_dir.gen({cache1: "1", cache2: "2"})
@@ -31,13 +31,13 @@ def test_cache(tmp_dir, dvc):
odb = ODBManager(dvc)
- md5_list = list(odb.local.all())
- assert len(md5_list) == 2
- assert cache1_md5 in md5_list
- assert cache2_md5 in md5_list
+ sha256_list = list(odb.local.all())
+ assert len(sha256_list) == 2
+ assert cache1_sha256 in sha256_list
+ assert cache2_sha256 in sha256_list
- odb_cache1 = odb.local.oid_to_path(cache1_md5)
- odb_cache2 = odb.local.oid_to_path(cache2_md5)
+ odb_cache1 = odb.local.oid_to_path(cache1_sha256)
+ odb_cache2 = odb.local.oid_to_path(cache2_sha256)
assert os.fspath(odb_cache1) == cache1
assert os.fspath(odb_cache2) == cache2
@@ -49,13 +49,13 @@ def test_cache_load_bad_dir_cache(tmp_dir, dvc):
fname = os.fspath(dvc.odb.local.oid_to_path(dir_hash))
tmp_dir.gen({fname: "<clearly>not,json"})
with pytest.raises(ObjectFormatError):
- load(dvc.odb.local, HashInfo("md5", dir_hash))
+ load(dvc.odb.local, HashInfo("sha256", dir_hash))
dir_hash = "234.dir"
fname = os.fspath(dvc.odb.local.oid_to_path(dir_hash))
tmp_dir.gen({fname: '{"a": "b"}'})
with pytest.raises(ObjectFormatError):
- load(dvc.odb.local, HashInfo("md5", dir_hash))
+ load(dvc.odb.local, HashInfo("sha256", dir_hash))
def test_external_cache_dir(tmp_dir, dvc, make_tmp_dir):
diff --git a/tests/func/test_remote.py b/tests/func/test_remote.py
index aac08ce7..6164cfa8 100644
--- a/tests/func/test_remote.py
+++ b/tests/func/test_remote.py
@@ -147,22 +147,22 @@ def test_dir_hash_should_be_key_order_agnostic(tmp_dir, dvc):
path = (tmp_dir / "data").fs_path
tree = Tree.from_list(
- [{"relpath": "1", "md5": "1"}, {"relpath": "2", "md5": "2"}]
+ [{"relpath": "1", "sha256": "1"}, {"relpath": "2", "sha256": "2"}]
)
tree.digest()
with patch("dvc_data.build._build_tree", return_value=(None, tree)):
- _, _, obj = build(dvc.odb.local, path, dvc.odb.local.fs, "md5")
+ _, _, obj = build(dvc.odb.local, path, dvc.odb.local.fs, "sha256")
hash1 = obj.hash_info
# remove the raw dir obj to force building the tree on the next build call
dvc.odb.local.fs.remove(dvc.odb.local.oid_to_path(hash1.as_raw().value))
tree = Tree.from_list(
- [{"md5": "1", "relpath": "1"}, {"md5": "2", "relpath": "2"}]
+ [{"sha256": "1", "relpath": "1"}, {"sha256": "2", "relpath": "2"}]
)
tree.digest()
with patch("dvc_data.build._build_tree", return_value=(None, tree)):
- _, _, obj = build(dvc.odb.local, path, dvc.odb.local.fs, "md5")
+ _, _, obj = build(dvc.odb.local, path, dvc.odb.local.fs, "sha256")
hash2 = obj.hash_info
assert hash1 == hash2
@@ -248,7 +248,7 @@ def test_remote_modify_local_on_repo_config(tmp_dir, dvc):
def test_external_dir_resource_on_no_cache(tmp_dir, dvc, tmp_path_factory):
# https://github.com/iterative/dvc/issues/2647, is some situations
- # (external dir dependency) cache is required to calculate dir md5
+ # (external dir dependency) cache is required to calculate dir sha256
external_dir = tmp_path_factory.mktemp("external_dir")
file = external_dir / "file"
diff --git a/tests/func/test_repo_index.py b/tests/func/test_repo_index.py
index c419d88f..dfaee778 100644
--- a/tests/func/test_repo_index.py
+++ b/tests/func/test_repo_index.py
@@ -269,17 +269,17 @@ def test_used_objs(tmp_dir, scm, dvc, run_copy, rev):
expected_objs = [
HashInfo(
- name="md5",
+ name="sha256",
value="acbd18db4cc2f85cedef654fccc4a4d8",
obj_name="bar",
),
HashInfo(
- name="md5",
+ name="sha256",
value="8c7dd922ad47494fc02c388e12c00eac",
obj_name="dir/subdir/file",
),
HashInfo(
- name="md5",
+ name="sha256",
value="d28c9e28591aeb7e303dc6772ffa6f6b.dir",
obj_name="dir",
),
diff --git a/tests/func/test_repro.py b/tests/func/test_repro.py
index ed405866..8060585c 100644
--- a/tests/func/test_repro.py
+++ b/tests/func/test_repro.py
@@ -21,7 +21,7 @@ from dvc.stage.exceptions import StageFileDoesNotExistError
from dvc.utils import relpath
from dvc.utils.fs import remove
from dvc.utils.serialize import dump_yaml, load_yaml
-from dvc_data.hashfile.hash import file_md5
+from dvc_data.hashfile.hash import file_sha256
from tests.basic_env import TestDvc
@@ -654,7 +654,7 @@ class TestReproDataSource(TestReproChangedData):
self.assertTrue(filecmp.cmp(self.FOO, self.BAR, shallow=False))
self.assertEqual(
- stages[0].outs[0].hash_info.value, file_md5(self.BAR, self.dvc.fs)
+ stages[0].outs[0].hash_info.value, file_sha256(self.BAR, self.dvc.fs)
)
@@ -1127,21 +1127,21 @@ def test_dvc_formatting_retained(tmp_dir, dvc, run_copy):
(tmp_dir / "foo").write_text("new foo")
dvc.reproduce("foo_copy.dvc", force=True)
- def _hide_md5(text):
- return re.sub(r"\b[a-f0-9]{32}\b", "<md5>", text)
+ def _hide_sha256(text):
+ return re.sub(r"\b[a-f0-9]{32}\b", "<sha256>", text)
def _hide_size(text):
return re.sub(r"size: [0-9]*\b", "size: <size>", text)
def _mask(text):
- return _hide_size(_hide_md5(text))
+ return _hide_size(_hide_sha256(text))
assert _mask(stage_text) == _mask(stage_path.read_text())
def _format_dvc_line(line):
- # Add line comment for all cache and md5 keys
- if "cache:" in line or "md5:" in line:
+ # Add line comment for all cache and sha256 keys
+ if "cache:" in line or "sha256:" in line:
return line + " # line comment"
# Format command as one word per line
if line.startswith("cmd: "):
diff --git a/tests/func/test_run_multistage.py b/tests/func/test_run_multistage.py
index f83b7e18..569a86de 100644
--- a/tests/func/test_run_multistage.py
+++ b/tests/func/test_run_multistage.py
@@ -355,7 +355,7 @@ def test_run_external_outputs(
dvc,
local_workspace,
):
- hash_name = "md5"
+ hash_name = "sha256"
foo_hash = "acbd18db4cc2f85cedef654fccc4a4d8"
bar_hash = "37b51d194a7513e45b56f6524f2d51f2"
diff --git a/tests/func/test_run_single_stage.py b/tests/func/test_run_single_stage.py
index db775d05..0b193b42 100644
--- a/tests/func/test_run_single_stage.py
+++ b/tests/func/test_run_single_stage.py
@@ -31,7 +31,7 @@ from dvc.stage.exceptions import (
StagePathOutsideError,
)
from dvc.utils.serialize import load_yaml
-from dvc_data.hashfile.hash import file_md5
+from dvc_data.hashfile.hash import file_sha256
from tests.basic_env import TestDvc, TestDvcGit
@@ -60,7 +60,7 @@ class TestRun(TestDvc):
self.assertEqual(len(stage.outs), len(outs + outs_no_cache))
self.assertEqual(stage.outs[0].fspath, outs[0])
self.assertEqual(
- stage.outs[0].hash_info.value, file_md5(self.FOO, self.dvc.fs)
+ stage.outs[0].hash_info.value, file_sha256(self.FOO, self.dvc.fs)
)
self.assertTrue(stage.path, fname)
@@ -987,20 +987,20 @@ def test_run_force_preserves_comments_and_meta(tmp_dir, dvc, run_copy):
cmd: python copy.py foo bar
deps:
- path: copy.py
- md5: 90c27dd80b698fe766f0c3ee0b6b9729
+ sha256: 90c27dd80b698fe766f0c3ee0b6b9729
size: {code_size}
- path: foo
- md5: acbd18db4cc2f85cedef654fccc4a4d8
+ sha256: acbd18db4cc2f85cedef654fccc4a4d8
size: 3
outs:
# comment preserved
- path: bar
desc: out desc
- md5: acbd18db4cc2f85cedef654fccc4a4d8
+ sha256: acbd18db4cc2f85cedef654fccc4a4d8
size: 3
meta:
name: copy-foo-bar
- md5: be659ce4a33cebb85d4e8e1335d394ad
+ sha256: be659ce4a33cebb85d4e8e1335d394ad
"""
)
@@ -1011,18 +1011,18 @@ def test_run_force_preserves_comments_and_meta(tmp_dir, dvc, run_copy):
cmd: python copy.py foo1 bar1
deps:
- path: foo1
- md5: 299a0be4a5a79e6a59fdd251b19d78bb
+ sha256: 299a0be4a5a79e6a59fdd251b19d78bb
size: 4
- path: copy.py
- md5: 90c27dd80b698fe766f0c3ee0b6b9729
+ sha256: 90c27dd80b698fe766f0c3ee0b6b9729
size: {code_size}
outs:
# comment preserved
- path: bar1
- md5: 299a0be4a5a79e6a59fdd251b19d78bb
+ sha256: 299a0be4a5a79e6a59fdd251b19d78bb
size: 4
meta:
name: copy-foo-bar
- md5: 9e725b11cb393e6a7468369fa50328b7
+ sha256: 9e725b11cb393e6a7468369fa50328b7
"""
)
diff --git a/tests/func/test_stage.py b/tests/func/test_stage.py
index 77a35488..46ff6a02 100644
--- a/tests/func/test_stage.py
+++ b/tests/func/test_stage.py
@@ -78,8 +78,8 @@ class TestReload(TestDvc):
d = load_yaml(stage.relpath)
# NOTE: checking that reloaded stage didn't change its checksum
- md5 = "11111111111111111111111111111111"
- d[stage.PARAM_MD5] = md5
+ sha256 = "11111111111111111111111111111111"
+ d[stage.PARAM_MD5] = sha256
dump_yaml(stage.relpath, d)
dvcfile = SingleStageFile(self.dvc, stage.relpath)
@@ -89,7 +89,7 @@ class TestReload(TestDvc):
dvcfile.dump(stage)
d = load_yaml(stage.relpath)
- self.assertEqual(d[stage.PARAM_MD5], md5)
+ self.assertEqual(d[stage.PARAM_MD5], sha256)
class TestDefaultWorkingDirectory(TestDvc):
@@ -154,7 +154,7 @@ class TestExternalRemoteResolution(TestDvc):
assert os.path.exists("movie.txt")
-def test_md5_ignores_comments(tmp_dir, dvc):
+def test_sha256_ignores_comments(tmp_dir, dvc):
(stage,) = tmp_dir.dvc_gen("foo", "foo content")
with open(stage.path, "a", encoding="utf-8") as f:
diff --git a/tests/func/test_state.py b/tests/func/test_state.py
index 1e4f6ae6..4fa328d6 100644
--- a/tests/func/test_state.py
+++ b/tests/func/test_state.py
@@ -2,7 +2,7 @@ import os
import re
from dvc.repo import Repo
-from dvc_data.hashfile.hash import file_md5
+from dvc_data.hashfile.hash import file_sha256
from dvc_data.hashfile.hash_info import HashInfo
from dvc_data.hashfile.state import State
@@ -10,7 +10,7 @@ from dvc_data.hashfile.state import State
def test_state(tmp_dir, dvc):
tmp_dir.gen("foo", "foo content")
path = tmp_dir / "foo"
- hash_info = HashInfo("md5", file_md5(path, dvc.fs))
+ hash_info = HashInfo("sha256", file_sha256(path, dvc.fs))
state = State(dvc.root_dir, dvc.tmp_dir, dvc.dvcignore)
@@ -22,7 +22,7 @@ def test_state(tmp_dir, dvc):
assert state.get(path, dvc.fs) == (None, None)
- hash_info = HashInfo("md5", file_md5(path, dvc.fs))
+ hash_info = HashInfo("sha256", file_sha256(path, dvc.fs))
state.save(path, dvc.fs, hash_info)
assert state.get(path, dvc.fs)[1] == hash_info
diff --git a/tests/func/test_utils.py b/tests/func/test_utils.py
index 0a1834ef..f9bf8d3a 100644
--- a/tests/func/test_utils.py
+++ b/tests/func/test_utils.py
@@ -6,7 +6,7 @@ from dvc import utils
from dvc.exceptions import DvcException
-def test_dict_md5():
+def test_dict_sha256():
d = {
"cmd": "python code.py foo file1",
"locked": "true",
@@ -15,18 +15,18 @@ def test_dict_md5():
"path": "file1",
"metric": {"type": "raw"},
"cache": False,
- "md5": "acbd18db4cc2f85cedef654fccc4a4d8",
+ "sha256": "acbd18db4cc2f85cedef654fccc4a4d8",
}
],
"deps": [
- {"path": "foo", "md5": "acbd18db4cc2f85cedef654fccc4a4d8"},
- {"path": "code.py", "md5": "d05447644b89960913c7eee5fd776adb"},
+ {"path": "foo", "sha256": "acbd18db4cc2f85cedef654fccc4a4d8"},
+ {"path": "code.py", "sha256": "d05447644b89960913c7eee5fd776adb"},
],
}
- md5 = "8b263fa05ede6c3145c164829be694b4"
+ sha256 = "8b263fa05ede6c3145c164829be694b4"
- assert md5 == utils.dict_md5(d, exclude=["metric", "locked"])
+ assert sha256 == utils.dict_sha256(d, exclude=["metric", "locked"])
def test_boxify():
diff --git a/tests/unit/cli/test_main.py b/tests/unit/cli/test_main.py
index 73cf3bf7..a83056d6 100644
--- a/tests/unit/cli/test_main.py
+++ b/tests/unit/cli/test_main.py
@@ -14,7 +14,7 @@ def test_state_pickle_errors_are_correctly_raised(tmp_dir, caplog, mocker):
mocker.patch(
"dvc.cli.parse_args",
return_value=Namespace(
- func=raiser(DiskError(path, "md5s")),
+ func=raiser(DiskError(path, "sha256s")),
quiet=False,
verbose=True,
),
@@ -22,7 +22,7 @@ def test_state_pickle_errors_are_correctly_raised(tmp_dir, caplog, mocker):
assert main() == 255
assert (
- f"Could not open pickled 'md5s' cache.\n"
+ f"Could not open pickled 'sha256s' cache.\n"
f"Remove the '{path.relative_to(tmp_dir)}' directory "
"and then retry this command.\n"
"See <https://error.dvc.org/pickle> for more information."
diff --git a/tests/unit/data/db/test_local.py b/tests/unit/data/db/test_local.py
index b755cf64..0175f179 100644
--- a/tests/unit/data/db/test_local.py
+++ b/tests/unit/data/db/test_local.py
@@ -17,8 +17,8 @@ def test_status_download_optimization(mocker, dvc):
odb = LocalHashFileDB(LocalFileSystem(), os.getcwd())
obj_ids = {
- HashInfo("md5", "acbd18db4cc2f85cedef654fccc4a4d8"),
- HashInfo("md5", "37b51d194a7513e45b56f6524f2d51f2"),
+ HashInfo("sha256", "acbd18db4cc2f85cedef654fccc4a4d8"),
+ HashInfo("sha256", "37b51d194a7513e45b56f6524f2d51f2"),
}
local_exists = [hash_info.value for hash_info in obj_ids]
@@ -94,7 +94,7 @@ def test_staging_file(tmp_dir, dvc):
local_odb = dvc.odb.local
staging_odb, _, obj = build(
- local_odb, (tmp_dir / "foo").fs_path, fs, "md5"
+ local_odb, (tmp_dir / "foo").fs_path, fs, "sha256"
)
assert not local_odb.exists(obj.hash_info.value)
@@ -122,7 +122,7 @@ def test_staging_dir(tmp_dir, dvc):
local_odb = dvc.odb.local
staging_odb, _, obj = build(
- local_odb, (tmp_dir / "dir").fs_path, fs, "md5"
+ local_odb, (tmp_dir / "dir").fs_path, fs, "sha256"
)
assert not local_odb.exists(obj.hash_info.value)
diff --git a/tests/unit/fs/test_data.py b/tests/unit/fs/test_data.py
index 0b838d1e..ad17ebd0 100644
--- a/tests/unit/fs/test_data.py
+++ b/tests/unit/fs/test_data.py
@@ -222,7 +222,7 @@ def test_isdvc(tmp_dir, dvc):
def test_get_hash_file(tmp_dir, dvc):
tmp_dir.dvc_gen({"foo": "foo"})
fs = DataFileSystem(index=dvc.index.data["repo"])
- assert fs.info("foo")["md5"] == "acbd18db4cc2f85cedef654fccc4a4d8"
+ assert fs.info("foo")["sha256"] == "acbd18db4cc2f85cedef654fccc4a4d8"
def test_get_hash_dir(tmp_dir, dvc, mocker):
@@ -231,7 +231,7 @@ def test_get_hash_dir(tmp_dir, dvc, mocker):
)
fs = DataFileSystem(index=dvc.index.data["repo"])
hash_file_spy = mocker.spy(dvc_data.hashfile.hash, "hash_file")
- assert fs.info("dir")["md5"] == "8761c4e9acad696bee718615e23e22db.dir"
+ assert fs.info("dir")["sha256"] == "8761c4e9acad696bee718615e23e22db.dir"
assert not hash_file_spy.called
@@ -241,15 +241,15 @@ def test_get_hash_granular(tmp_dir, dvc):
)
fs = DataFileSystem(index=dvc.index.data["repo"])
subdir = "dir/subdir"
- assert fs.info(subdir).get("md5") is None
- _, _, obj = build(dvc.odb.local, subdir, fs, "md5", dry_run=True)
+ assert fs.info(subdir).get("sha256") is None
+ _, _, obj = build(dvc.odb.local, subdir, fs, "sha256", dry_run=True)
assert obj.hash_info == HashInfo(
- "md5", "af314506f1622d107e0ed3f14ec1a3b5.dir"
+ "sha256", "af314506f1622d107e0ed3f14ec1a3b5.dir"
)
data = posixpath.join(subdir, "data")
- assert fs.info(data)["md5"] == "8d777f385d3dfec8815d20f7496026dc"
- _, _, obj = build(dvc.odb.local, data, fs, "md5", dry_run=True)
- assert obj.hash_info == HashInfo("md5", "8d777f385d3dfec8815d20f7496026dc")
+ assert fs.info(data)["sha256"] == "8d777f385d3dfec8815d20f7496026dc"
+ _, _, obj = build(dvc.odb.local, data, fs, "sha256", dry_run=True)
+ assert obj.hash_info == HashInfo("sha256", "8d777f385d3dfec8815d20f7496026dc")
def test_get_hash_dirty_file(tmp_dir, dvc):
@@ -258,9 +258,9 @@ def test_get_hash_dirty_file(tmp_dir, dvc):
fs = DataFileSystem(index=dvc.index.data["repo"])
expected = "8c7dd922ad47494fc02c388e12c00eac"
- assert fs.info("file").get("md5") == expected
- _, _, obj = build(dvc.odb.local, "file", fs, "md5", dry_run=True)
- assert obj.hash_info == HashInfo("md5", expected)
+ assert fs.info("file").get("sha256") == expected
+ _, _, obj = build(dvc.odb.local, "file", fs, "sha256", dry_run=True)
+ assert obj.hash_info == HashInfo("sha256", expected)
def test_get_hash_dirty_dir(tmp_dir, dvc):
@@ -269,6 +269,6 @@ def test_get_hash_dirty_dir(tmp_dir, dvc):
fs = DataFileSystem(index=dvc.index.data["repo"])
expected = "5ea40360f5b4ec688df672a4db9c17d1.dir"
- assert fs.info("dir").get("md5") == expected
- _, _, obj = build(dvc.odb.local, "dir", fs, "md5", dry_run=True)
- assert obj.hash_info == HashInfo("md5", expected)
+ assert fs.info("dir").get("sha256") == expected
+ _, _, obj = build(dvc.odb.local, "dir", fs, "sha256", dry_run=True)
+ assert obj.hash_info == HashInfo("sha256", expected)
diff --git a/tests/unit/fs/test_dvc.py b/tests/unit/fs/test_dvc.py
index 17c8c9d5..d2087a5f 100644
--- a/tests/unit/fs/test_dvc.py
+++ b/tests/unit/fs/test_dvc.py
@@ -498,11 +498,11 @@ def test_get_hash_cached_file(tmp_dir, dvc, mocker):
tmp_dir.dvc_gen({"foo": "foo"})
fs = DvcFileSystem(repo=dvc)
expected = "acbd18db4cc2f85cedef654fccc4a4d8"
- assert fs.info("foo").get("md5") is None
- _, _, obj = build(dvc.odb.local, "foo", fs, "md5")
- assert obj.hash_info == HashInfo("md5", expected)
+ assert fs.info("foo").get("sha256") is None
+ _, _, obj = build(dvc.odb.local, "foo", fs, "sha256")
+ assert obj.hash_info == HashInfo("sha256", expected)
(tmp_dir / "foo").unlink()
- assert fs.info("foo")["md5"] == expected
+ assert fs.info("foo")["sha256"] == expected
def test_get_hash_cached_dir(tmp_dir, dvc, mocker):
@@ -511,17 +511,17 @@ def test_get_hash_cached_dir(tmp_dir, dvc, mocker):
)
fs = DvcFileSystem(repo=dvc)
expected = "8761c4e9acad696bee718615e23e22db.dir"
- assert fs.info("dir").get("md5") is None
- _, _, obj = build(dvc.odb.local, "dir", fs, "md5")
+ assert fs.info("dir").get("sha256") is None
+ _, _, obj = build(dvc.odb.local, "dir", fs, "sha256")
assert obj.hash_info == HashInfo(
- "md5", "8761c4e9acad696bee718615e23e22db.dir"
+ "sha256", "8761c4e9acad696bee718615e23e22db.dir"
)
shutil.rmtree(tmp_dir / "dir")
- assert fs.info("dir")["md5"] == expected
- _, _, obj = build(dvc.odb.local, "dir", fs, "md5")
+ assert fs.info("dir")["sha256"] == expected
+ _, _, obj = build(dvc.odb.local, "dir", fs, "sha256")
assert obj.hash_info == HashInfo(
- "md5", "8761c4e9acad696bee718615e23e22db.dir"
+ "sha256", "8761c4e9acad696bee718615e23e22db.dir"
)
@@ -531,17 +531,17 @@ def test_get_hash_cached_granular(tmp_dir, dvc, mocker):
)
fs = DvcFileSystem(repo=dvc)
subdir = "dir/subdir"
- assert fs.info(subdir).get("md5") is None
- _, _, obj = build(dvc.odb.local, subdir, fs, "md5")
+ assert fs.info(subdir).get("sha256") is None
+ _, _, obj = build(dvc.odb.local, subdir, fs, "sha256")
assert obj.hash_info == HashInfo(
- "md5", "af314506f1622d107e0ed3f14ec1a3b5.dir"
+ "sha256", "af314506f1622d107e0ed3f14ec1a3b5.dir"
)
- assert fs.info(posixpath.join(subdir, "data")).get("md5") is None
- _, _, obj = build(dvc.odb.local, posixpath.join(subdir, "data"), fs, "md5")
- assert obj.hash_info == HashInfo("md5", "8d777f385d3dfec8815d20f7496026dc")
+ assert fs.info(posixpath.join(subdir, "data")).get("sha256") is None
+ _, _, obj = build(dvc.odb.local, posixpath.join(subdir, "data"), fs, "sha256")
+ assert obj.hash_info == HashInfo("sha256", "8d777f385d3dfec8815d20f7496026dc")
(tmp_dir / "dir" / "subdir" / "data").unlink()
assert (
- fs.info(posixpath.join(subdir, "data"))["md5"]
+ fs.info(posixpath.join(subdir, "data"))["sha256"]
== "8d777f385d3dfec8815d20f7496026dc"
)
@@ -559,9 +559,9 @@ def test_get_hash_mixed_dir(tmp_dir, scm, dvc):
tmp_dir.scm.commit("add dir")
fs = DvcFileSystem(repo=dvc)
- _, _, obj = build(dvc.odb.local, "dir", fs, "md5")
+ _, _, obj = build(dvc.odb.local, "dir", fs, "sha256")
assert obj.hash_info == HashInfo(
- "md5", "e1d9e8eae5374860ae025ec84cfd85c7.dir"
+ "sha256", "e1d9e8eae5374860ae025ec84cfd85c7.dir"
)
@@ -570,28 +570,28 @@ def test_get_hash_dirty_file(tmp_dir, dvc):
from dvc_data.hashfile.hash import hash_file
tmp_dir.dvc_gen("file", "file")
- file_hash_info = HashInfo("md5", "8c7dd922ad47494fc02c388e12c00eac")
+ file_hash_info = HashInfo("sha256", "8c7dd922ad47494fc02c388e12c00eac")
(tmp_dir / "file").write_text("something")
- something_hash_info = HashInfo("md5", "437b930db84b8079c2dd804a71936b5f")
+ something_hash_info = HashInfo("sha256", "437b930db84b8079c2dd804a71936b5f")
# file is modified in workspace
# hash_file(file) should return workspace hash, not DVC cached hash
fs = DvcFileSystem(repo=dvc)
- assert fs.info("file").get("md5") is None
- staging, _, obj = build(dvc.odb.local, "file", fs, "md5")
+ assert fs.info("file").get("sha256") is None
+ staging, _, obj = build(dvc.odb.local, "file", fs, "sha256")
assert obj.hash_info == something_hash_info
check(staging, obj)
# hash_file(file) should return DVC cached hash
(tmp_dir / "file").unlink()
- assert fs.info("file")["md5"] == file_hash_info.value
- _, hash_info = hash_file("file", fs, "md5", state=dvc.state)
+ assert fs.info("file")["sha256"] == file_hash_info.value
+ _, hash_info = hash_file("file", fs, "sha256", state=dvc.state)
assert hash_info == file_hash_info
# tmp_dir/file can be built even though it is missing in workspace since
# repofs will use the DVC cached hash (and refer to the local cache object)
- _, _, obj = build(dvc.odb.local, "file", fs, "md5")
+ _, _, obj = build(dvc.odb.local, "file", fs, "sha256")
assert obj.hash_info == file_hash_info
@@ -600,9 +600,9 @@ def test_get_hash_dirty_dir(tmp_dir, dvc):
(tmp_dir / "dir" / "baz").write_text("baz")
fs = DvcFileSystem(repo=dvc)
- _, meta, obj = build(dvc.odb.local, "dir", fs, "md5")
+ _, meta, obj = build(dvc.odb.local, "dir", fs, "sha256")
assert obj.hash_info == HashInfo(
- "md5", "ba75a2162ca9c29acecb7957105a0bc2.dir"
+ "sha256", "ba75a2162ca9c29acecb7957105a0bc2.dir"
)
assert meta.nfiles == 3
diff --git a/tests/unit/output/test_local.py b/tests/unit/output/test_local.py
index 5d1ca10c..33ba3b46 100644
--- a/tests/unit/output/test_local.py
+++ b/tests/unit/output/test_local.py
@@ -64,12 +64,12 @@ class TestGetFilesNumber(TestDvc):
def test_return_multiple_for_dir(self):
o = self._get_output()
- o.hash_info = HashInfo("md5", "12345678.dir")
+ o.hash_info = HashInfo("sha256", "12345678.dir")
o.meta = Meta(nfiles=2)
self.assertEqual(2, o.get_files_number())
@patch.object(Output, "is_dir_checksum", False)
def test_return_1_on_single_file_cache(self):
o = self._get_output()
- o.hash_info = HashInfo("md5", "12345678")
+ o.hash_info = HashInfo("sha256", "12345678")
self.assertEqual(1, o.get_files_number())
diff --git a/tests/unit/output/test_output.py b/tests/unit/output/test_output.py
index e7c0dcef..4e466d63 100644
--- a/tests/unit/output/test_output.py
+++ b/tests/unit/output/test_output.py
@@ -31,7 +31,7 @@ def test_save_missing(dvc, mocker):
(
"3cc286c534a71504476da009ed174423",
"3cc286c534a71504476da009ed174423",
- ), # md5
+ ), # sha256
(
"d41d8cd98f00b204e9800998ecf8427e-38",
"d41d8cd98f00b204e9800998ecf8427e-38",
diff --git a/tests/unit/repo/test_repo.py b/tests/unit/repo/test_repo.py
index efb1ead4..7d1b7406 100644
--- a/tests/unit/repo/test_repo.py
+++ b/tests/unit/repo/test_repo.py
@@ -48,8 +48,8 @@ def test_used_objs(tmp_dir, dvc, path):
tmp_dir.dvc_gen({"dir": {"subdir": {"file": "file"}, "other": "other"}})
expected = {
- HashInfo("md5", "70922d6bf66eb073053a82f77d58c536.dir"),
- HashInfo("md5", "8c7dd922ad47494fc02c388e12c00eac"),
+ HashInfo("sha256", "70922d6bf66eb073053a82f77d58c536.dir"),
+ HashInfo("sha256", "8c7dd922ad47494fc02c388e12c00eac"),
}
used = set()
diff --git a/tests/unit/stage/test_loader_pipeline_file.py b/tests/unit/stage/test_loader_pipeline_file.py
index 5ef37201..83a00b49 100644
--- a/tests/unit/stage/test_loader_pipeline_file.py
+++ b/tests/unit/stage/test_loader_pipeline_file.py
@@ -20,8 +20,8 @@ def stage_data():
def lock_data():
return {
"cmd": "command",
- "deps": [{"path": "foo", "md5": "foo_checksum"}],
- "outs": [{"path": "bar", "md5": "bar_checksum"}],
+ "deps": [{"path": "foo", "sha256": "foo_checksum"}],
+ "outs": [{"path": "bar", "sha256": "bar_checksum"}],
}
@@ -35,8 +35,8 @@ def test_fill_from_lock_deps_outs(dvc, lock_data):
StageLoader.fill_from_lock(stage, lock_data)
- assert stage.deps[0].hash_info == HashInfo("md5", "foo_checksum")
- assert stage.outs[0].hash_info == HashInfo("md5", "bar_checksum")
+ assert stage.deps[0].hash_info == HashInfo("sha256", "foo_checksum")
+ assert stage.outs[0].hash_info == HashInfo("sha256", "bar_checksum")
def test_fill_from_lock_outs_isexec(dvc):
@@ -48,12 +48,12 @@ def test_fill_from_lock_outs_isexec(dvc):
stage,
{
"cmd": "command",
- "outs": [{"path": "foo", "md5": "foo_checksum", "isexec": True}],
+ "outs": [{"path": "foo", "sha256": "foo_checksum", "isexec": True}],
},
)
assert stage.outs[0].def_path == "foo"
- assert stage.outs[0].hash_info == HashInfo("md5", "foo_checksum")
+ assert stage.outs[0].hash_info == HashInfo("sha256", "foo_checksum")
assert stage.outs[0].meta.isexec
@@ -118,8 +118,8 @@ def test_fill_from_lock_missing_checksums(dvc, lock_data):
StageLoader.fill_from_lock(stage, lock_data)
- assert stage.deps[0].hash_info == HashInfo("md5", "foo_checksum")
- assert stage.outs[0].hash_info == HashInfo("md5", "bar_checksum")
+ assert stage.deps[0].hash_info == HashInfo("sha256", "foo_checksum")
+ assert stage.outs[0].hash_info == HashInfo("sha256", "bar_checksum")
assert not stage.deps[1].hash_info and not stage.outs[1].hash_info
@@ -134,7 +134,7 @@ def test_fill_from_lock_use_appropriate_checksum(dvc, lock_data):
lock_data["deps"] = [{"path": "s3://dvc-temp/foo", "etag": "e-tag"}]
StageLoader.fill_from_lock(stage, lock_data)
assert stage.deps[0].hash_info == HashInfo("etag", "e-tag")
- assert stage.outs[0].hash_info == HashInfo("md5", "bar_checksum")
+ assert stage.outs[0].hash_info == HashInfo("sha256", "bar_checksum")
def test_fill_from_lock_with_missing_sections(dvc, lock_data):
@@ -145,12 +145,12 @@ def test_fill_from_lock_with_missing_sections(dvc, lock_data):
del lock["deps"]
StageLoader.fill_from_lock(stage, lock)
assert not stage.deps[0].hash_info
- assert stage.outs[0].hash_info == HashInfo("md5", "bar_checksum")
+ assert stage.outs[0].hash_info == HashInfo("sha256", "bar_checksum")
lock = deepcopy(lock_data)
del lock["outs"]
StageLoader.fill_from_lock(stage, lock)
- assert stage.deps[0].hash_info == HashInfo("md5", "foo_checksum")
+ assert stage.deps[0].hash_info == HashInfo("sha256", "foo_checksum")
assert not stage.outs[0].hash_info
@@ -173,9 +173,9 @@ def test_load_stage(dvc, stage_data, lock_data):
assert stage.cmd == "command"
assert stage.path == os.path.abspath(PIPELINE_FILE)
assert stage.deps[0].def_path == "foo"
- assert stage.deps[0].hash_info == HashInfo("md5", "foo_checksum")
+ assert stage.deps[0].hash_info == HashInfo("sha256", "foo_checksum")
assert stage.outs[0].def_path == "bar"
- assert stage.outs[0].hash_info == HashInfo("md5", "bar_checksum")
+ assert stage.outs[0].hash_info == HashInfo("sha256", "bar_checksum")
def test_load_stage_cmd_with_list(dvc, stage_data, lock_data):
@@ -210,8 +210,8 @@ def test_load_stage_with_params(dvc, stage_data, lock_data):
assert deps[0].def_path == "foo" and stage.outs[0].def_path == "bar"
assert params[0].def_path == "params.yaml"
assert params[0].hash_info == HashInfo("params", {"lorem": "ipsum"})
- assert deps[0].hash_info == HashInfo("md5", "foo_checksum")
- assert stage.outs[0].hash_info == HashInfo("md5", "bar_checksum")
+ assert deps[0].hash_info == HashInfo("sha256", "foo_checksum")
+ assert stage.outs[0].hash_info == HashInfo("sha256", "bar_checksum")
@pytest.mark.parametrize("typ", ["metrics", "plots"])
@@ -221,7 +221,7 @@ def test_load_stage_with_metrics_and_plots(dvc, stage_data, lock_data, typ):
stage = StageLoader.load_stage(dvcfile, "stage-1", stage_data, lock_data)
assert stage.outs[0].def_path == "bar"
- assert stage.outs[0].hash_info == HashInfo("md5", "bar_checksum")
+ assert stage.outs[0].hash_info == HashInfo("sha256", "bar_checksum")
def test_load_changed_command(dvc, stage_data, lock_data):
diff --git a/tests/unit/stage/test_serialize_pipeline_lock.py b/tests/unit/stage/test_serialize_pipeline_lock.py
index c20fc19f..36846511 100644
--- a/tests/unit/stage/test_serialize_pipeline_lock.py
+++ b/tests/unit/stage/test_serialize_pipeline_lock.py
@@ -31,11 +31,11 @@ def test_lock(dvc):
def test_lock_deps(dvc):
stage = create_stage(PipelineStage, dvc, deps=["input"], **kwargs)
- stage.deps[0].hash_info = HashInfo("md5", "md-five")
+ stage.deps[0].hash_info = HashInfo("sha256", "md-five")
assert to_single_stage_lockfile(stage) == OrderedDict(
[
("cmd", "command"),
- ("deps", [OrderedDict([("path", "input"), ("md5", "md-five")])]),
+ ("deps", [OrderedDict([("path", "input"), ("sha256", "md-five")])]),
]
)
@@ -44,16 +44,16 @@ def test_lock_deps_order(dvc):
stage = create_stage(
PipelineStage, dvc, deps=["input1", "input0"], **kwargs
)
- stage.deps[0].hash_info = HashInfo("md5", "md-one1")
- stage.deps[1].hash_info = HashInfo("md5", "md-zer0")
+ stage.deps[0].hash_info = HashInfo("sha256", "md-one1")
+ stage.deps[1].hash_info = HashInfo("sha256", "md-zer0")
assert to_single_stage_lockfile(stage) == OrderedDict(
[
("cmd", "command"),
(
"deps",
[
- OrderedDict([("path", "input0"), ("md5", "md-zer0")]),
- OrderedDict([("path", "input1"), ("md5", "md-one1")]),
+ OrderedDict([("path", "input0"), ("sha256", "md-zer0")]),
+ OrderedDict([("path", "input1"), ("sha256", "md-one1")]),
],
),
]
@@ -142,11 +142,11 @@ def test_lock_params_without_targets(dvc, info, expected):
@pytest.mark.parametrize("typ", ["plots", "metrics", "outs"])
def test_lock_outs(dvc, typ):
stage = create_stage(PipelineStage, dvc, **{typ: ["input"]}, **kwargs)
- stage.outs[0].hash_info = HashInfo("md5", "md-five")
+ stage.outs[0].hash_info = HashInfo("sha256", "md-five")
assert to_single_stage_lockfile(stage) == OrderedDict(
[
("cmd", "command"),
- ("outs", [OrderedDict([("path", "input"), ("md5", "md-five")])]),
+ ("outs", [OrderedDict([("path", "input"), ("sha256", "md-five")])]),
]
)
@@ -154,7 +154,7 @@ def test_lock_outs(dvc, typ):
@pytest.mark.parametrize("typ", ["plots", "metrics", "outs"])
def test_lock_outs_isexec(dvc, typ):
stage = create_stage(PipelineStage, dvc, **{typ: ["input"]}, **kwargs)
- stage.outs[0].hash_info = HashInfo("md5", "md-five")
+ stage.outs[0].hash_info = HashInfo("sha256", "md-five")
stage.outs[0].meta.isexec = True
assert to_single_stage_lockfile(stage) == OrderedDict(
[
@@ -165,7 +165,7 @@ def test_lock_outs_isexec(dvc, typ):
OrderedDict(
[
("path", "input"),
- ("md5", "md-five"),
+ ("sha256", "md-five"),
("isexec", True),
]
)
@@ -180,16 +180,16 @@ def test_lock_outs_order(dvc, typ):
stage = create_stage(
PipelineStage, dvc, **{typ: ["input1", "input0"]}, **kwargs
)
- stage.outs[0].hash_info = HashInfo("md5", "md-one1")
- stage.outs[1].hash_info = HashInfo("md5", "md-zer0")
+ stage.outs[0].hash_info = HashInfo("sha256", "md-one1")
+ stage.outs[1].hash_info = HashInfo("sha256", "md-zer0")
assert to_single_stage_lockfile(stage) == OrderedDict(
[
("cmd", "command"),
(
"outs",
[
- OrderedDict([("path", "input0"), ("md5", "md-zer0")]),
- OrderedDict([("path", "input1"), ("md5", "md-one1")]),
+ OrderedDict([("path", "input0"), ("sha256", "md-zer0")]),
+ OrderedDict([("path", "input1"), ("sha256", "md-one1")]),
],
),
]
@@ -200,7 +200,7 @@ def test_dump_nondefault_hash(dvc):
stage = create_stage(
PipelineStage, dvc, deps=["s3://dvc-temp/file"], **kwargs
)
- stage.deps[0].hash_info = HashInfo("md5", "value")
+ stage.deps[0].hash_info = HashInfo("sha256", "value")
assert to_single_stage_lockfile(stage) == OrderedDict(
[
("cmd", "command"),
@@ -208,7 +208,7 @@ def test_dump_nondefault_hash(dvc):
"deps",
[
OrderedDict(
- [("path", "s3://dvc-temp/file"), ("md5", "value")]
+ [("path", "s3://dvc-temp/file"), ("sha256", "value")]
)
],
),
@@ -227,23 +227,23 @@ def test_order(dvc):
)
params, deps = split_params_deps(stage)
- deps[0].hash_info = HashInfo("md5", "md-five")
+ deps[0].hash_info = HashInfo("sha256", "md-five")
params[0].hash_info = HashInfo("params", {"foo-param": "value"})
- stage.outs[0].hash_info = HashInfo("md5", "md5-output")
+ stage.outs[0].hash_info = HashInfo("sha256", "sha256-output")
assert to_single_stage_lockfile(stage) == OrderedDict(
[
("cmd", "command"),
- ("deps", [{"path": "input", "md5": "md-five"}]),
+ ("deps", [{"path": "input", "sha256": "md-five"}]),
("params", {"params.yaml": {"foo-param": "value"}}),
- ("outs", [{"path": "output", "md5": "md5-output"}]),
+ ("outs", [{"path": "output", "sha256": "sha256-output"}]),
]
)
def test_to_lockfile(dvc):
stage = create_stage(PipelineStage, dvc, deps=["input"], **kwargs)
- stage.deps[0].hash_info = HashInfo("md5", "md-five")
+ stage.deps[0].hash_info = HashInfo("sha256", "md-five")
entry = to_lockfile(stage)
assert len(entry) == 1
_Schema(LOCKFILE_STAGES_SCHEMA)(entry)
@@ -251,7 +251,7 @@ def test_to_lockfile(dvc):
"something": OrderedDict(
[
("cmd", "command"),
- ("deps", [{"path": "input", "md5": "md-five"}]),
+ ("deps", [{"path": "input", "sha256": "md-five"}]),
]
)
}
diff --git a/tests/unit/stage/test_stage.py b/tests/unit/stage/test_stage.py
index f564448a..fb6ac3d2 100644
--- a/tests/unit/stage/test_stage.py
+++ b/tests/unit/stage/test_stage.py
@@ -10,10 +10,10 @@ from dvc.stage import Stage
from dvc.stage.exceptions import StageUpdateError
TEST_STAGE_DICT = {
- "md5": "123456",
+ "sha256": "123456",
"cmd": "mycmd",
- "outs": [{"path": "a", "md5": "123456789"}],
- "deps": [{"path": "b", "md5": "987654321"}],
+ "outs": [{"path": "a", "sha256": "123456789"}],
+ "deps": [{"path": "b", "sha256": "987654321"}],
}
@@ -21,7 +21,7 @@ def test_stage_checksum(mocker):
stage = Stage(None, "path", cmd="mycmd")
mocker.patch.object(stage, "dumpd", return_value=TEST_STAGE_DICT)
- assert stage.compute_md5() == "e9521a22111493406ea64a88cda63e0b"
+ assert stage.compute_sha256() == "e9521a22111493406ea64a88cda63e0b"
def test_wdir_default_ignored(mocker):
@@ -29,7 +29,7 @@ def test_wdir_default_ignored(mocker):
d = dict(TEST_STAGE_DICT, wdir=".")
mocker.patch.object(stage, "dumpd", return_value=d)
- assert stage.compute_md5() == "e9521a22111493406ea64a88cda63e0b"
+ assert stage.compute_sha256() == "e9521a22111493406ea64a88cda63e0b"
def test_wdir_non_default_is_not_ignored(mocker):
@@ -37,7 +37,7 @@ def test_wdir_non_default_is_not_ignored(mocker):
d = dict(TEST_STAGE_DICT, wdir="..")
mocker.patch.object(stage, "dumpd", return_value=d)
- assert stage.compute_md5() == "2ceba15e87f6848aa756502c1e6d24e9"
+ assert stage.compute_sha256() == "2ceba15e87f6848aa756502c1e6d24e9"
def test_meta_ignored(mocker):
@@ -45,7 +45,7 @@ def test_meta_ignored(mocker):
d = dict(TEST_STAGE_DICT, meta={"author": "Suor"})
mocker.patch.object(stage, "dumpd", return_value=d)
- assert stage.compute_md5() == "e9521a22111493406ea64a88cda63e0b"
+ assert stage.compute_sha256() == "e9521a22111493406ea64a88cda63e0b"
def test_path_conversion(dvc):
diff --git a/tests/unit/test_hashinfo.py b/tests/unit/test_hashinfo.py
index c7da09f3..776cb371 100644
--- a/tests/unit/test_hashinfo.py
+++ b/tests/unit/test_hashinfo.py
@@ -3,15 +3,15 @@ from dvc_data.hashfile.hash_info import HashInfo
def test_as_raw():
hash_info = HashInfo(
- "md5", "a1d0c6e83f027327d8461063f4ac58a6.dir", "objname"
+ "sha256", "a1d0c6e83f027327d8461063f4ac58a6.dir", "objname"
)
raw = hash_info.as_raw()
- assert hash_info.name == "md5"
+ assert hash_info.name == "sha256"
assert hash_info.value == "a1d0c6e83f027327d8461063f4ac58a6.dir"
assert hash_info.obj_name == "objname"
- assert raw.name == "md5"
+ assert raw.name == "sha256"
assert raw.value == "a1d0c6e83f027327d8461063f4ac58a6"
assert raw.obj_name == "objname"
diff --git a/tests/unit/test_lockfile.py b/tests/unit/test_lockfile.py
index ff42a775..831f9c45 100644
--- a/tests/unit/test_lockfile.py
+++ b/tests/unit/test_lockfile.py
@@ -31,8 +31,8 @@ def test_stage_dump_with_deps_and_outs(tmp_dir, dvc):
data = {
"s1": {
"cmd": "command",
- "deps": [{"md5": "1.txt", "path": "checksum"}],
- "outs": [{"md5": "2.txt", "path": "checksum"}],
+ "deps": [{"sha256": "1.txt", "path": "checksum"}],
+ "outs": [{"sha256": "2.txt", "path": "checksum"}],
}
}
(tmp_dir / "path.lock").dump(data)
@@ -70,11 +70,11 @@ def test_load_when_lockfile_does_not_exist(tmp_dir, dvc):
"s1": {
"cmd": "command",
"outs": [
- {"md5": "checksum", "path": "path", "random": "value"}
+ {"sha256": "checksum", "path": "path", "random": "value"}
],
}
},
- {"s1": {"cmd": "command", "deps": [{"md5": "checksum"}]}},
+ {"s1": {"cmd": "command", "deps": [{"sha256": "checksum"}]}},
],
)
def test_load_when_lockfile_is_corrupted(tmp_dir, dvc, corrupt_data):
Reference in a new issue View git blame Copy permalink