def test_plots_path_is_quoted_and_resolved_properly(
tmp_dir, dvc, mocker, capsys, output, expected_url_path, plots_data
):
cli_args = parse_args(
["plots", "diff", "--targets", "datafile", "--out", output]
)
cmd = cli_args.func(cli_args)
mocker.patch(
"dvc.repo.plots.diff.diff", return_value={"datafile": plots_data}
)
assert cmd.run() == 0
expected_url = posixpath.join(tmp_dir.as_uri(), expected_url_path)
out, _ = capsys.readouterr()
assert expected_url in out
def test_import_url(mocker):
cli_args = parse_args([
"import-url", "src", "out", "--file", "file", "--desc", "description"
])
assert cli_args.func == CmdImportUrl
cmd = cli_args.func(cli_args)
m = mocker.patch.object(cmd.repo, "imp_url", autospec=True)
assert cmd.run() == 0
m.assert_called_once_with("src",
out="out",
fname="file",
no_exec=False,
desc="description")
def test_params_diff_show_json(dvc, mocker, caplog, capsys):
cli_args = parse_args(
["params", "diff", "HEAD~10", "HEAD~1", "--show-json"])
cmd = cli_args.func(cli_args)
mocker.patch("dvc.repo.params.diff.diff",
return_value={"params.yaml": {
"a": "b"
}})
show_diff_mock = mocker.patch("dvc.compare.show_diff")
with caplog.at_level(logging.INFO, logger="dvc"):
assert cmd.run() == 0
assert '{"params.yaml": {"a": "b"}}\n' in caplog.text
show_diff_mock.assert_not_called()
assert capsys.readouterr() == ("", "")
def test_plots_diff_open(tmp_dir, dvc, mocker, capsys, plots_data):
mocked_open = mocker.patch("webbrowser.open", return_value=True)
cli_args = parse_args(
["plots", "diff", "--targets", "plots.csv", "--open"]
)
cmd = cli_args.func(cli_args)
mocker.patch("dvc.repo.plots.diff.diff", return_value=plots_data)
index_path = tmp_dir / "dvc_plots" / "index.html"
mocker.patch("dvc.command.plots.render", return_value=index_path)
assert cmd.run() == 0
mocked_open.assert_called_once_with(index_path)
out, _ = capsys.readouterr()
assert index_path.as_uri() in out
def test_checkout(tmp_dir, dvc, mocker):
cli_args = parse_args(
["checkout", "foo.dvc", "bar.dvc", "--relink", "--with-deps"])
assert cli_args.func == CmdCheckout
cmd = cli_args.func(cli_args)
m = mocker.patch("dvc.repo.Repo.checkout")
assert cmd.run() == 0
m.assert_called_once_with(
targets=["foo.dvc", "bar.dvc"],
force=False,
recursive=False,
relink=True,
with_deps=True,
)
def test_status_up_to_date(dvc, mocker, capsys, cloud_opts, expected_message):
cli_args = parse_args(["status", *cloud_opts])
assert cli_args.func == CmdDataStatus
cmd = cli_args.func(cli_args)
mocker.patch.dict(cmd.repo.config, {"core": {"remote": "default"}})
mocker.patch.object(cmd.repo, "status", autospec=True, return_value={})
mocker.patch.object(cmd.repo.stage,
"_collect_repo",
return_value=[object()],
autospec=True)
assert cmd.run() == 0
captured = capsys.readouterr()
assert expected_message in captured.out
def test_plots_diff_open_WSL(tmp_dir, dvc, mocker, plots_data):
mocked_open = mocker.patch("webbrowser.open", return_value=True)
mocked_uname_result = mocker.MagicMock()
mocked_uname_result.release = "Microsoft"
mocker.patch("platform.uname", return_value=mocked_uname_result)
cli_args = parse_args(
["plots", "diff", "--targets", "plots.csv", "--open"])
cmd = cli_args.func(cli_args)
mocker.patch("dvc.repo.plots.diff.diff", return_value=plots_data)
index_path = tmp_dir / "dvc_plots" / "index.html"
mocker.patch("dvc.render.utils.render", return_value=index_path)
assert cmd.run() == 0
mocked_open.assert_called_once_with(str(Path("dvc_plots") / "index.html"))
def test_plots_diff_open_failed(tmp_dir, dvc, mocker, capsys):
mocked_open = mocker.patch("webbrowser.open", return_value=False)
cli_args = parse_args(["plots", "diff", "--targets", "datafile", "--open"])
cmd = cli_args.func(cli_args)
mocker.patch("dvc.repo.plots.diff.diff",
return_value={"datafile": "filledtemplate"})
assert cmd.run() == 1
mocked_open.assert_called_once_with("plots.html")
error_message = "Failed to open. Please try opening it manually."
expected_url = posixpath.join(tmp_dir.as_uri(), "plots.html")
out, err = capsys.readouterr()
assert expected_url in out
assert error_message in err
def main(argv=None):
"""Run dvc CLI command.
Args:
argv: optional list of arguments to parse. sys.argv is used by default.
Returns:
int: command's return code.
"""
args = None
cmd = None
outerLogLevel = logger.level
try:
args = parse_args(argv)
if args.quiet:
logger.setLevel(logging.CRITICAL)
elif args.verbose:
logger.setLevel(logging.DEBUG)
cmd = args.func(args)
ret = cmd.run_cmd()
except ConfigError:
logger.exception("configuration error")
ret = 251
except KeyboardInterrupt:
logger.exception("interrupted by the user")
ret = 252
except NotDvcRepoError:
logger.exception("")
ret = 253
except DvcParserError:
ret = 254
except Exception: # pylint: disable=broad-except
logger.exception("unexpected error")
ret = 255
finally:
logger.setLevel(outerLogLevel)
# Python 2 fails to close these clean occasionally and users see
# weird error messages, so we do it manually
close_ssh_pools()
Analytics().send_cmd(cmd, args, ret)
return ret
def test_default(mocker, caplog):
args = parse_args(["diff"])
cmd = args.func(args)
diff = {
"added": [{"path": "file", "hash": "00000000"}],
"deleted": [],
"modified": [],
}
mocker.patch("dvc.repo.Repo.diff", return_value=diff)
assert 0 == cmd.run()
assert (
"Added:\n"
" file\n"
"\n"
"files summary: 1 added, 0 deleted, 0 modified"
) in caplog.text
def test(self):
dep1 = "dep1"
dep2 = "dep2"
out1 = "out1"
out2 = "out2"
out_no_cache1 = "out_no_cache1"
out_no_cache2 = "out_no_cache2"
fname = "dvc.dvc"
cmd = "cmd"
arg1 = "arg1"
arg2 = "arg2"
args = parse_args(
[
"run",
"-d",
dep1,
"--deps",
dep2,
"-o",
out1,
"--outs",
out2,
"-O",
out_no_cache1,
"--outs-no-cache",
out_no_cache2,
"-f",
fname,
"--file",
fname,
cmd,
arg1,
arg2,
]
)
self.assertIsInstance(args.func(args), CmdRun)
self.assertEqual(args.deps, [dep1, dep2])
self.assertEqual(args.outs, [out1, out2])
self.assertEqual(args.outs_no_cache, [out_no_cache1, out_no_cache2])
self.assertEqual(args.file, fname)
self.assertEqual(args.command, [cmd, arg1, arg2])
def test_experiments_init_explicit(dvc, mocker):
stage = mocker.Mock(outs=[])
m = mocker.patch("dvc.repo.experiments.init.init",
return_value=(stage, [], []))
cli_args = parse_args(["exp", "init", "--explicit", "cmd"])
cmd = cli_args.func(cli_args)
assert cmd.run() == 0
m.assert_called_once_with(
ANY(Repo),
name="train",
type="default",
defaults={},
overrides={"cmd": "cmd"},
interactive=False,
force=False,
)
def test_plots_diff_vega(dvc, mocker, capsys):
cli_args = parse_args([
"plots",
"diff",
"HEAD~10",
"HEAD~1",
"--show-vega",
"--targets",
"plots.csv",
])
cmd = cli_args.func(cli_args)
mocker.patch("dvc.repo.plots.diff.diff",
return_value={"plots.csv": "plothtml"})
assert cmd.run() == 0
out, _ = capsys.readouterr()
assert "plothtml" in out
def test_plots_diff_open_failed(tmp_dir, dvc, mocker, caplog):
mocked_open = mocker.patch("webbrowser.open", return_value=False)
cli_args = parse_args(["plots", "diff", "--targets", "datafile", "--open"])
cmd = cli_args.func(cli_args)
mocker.patch("dvc.repo.plots.diff.diff",
return_value={"datafile": "filledtemplate"})
assert cmd.run() == 1
mocked_open.assert_called_once_with("plots.html")
error_message = "Failed to open. Please try opening it manually."
expected_url = posixpath.join(tmp_dir.as_uri(), "plots.html")
assert caplog.record_tuples == [
("dvc.command.plots", logging.INFO, expected_url),
("dvc.command.plots", logging.ERROR, error_message),
]
def test_plots_diff_open_failed(tmp_dir, dvc, mocker, capsys, plots_data):
mocked_open = mocker.patch("webbrowser.open", return_value=False)
cli_args = parse_args(
["plots", "diff", "--targets", "plots.csv", "--open"])
cmd = cli_args.func(cli_args)
mocker.patch("dvc.repo.plots.diff.diff",
return_value={"datafile": plots_data})
assert cmd.run() == 1
expected_url = tmp_dir / "dvc_plots" / "index.html"
mocked_open.assert_called_once_with(expected_url.as_uri())
error_message = "Failed to open. Please try opening it manually."
out, err = capsys.readouterr()
assert expected_url.as_uri() in out
assert error_message in err
def test_show_json(mocker, caplog):
args = parse_args(["diff", "--show-json"])
cmd = args.func(args)
diff = {
"added": [
{"path": "file2", "hash": "22222222"},
{"path": "file1", "hash": "11111111"},
],
"deleted": [],
"modified": [],
}
mocker.patch("dvc.repo.Repo.diff", return_value=diff)
assert 0 == cmd.run()
assert '"added": [{"path": "file1"}, {"path": "file2"}]' in caplog.text
assert '"deleted": []' in caplog.text
assert '"modified": []' in caplog.text
def test_experiments_run(dvc, mocker, args, resume):
default_arguments = {
"params": [],
"queue": False,
"run_all": False,
"jobs": None,
"checkpoint_resume": resume,
}
default_arguments.update(repro_arguments)
cmd = CmdExperimentsRun(parse_args(args))
mocker.patch.object(cmd.repo, "reproduce")
mocker.patch.object(cmd.repo.experiments, "run")
cmd.run()
cmd.repo.experiments.run.assert_called_with(PIPELINE_FILE,
**default_arguments)
def test_collect_and_send_report(mock_json, mock_daemon, tmp_global_dir):
analytics.collect_and_send_report()
report = mock_json.call_args[0][0]
assert not report.get("cmd_class")
assert not report.get("cmd_return_code")
args = parse_args(["add", "foo"])
return_code = 0
analytics.collect_and_send_report(args, return_code)
report = mock_json.call_args[0][0]
assert report["cmd_class"] == "CmdAdd"
assert report["cmd_return_code"] == return_code
assert mock_daemon.call_count == 2
def test_list(tmp_dir, mocker, show_origin):
from dvc.compare import TabularData
from dvc.ui import ui
tmp_dir.gen(DATA)
cli_args = parse_args(["machine", "list"] + show_origin + ["foo"])
assert cli_args.func == CmdMachineList
cmd = cli_args.func(cli_args)
if show_origin:
m = mocker.patch.object(ui, "write", autospec=True)
else:
m = mocker.patch.object(TabularData, "render", autospec=True)
assert cmd.run() == 0
if show_origin:
m.assert_called_once_with(f".dvc{os.sep}config cloud=aws")
else:
m.assert_called_once()
def test_metrics_diff(dvc, mocker):
cli_args = parse_args([
"plots",
"diff",
"--out",
"result.extension",
"-t",
"template",
"--targets",
"datafile",
"--show-vega",
"-x",
"x_field",
"-y",
"y_field",
"--title",
"my_title",
"--x-label",
"x_title",
"--y-label",
"y_title",
"HEAD",
"tag1",
"tag2",
])
assert cli_args.func == CmdPlotsDiff
cmd = cli_args.func(cli_args)
m = mocker.patch("dvc.repo.plots.diff.diff",
return_value={"datafile": "filledtemplate"})
assert cmd.run() == 0
m.assert_called_once_with(
cmd.repo,
targets=["datafile"],
revs=["HEAD", "tag1", "tag2"],
props={
"template": "template",
"x": "x_field",
"y": "y_field",
"title": "my_title",
"x_label": "x_title",
"y_label": "y_title",
},
)
def test_params_diff_from_cli(dvc, mocker):
cli_args = parse_args(["params", "diff"])
assert cli_args.func == CmdParamsDiff
cmd = cli_args.func(cli_args)
m = mocker.patch("dvc.repo.params.diff.diff", return_value={})
assert cmd.run() == 0
m.assert_called_once_with(
cmd.repo,
a_rev=None,
b_rev=None,
all=False,
targets=None,
deps=False,
)
def test_json(mocker, caplog):
args = parse_args(["diff", "--show-json"])
cmd = args.func(args)
diff = {
"added": [{
"path": "file",
"checksum": "00000000"
}],
"deleted": [],
"modified": [],
}
mocker.patch("dvc.repo.Repo.diff", return_value=diff)
assert 0 == cmd.run()
assert '"added": [{"path": "file"}]' in caplog.text
assert '"deleted": []' in caplog.text
assert '"modified": []' in caplog.text
def test_experiments_init_config(dvc, mocker):
with dvc.config.edit() as conf:
conf["exp"] = {"code": "new_src", "models": "new_models"}
m = mocker.patch("dvc.repo.experiments.init.init")
cli_args = parse_args(["exp", "init", "cmd"])
cmd = cli_args.func(cli_args)
assert cmd.run() == 0
assert m.call_args[1]["defaults"] == {
"code": "new_src",
"models": "new_models",
"data": "data",
"metrics": "metrics.json",
"params": "params.yaml",
"plots": "plots",
"live": "dvclive",
}
def main(argv=None):
Logger.init()
args = parse_args(argv)
try:
cmd = args.func(args)
except Exception as ex:
Logger.error('Initialization error', ex)
return 255
try:
ret = cmd.run_cmd()
except Exception as ex:
Logger.error('Unexpected error', ex)
return 254
return ret
def test_show_json_and_hash(mocker, caplog):
args = parse_args(["diff", "--show-json", "--show-hash"])
cmd = args.func(args)
diff = {
"added": [
# py35: maintain a consistent key order for tests purposes
collections.OrderedDict([("path", "file"), ("hash", "00000000")])
],
"deleted": [],
"modified": [],
}
mocker.patch("dvc.repo.Repo.diff", return_value=diff)
assert 0 == cmd.run()
assert '"added": [{"path": "file", "hash": "00000000"}]' in caplog.text
assert '"deleted": []' in caplog.text
assert '"modified": []' in caplog.text
def test_update(dvc, mocker):
cli_args = parse_args(
["update", "target1", "target2", "--rev", "REV", "--recursive"]
)
assert cli_args.func == CmdUpdate
cmd = cli_args.func(cli_args)
m = mocker.patch("dvc.repo.Repo.update")
assert cmd.run() == 0
m.assert_called_once_with(
targets=["target1", "target2"],
rev="REV",
recursive=True,
to_remote=False,
remote=None,
jobs=None,
)
def test_plots_show_vega(dvc, mocker, caplog):
cli_args = parse_args(
[
"plots",
"diff",
"HEAD~10",
"HEAD~1",
"--show-vega",
"--targets",
"plots.csv",
]
)
cmd = cli_args.func(cli_args)
mocker.patch(
"dvc.repo.plots.diff.diff", return_value={"plots.csv": "plothtml"}
)
assert cmd.run() == 0
assert "plothtml" in caplog.text
def test_experiments_run(dvc, scm, mocker):
default_arguments = {
"params": [],
"name": None,
"queue": False,
"run_all": False,
"jobs": 1,
"tmp_dir": False,
"checkpoint_resume": None,
"reset": False,
}
default_arguments.update(repro_arguments)
cmd = CmdExperimentsRun(parse_args(["exp", "run"]))
mocker.patch.object(cmd.repo, "reproduce")
mocker.patch.object(cmd.repo.experiments, "run")
cmd.run()
cmd.repo.experiments.run.assert_called_with(**default_arguments)
def test_metrics_diff(dvc, mocker):
cli_args = parse_args([
"plots",
"diff",
"--out",
"result.extension",
"-t",
"template",
"--targets",
"datafile",
"--show-json",
"-x",
"x_field",
"-y",
"y_field",
"--title",
"my_title",
"--xlab",
"x_title",
"--ylab",
"y_title",
"HEAD",
"tag1",
"tag2",
])
assert cli_args.func == CmdPlotsDiff
cmd = cli_args.func(cli_args)
m = mocker.patch("dvc.repo.plots.diff.diff", return_value={})
assert cmd.run() == 0
m.assert_called_once_with(
cmd.repo,
targets=["datafile"],
template="template",
revs=["HEAD", "tag1", "tag2"],
x_field="x_field",
y_field="y_field",
csv_header=True,
title="my_title",
x_title="x_title",
y_title="y_title",
)
def test_experiments_show(dvc, mocker):
cli_args = parse_args([
"experiments",
"show",
"--all-tags",
"--all-branches",
"--all-commits",
])
assert cli_args.func == CmdExperimentsShow
cmd = cli_args.func(cli_args)
m = mocker.patch("dvc.repo.experiments.show.show", return_value={})
assert cmd.run() == 0
m.assert_called_once_with(cmd.repo,
all_tags=True,
all_branches=True,
all_commits=True)
