Merging upstream version 0.16.2.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 366 insertions, 258 deletions

diff --git a/tests/test_main.py b/tests/test_main.py
index 3941ea9..e36c2d8 100644
--- a/tests/test_main.py
+++ b/tests/test_main.py
@@ -1,4 +1,3 @@
-import os
 import pytest
 from unittest.mock import patch
 from pathlib import Path
@@ -7,312 +6,368 @@ import asyncio
 import shlex
 
 from gita import __main__
-from gita import utils, info, common
+from gita import utils, info
 from conftest import (
-    PATH_FNAME, PATH_FNAME_EMPTY, PATH_FNAME_CLASH, GROUP_FNAME,
-    async_mock, TEST_DIR,
+    PATH_FNAME,
+    PATH_FNAME_EMPTY,
+    PATH_FNAME_CLASH,
+    GROUP_FNAME,
+    async_mock,
+    TEST_DIR,
 )
 
 
-@patch('gita.utils.get_repos', return_value={'aa'})
+@patch("gita.utils.get_repos", return_value={"aa"})
 def test_group_name(_):
-    got = __main__._group_name('xx')
-    assert got == 'xx'
+    got = __main__._group_name("xx")
+    assert got == "xx"
     with pytest.raises(SystemExit):
-        __main__._group_name('aa')
+        __main__._group_name("aa")
 
 
 class TestAdd:
-
-    @pytest.mark.parametrize('input, expected', [
-        (['add', '.'], ''),
-        ])
-    @patch('gita.common.get_config_fname')
+    @pytest.mark.parametrize(
+        "input, expected",
+        [
+            (["add", "."], ""),
+        ],
+    )
+    @patch("gita.common.get_config_fname")
     def test_add(self, mock_path_fname, tmp_path, input, expected):
         def side_effect(input, _=None):
-            return tmp_path / f'{input}.txt'
+            return tmp_path / f"{input}.txt"
+
         mock_path_fname.side_effect = side_effect
         utils.get_repos.cache_clear()
         __main__.main(input)
         utils.get_repos.cache_clear()
         got = utils.get_repos()
         assert len(got) == 1
-        assert got['gita']['type'] == expected
+        assert got["gita"]["type"] == expected
 
 
-@pytest.mark.parametrize('path_fname, expected', [
-    (PATH_FNAME, ''),
-    (PATH_FNAME_CLASH, "repo2: ['--haha', '--pp']\n"),
-    ])
-@patch('gita.utils.is_git', return_value=True)
-@patch('gita.utils.get_groups', return_value={})
-@patch('gita.common.get_config_fname')
+@pytest.mark.parametrize(
+    "path_fname, expected",
+    [
+        (PATH_FNAME, ""),
+        (PATH_FNAME_CLASH, "repo2: ['--haha', '--pp']\n"),
+    ],
+)
+@patch("gita.utils.is_git", return_value=True)
+@patch("gita.utils.get_groups", return_value={})
+@patch("gita.common.get_config_fname")
 def test_flags(mock_path_fname, _, __, path_fname, expected, capfd):
     mock_path_fname.return_value = path_fname
     utils.get_repos.cache_clear()
-    __main__.main(['flags'])
+    __main__.main(["flags"])
     out, err = capfd.readouterr()
-    assert err == ''
+    assert err == ""
     assert out == expected
 
 
 class TestLsLl:
-    @patch('gita.common.get_config_fname')
+    @patch("gita.common.get_config_fname")
     def test_ll(self, mock_path_fname, capfd, tmp_path):
         """
         functional test
         """
         # avoid modifying the local configuration
         def side_effect(input, _=None):
-            return tmp_path / f'{input}.txt'
+            return tmp_path / f"{input}.txt"
+
         mock_path_fname.side_effect = side_effect
         utils.get_repos.cache_clear()
-        __main__.main(['add', '.'])
+        __main__.main(["add", "."])
         out, err = capfd.readouterr()
-        assert err == ''
-        assert 'Found 1 new repo(s).\n' == out
+        assert err == ""
+        assert "Found 1 new repo(s).\n" == out
 
         # in production this is not needed
         utils.get_repos.cache_clear()
 
-        __main__.main(['ls'])
+        __main__.main(["ls"])
         out, err = capfd.readouterr()
-        assert err == ''
-        assert 'gita\n' == out
+        assert err == ""
+        assert "gita\n" == out
 
-        __main__.main(['ll'])
+        __main__.main(["ll"])
         out, err = capfd.readouterr()
-        assert err == ''
-        assert 'gita' in out
+        assert err == ""
+        assert "gita" in out
         assert info.Color.end in out
 
         # no color on branch name
-        __main__.main(['ll', '-C'])
+        __main__.main(["ll", "-C"])
         out, err = capfd.readouterr()
-        assert err == ''
-        assert 'gita' in out
+        assert err == ""
+        assert "gita" in out
         assert info.Color.end not in out
 
-        __main__.main(['ls', 'gita'])
+        __main__.main(["ls", "gita"])
         out, err = capfd.readouterr()
-        assert err == ''
-        assert out.strip() == utils.get_repos()['gita']['path']
+        assert err == ""
+        assert out.strip() == utils.get_repos()["gita"]["path"]
 
     def test_ls(self, monkeypatch, capfd):
-        monkeypatch.setattr(utils, 'get_repos',
-                lambda: {'repo1': {'path': '/a/'}, 'repo2': {'path': '/b/'}})
-        monkeypatch.setattr(utils, 'describe', lambda x: x)
-        __main__.main(['ls'])
+        monkeypatch.setattr(
+            utils,
+            "get_repos",
+            lambda: {"repo1": {"path": "/a/"}, "repo2": {"path": "/b/"}},
+        )
+        monkeypatch.setattr(utils, "describe", lambda x: x)
+        __main__.main(["ls"])
         out, err = capfd.readouterr()
-        assert err == ''
+        assert err == ""
         assert out == "repo1 repo2\n"
-        __main__.main(['ls', 'repo1'])
+        __main__.main(["ls", "repo1"])
         out, err = capfd.readouterr()
-        assert err == ''
-        assert out == '/a/\n'
-
-    @pytest.mark.parametrize('path_fname, expected', [
-        (PATH_FNAME,
-         "repo1 cmaster dsu\x1b[0m msg \nrepo2 cmaster dsu\x1b[0m msg \nxxx   cmaster dsu\x1b[0m msg \n"),
-        (PATH_FNAME_EMPTY, ""),
-        (PATH_FNAME_CLASH,
-         "repo1 cmaster dsu\x1b[0m msg \nrepo2 cmaster dsu\x1b[0m msg \n"
-         ),
-    ])
-    @patch('gita.utils.is_git', return_value=True)
-    @patch('gita.info.get_head', return_value="master")
-    @patch('gita.info._get_repo_status', return_value=("d", "s", "u", "c"))
-    @patch('gita.info.get_commit_msg', return_value="msg")
-    @patch('gita.info.get_commit_time', return_value="")
-    @patch('gita.common.get_config_fname')
-    def test_with_path_files(self, mock_path_fname, _0, _1, _2, _3, _4, path_fname,
-                          expected, capfd):
+        assert err == ""
+        assert out == "/a/\n"
+
+    @pytest.mark.parametrize(
+        "path_fname, expected",
+        [
+            (
+                PATH_FNAME,
+                "repo1 cmaster dsu\x1b[0m msg \nrepo2 cmaster dsu\x1b[0m msg \nxxx   cmaster dsu\x1b[0m msg \n",
+            ),
+            (PATH_FNAME_EMPTY, ""),
+            (
+                PATH_FNAME_CLASH,
+                "repo1 cmaster dsu\x1b[0m msg \nrepo2 cmaster dsu\x1b[0m msg \n",
+            ),
+        ],
+    )
+    @patch("gita.utils.is_git", return_value=True)
+    @patch("gita.info.get_head", return_value="master")
+    @patch("gita.info._get_repo_status", return_value=("d", "s", "u", "c"))
+    @patch("gita.info.get_commit_msg", return_value="msg")
+    @patch("gita.info.get_commit_time", return_value="")
+    @patch("gita.common.get_config_fname")
+    def test_with_path_files(
+        self, mock_path_fname, _0, _1, _2, _3, _4, path_fname, expected, capfd
+    ):
         def side_effect(input, _=None):
-            if input == 'repos.csv':
+            if input == "repos.csv":
                 return path_fname
-            return f'/{input}'
+            return f"/{input}"
+
         mock_path_fname.side_effect = side_effect
         utils.get_repos.cache_clear()
-        __main__.main(['ll'])
+        __main__.main(["ll"])
         out, err = capfd.readouterr()
         print(out)
-        assert err == ''
+        assert err == ""
         assert out == expected
 
 
-@pytest.mark.parametrize('input, expected', [
-    ({'repo1': {'path': '/a/'}, 'repo2': {'path': '/b/'}}, ''),
-    ])
-@patch('subprocess.run')
-@patch('gita.utils.get_repos')
+@pytest.mark.parametrize(
+    "input, expected",
+    [
+        ({"repo1": {"path": "/a/"}, "repo2": {"path": "/b/"}}, ""),
+    ],
+)
+@patch("subprocess.run")
+@patch("gita.utils.get_repos")
 def test_freeze(mock_repos, mock_run, input, expected, capfd):
     mock_repos.return_value = input
-    __main__.main(['freeze'])
+    __main__.main(["freeze"])
     assert mock_run.call_count == 2
     out, err = capfd.readouterr()
-    assert err == ''
+    assert err == ""
     assert out == expected
 
 
-@patch('gita.utils.parse_clone_config', return_value=[
-    ['git@github.com:user/repo.git', 'repo', '/a/repo']])
-@patch('gita.utils.run_async', new=async_mock())
-@patch('subprocess.run')
-def test_clone(*_):
-    asyncio.set_event_loop(asyncio.new_event_loop())
+@patch("subprocess.run")
+def test_clone_with_url(mock_run):
     args = argparse.Namespace()
-    args.fname = ['freeze_filename']
+    args.clonee = "http://abc.com/repo1"
     args.preserve_path = None
+    args.directory = "/home/xxx"
+    args.from_file = False
+    __main__.f_clone(args)
+    cmds = ["git", "clone", args.clonee]
+    mock_run.assert_called_once_with(cmds, cwd=args.directory)
+
+
+@patch(
+    "gita.utils.parse_clone_config",
+    return_value=[["git@github.com:user/repo.git", "repo", "/a/repo"]],
+)
+@patch("gita.utils.run_async", new=async_mock())
+@patch("subprocess.run")
+def test_clone_with_config_file(*_):
+    asyncio.set_event_loop(asyncio.new_event_loop())
+    args = argparse.Namespace()
+    args.clonee = "freeze_filename"
+    args.preserve_path = False
+    args.directory = None
+    args.from_file = True
     __main__.f_clone(args)
     mock_run = utils.run_async.mock
     assert mock_run.call_count == 1
-    cmds = ['git', 'clone', 'git@github.com:user/repo.git']
-    mock_run.assert_called_once_with('repo', Path.cwd(), cmds)
+    cmds = ["git", "clone", "git@github.com:user/repo.git"]
+    mock_run.assert_called_once_with("repo", Path.cwd(), cmds)
 
 
-@patch('gita.utils.parse_clone_config', return_value=[
-    ['git@github.com:user/repo.git', 'repo', '/a/repo']])
-@patch('gita.utils.run_async', new=async_mock())
-@patch('subprocess.run')
+@patch(
+    "gita.utils.parse_clone_config",
+    return_value=[["git@github.com:user/repo.git", "repo", "/a/repo"]],
+)
+@patch("gita.utils.run_async", new=async_mock())
+@patch("subprocess.run")
 def test_clone_with_preserve_path(*_):
     asyncio.set_event_loop(asyncio.new_event_loop())
     args = argparse.Namespace()
-    args.fname = ['freeze_filename']
+    args.clonee = "freeze_filename"
+    args.directory = None
+    args.from_file = True
     args.preserve_path = True
     __main__.f_clone(args)
     mock_run = utils.run_async.mock
     assert mock_run.call_count == 1
-    cmds = ['git', 'clone', 'git@github.com:user/repo.git', '/a/repo']
-    mock_run.assert_called_once_with('repo', Path.cwd(), cmds)
+    cmds = ["git", "clone", "git@github.com:user/repo.git", "/a/repo"]
+    mock_run.assert_called_once_with("repo", Path.cwd(), cmds)
 
 
-@patch('os.makedirs')
-@patch('os.path.isfile', return_value=True)
-@patch('gita.common.get_config_fname', return_value='some path')
-@patch('gita.utils.get_repos', return_value={'repo1': {'path': '/a/', 'type': ''},
-                                             'repo2': {'path': '/b/', 'type': ''}})
-@patch('gita.utils.write_to_repo_file')
+@patch("os.makedirs")
+@patch("os.path.isfile", return_value=True)
+@patch("gita.common.get_config_fname", return_value="some path")
+@patch(
+    "gita.utils.get_repos",
+    return_value={
+        "repo1": {"path": "/a/", "type": ""},
+        "repo2": {"path": "/b/", "type": ""},
+    },
+)
+@patch("gita.utils.write_to_repo_file")
 def test_rm(mock_write, *_):
     args = argparse.Namespace()
-    args.repo = ['repo1']
+    args.repo = ["repo1"]
     __main__.f_rm(args)
-    mock_write.assert_called_once_with(
-            {'repo2': {'path': '/b/', 'type': ''}}, 'w')
+    mock_write.assert_called_once_with({"repo2": {"path": "/b/", "type": ""}}, "w")
 
 
 def test_not_add():
     # this won't write to disk because the repo is not valid
-    __main__.main(['add', '/home/some/repo/'])
+    __main__.main(["add", "/home/some/repo/"])
 
 
-@patch('gita.utils.get_repos', return_value={'repo2': {'path': '/d/efg',
-                    'flags': []}})
-@patch('subprocess.run')
+@patch("gita.utils.get_repos", return_value={"repo2": {"path": "/d/efg", "flags": []}})
+@patch("subprocess.run")
 def test_fetch(mock_run, *_):
     asyncio.set_event_loop(asyncio.new_event_loop())
-    __main__.main(['fetch'])
-    mock_run.assert_called_once_with(['git', 'fetch'], cwd='/d/efg', shell=False)
+    __main__.main(["fetch"])
+    mock_run.assert_called_once_with(["git", "fetch"], cwd="/d/efg", shell=False)
 
 
 @patch(
-    'gita.utils.get_repos', return_value={
-        'repo1': {'path': '/a/bc', 'flags': []},
-        'repo2': {'path': '/d/efg', 'flags': []}
-    })
-@patch('gita.utils.run_async', new=async_mock())
-@patch('subprocess.run')
+    "gita.utils.get_repos",
+    return_value={
+        "repo1": {"path": "/a/bc", "flags": []},
+        "repo2": {"path": "/d/efg", "flags": []},
+    },
+)
+@patch("gita.utils.run_async", new=async_mock())
+@patch("subprocess.run")
 def test_async_fetch(*_):
-    __main__.main(['fetch'])
+    __main__.main(["fetch"])
     mock_run = utils.run_async.mock
     assert mock_run.call_count == 2
-    cmds = ['git', 'fetch']
+    cmds = ["git", "fetch"]
     # print(mock_run.call_args_list)
-    mock_run.assert_any_call('repo1', '/a/bc', cmds)
-    mock_run.assert_any_call('repo2', '/d/efg', cmds)
+    mock_run.assert_any_call("repo1", "/a/bc", cmds)
+    mock_run.assert_any_call("repo2", "/d/efg", cmds)
 
 
-@pytest.mark.parametrize('input', [
-    'diff --name-only --staged',
-    "commit -am 'lala kaka'",
-])
-@patch('gita.utils.get_repos', return_value={'repo7': {'path': 'path7', 'flags': []}})
-@patch('subprocess.run')
+@pytest.mark.parametrize(
+    "input",
+    [
+        "diff --name-only --staged",
+        "commit -am 'lala kaka'",
+    ],
+)
+@patch("gita.utils.get_repos", return_value={"repo7": {"path": "path7", "flags": []}})
+@patch("subprocess.run")
 def test_superman(mock_run, _, input):
     mock_run.reset_mock()
-    args = ['super', 'repo7'] + shlex.split(input)
+    args = ["super", "repo7"] + shlex.split(input)
     __main__.main(args)
-    expected_cmds = ['git'] + shlex.split(input)
-    mock_run.assert_called_once_with(expected_cmds, cwd='path7', shell=False)
+    expected_cmds = ["git"] + shlex.split(input)
+    mock_run.assert_called_once_with(expected_cmds, cwd="path7", shell=False)
 
 
-@pytest.mark.parametrize('input', [
-    'diff --name-only --staged',
-    "commit -am 'lala kaka'",
-])
-@patch('gita.utils.get_repos', return_value={'repo7': {'path': 'path7', 'flags': []}})
-@patch('subprocess.run')
+@pytest.mark.parametrize(
+    "input",
+    [
+        "diff --name-only --staged",
+        "commit -am 'lala kaka'",
+    ],
+)
+@patch("gita.utils.get_repos", return_value={"repo7": {"path": "path7", "flags": []}})
+@patch("subprocess.run")
 def test_shell(mock_run, _, input):
     mock_run.reset_mock()
-    args = ['shell', 'repo7', input]
+    args = ["shell", "repo7", input]
     __main__.main(args)
     expected_cmds = input
-    mock_run.assert_called_once_with(expected_cmds, cwd='path7', shell=True, stderr=-2, stdout=-1)
+    mock_run.assert_called_once_with(
+        expected_cmds, cwd="path7", shell=True, stderr=-2, stdout=-1
+    )
 
 
 class TestContext:
-
-    @patch('gita.utils.get_context', return_value=None)
+    @patch("gita.utils.get_context", return_value=None)
     def test_display_no_context(self, _, capfd):
-        __main__.main(['context'])
+        __main__.main(["context"])
         out, err = capfd.readouterr()
-        assert err == ''
-        assert 'Context is not set\n' == out
+        assert err == ""
+        assert "Context is not set\n" == out
 
-    @patch('gita.utils.get_context', return_value=Path('gname.context'))
-    @patch('gita.utils.get_groups', return_value={'gname': {'repos': ['a', 'b']}})
+    @patch("gita.utils.get_context", return_value=Path("gname.context"))
+    @patch("gita.utils.get_groups", return_value={"gname": {"repos": ["a", "b"]}})
     def test_display_context(self, _, __, capfd):
-        __main__.main(['context'])
+        __main__.main(["context"])
         out, err = capfd.readouterr()
-        assert err == ''
-        assert 'gname: a b\n' == out
+        assert err == ""
+        assert "gname: a b\n" == out
 
-    @patch('gita.utils.get_context')
+    @patch("gita.utils.get_context")
     def test_reset(self, mock_ctx):
-        __main__.main(['context', 'none'])
+        __main__.main(["context", "none"])
         mock_ctx.return_value.unlink.assert_called()
 
-    @patch('gita.utils.get_context', return_value=None)
-    @patch('gita.common.get_config_dir', return_value=TEST_DIR)
-    @patch('gita.utils.get_groups', return_value={'lala': ['b'], 'kaka': []})
+    @patch("gita.utils.get_context", return_value=None)
+    @patch("gita.common.get_config_dir", return_value=TEST_DIR)
+    @patch("gita.utils.get_groups", return_value={"lala": ["b"], "kaka": []})
     def test_set_first_time(self, *_):
-        ctx = TEST_DIR / 'lala.context'
+        ctx = TEST_DIR / "lala.context"
         assert not ctx.is_file()
-        __main__.main(['context', 'lala'])
+        __main__.main(["context", "lala"])
         assert ctx.is_file()
         ctx.unlink()
 
-    @patch('gita.common.get_config_dir', return_value=TEST_DIR)
-    @patch('gita.utils.get_groups', return_value={'lala': ['b'], 'kaka': []})
-    @patch('gita.utils.get_context')
+    @patch("gita.common.get_config_dir", return_value=TEST_DIR)
+    @patch("gita.utils.get_groups", return_value={"lala": ["b"], "kaka": []})
+    @patch("gita.utils.get_context")
     def test_set_second_time(self, mock_ctx, *_):
-        __main__.main(['context', 'kaka'])
+        __main__.main(["context", "kaka"])
         mock_ctx.return_value.rename.assert_called()
 
 
 class TestGroupCmd:
-
-    @patch('gita.common.get_config_fname', return_value=GROUP_FNAME)
+    @patch("gita.common.get_config_fname", return_value=GROUP_FNAME)
     def test_ls(self, _, capfd):
         args = argparse.Namespace()
         args.to_group = None
-        args.group_cmd = 'ls'
+        args.group_cmd = "ls"
         utils.get_groups.cache_clear()
         __main__.f_group(args)
         out, err = capfd.readouterr()
-        assert err == ''
-        assert 'xx yy\n' == out
+        assert err == ""
+        assert "xx yy\n" == out
 
-    @patch('gita.common.get_config_fname', return_value=GROUP_FNAME)
+    @patch("gita.common.get_config_fname", return_value=GROUP_FNAME)
     def test_ll(self, _, capfd):
         args = argparse.Namespace()
         args.to_group = None
@@ -321,175 +376,228 @@ class TestGroupCmd:
         utils.get_groups.cache_clear()
         __main__.f_group(args)
         out, err = capfd.readouterr()
-        assert err == ''
-        assert out == '\x1b[4mxx\x1b[0m: \n  - a\n  - b\n\x1b[4myy\x1b[0m: \n  - a\n  - c\n  - d\n'
+        assert err == ""
+        assert (
+            out
+            == "\x1b[4mxx\x1b[0m: \n  - a\n  - b\n\x1b[4myy\x1b[0m: \n  - a\n  - c\n  - d\n"
+        )
 
-    @patch('gita.common.get_config_fname', return_value=GROUP_FNAME)
+    @patch("gita.common.get_config_fname", return_value=GROUP_FNAME)
     def test_ll_with_group(self, _, capfd):
         args = argparse.Namespace()
         args.to_group = None
         args.group_cmd = None
-        args.to_show = 'yy'
+        args.to_show = "yy"
         utils.get_groups.cache_clear()
         __main__.f_group(args)
         out, err = capfd.readouterr()
-        assert err == ''
-        assert 'a c d\n' == out
+        assert err == ""
+        assert "a c d\n" == out
 
-    @patch('gita.common.get_config_fname', return_value=GROUP_FNAME)
-    @patch('gita.utils.write_to_groups_file')
+    @patch("gita.common.get_config_fname", return_value=GROUP_FNAME)
+    @patch("gita.utils.write_to_groups_file")
     def test_rename(self, mock_write, _):
         args = argparse.Namespace()
-        args.gname = 'xx'
-        args.new_name = 'zz'
-        args.group_cmd = 'rename'
+        args.gname = "xx"
+        args.new_name = "zz"
+        args.group_cmd = "rename"
         utils.get_groups.cache_clear()
         __main__.f_group(args)
-        expected = {'yy': {'repos': ['a', 'c', 'd'], 'path': ''},
-                    'zz': {'repos': ['a', 'b'], 'path': ''}}
-        mock_write.assert_called_once_with(expected, 'w')
-
-    @patch('gita.info.get_color_encoding', return_value=info.default_colors)
-    @patch('gita.common.get_config_fname', return_value=GROUP_FNAME)
+        expected = {
+            "yy": {"repos": ["a", "c", "d"], "path": ""},
+            "zz": {"repos": ["a", "b"], "path": ""},
+        }
+        mock_write.assert_called_once_with(expected, "w")
+
+    @patch("gita.info.get_color_encoding", return_value=info.default_colors)
+    @patch("gita.common.get_config_fname", return_value=GROUP_FNAME)
     def test_rename_error(self, *_):
         utils.get_groups.cache_clear()
         with pytest.raises(SystemExit, match="1"):
-            __main__.main('group rename xx yy'.split())
-
-    @pytest.mark.parametrize('input, expected', [
-        ('xx', {'yy': {'repos': ['a', 'c', 'd'], 'path': ''}}),
-        ("xx yy", {}),
-    ])
-    @patch('gita.utils.get_repos', return_value={'a': '', 'b': '', 'c': '', 'd': ''})
-    @patch('gita.common.get_config_fname', return_value=GROUP_FNAME)
-    @patch('gita.utils.write_to_groups_file')
+            __main__.main("group rename xx yy".split())
+
+    @pytest.mark.parametrize(
+        "input, expected",
+        [
+            ("xx", {"yy": {"repos": ["a", "c", "d"], "path": ""}}),
+            ("xx yy", {}),
+        ],
+    )
+    @patch("gita.utils.get_repos", return_value={"a": "", "b": "", "c": "", "d": ""})
+    @patch("gita.common.get_config_fname", return_value=GROUP_FNAME)
+    @patch("gita.utils.write_to_groups_file")
     def test_rm(self, mock_write, _, __, input, expected):
         utils.get_groups.cache_clear()
-        args = ['group', 'rm'] + shlex.split(input)
+        args = ["group", "rm"] + shlex.split(input)
         __main__.main(args)
-        mock_write.assert_called_once_with(expected, 'w')
+        mock_write.assert_called_once_with(expected, "w")
 
-    @patch('gita.utils.get_repos', return_value={'a': '', 'b': '', 'c': '', 'd': ''})
-    @patch('gita.common.get_config_fname', return_value=GROUP_FNAME)
-    @patch('gita.utils.write_to_groups_file')
+    @patch("gita.utils.get_repos", return_value={"a": "", "b": "", "c": "", "d": ""})
+    @patch("gita.common.get_config_fname", return_value=GROUP_FNAME)
+    @patch("gita.utils.write_to_groups_file")
     def test_add(self, mock_write, *_):
         args = argparse.Namespace()
-        args.to_group =  ['a', 'c']
-        args.group_cmd = 'add'
-        args.gname = 'zz'
+        args.to_group = ["a", "c"]
+        args.group_cmd = "add"
+        args.gname = "zz"
         utils.get_groups.cache_clear()
         __main__.f_group(args)
         mock_write.assert_called_once_with(
-                {'zz': {'repos': ['a', 'c'], 'path': ''}}, 'a+')
+            {"zz": {"repos": ["a", "c"], "path": ""}}, "a+"
+        )
 
-    @patch('gita.utils.get_repos', return_value={'a': '', 'b': '', 'c': '', 'd': ''})
-    @patch('gita.common.get_config_fname', return_value=GROUP_FNAME)
-    @patch('gita.utils.write_to_groups_file')
+    @patch("gita.utils.get_repos", return_value={"a": "", "b": "", "c": "", "d": ""})
+    @patch("gita.common.get_config_fname", return_value=GROUP_FNAME)
+    @patch("gita.utils.write_to_groups_file")
     def test_add_to_existing(self, mock_write, *_):
         args = argparse.Namespace()
-        args.to_group =  ['a', 'c']
-        args.group_cmd = 'add'
-        args.gname = 'xx'
+        args.to_group = ["a", "c"]
+        args.group_cmd = "add"
+        args.gname = "xx"
         utils.get_groups.cache_clear()
         __main__.f_group(args)
         mock_write.assert_called_once_with(
-                {'xx': {'repos': ['a', 'b', 'c'], 'path': ''},
-                 'yy': {'repos': ['a', 'c', 'd'], 'path': ''}}, 'w')
-
-    @patch('gita.utils.get_repos', return_value={'a': '', 'b': '', 'c': '', 'd': ''})
-    @patch('gita.common.get_config_fname', return_value=GROUP_FNAME)
-    @patch('gita.utils.write_to_groups_file')
+            {
+                "xx": {"repos": ["a", "b", "c"], "path": ""},
+                "yy": {"repos": ["a", "c", "d"], "path": ""},
+            },
+            "w",
+        )
+
+    @patch("gita.utils.get_repos", return_value={"a": "", "b": "", "c": "", "d": ""})
+    @patch("gita.common.get_config_fname", return_value=GROUP_FNAME)
+    @patch("gita.utils.write_to_groups_file")
     def test_rm_repo(self, mock_write, *_):
         args = argparse.Namespace()
-        args.to_rm = ['a', 'c']
-        args.group_cmd = 'rmrepo'
-        args.gname = 'xx'
+        args.to_rm = ["a", "c"]
+        args.group_cmd = "rmrepo"
+        args.gname = "xx"
         utils.get_groups.cache_clear()
         __main__.f_group(args)
         mock_write.assert_called_once_with(
-                {'xx': {'repos': ['b'], 'path': ''},
-                 'yy': {'repos': ['a', 'c', 'd'], 'path': ''}}, 'w')
-
-    @patch('gita.common.get_config_fname')
+            {
+                "xx": {"repos": ["b"], "path": ""},
+                "yy": {"repos": ["a", "c", "d"], "path": ""},
+            },
+            "w",
+        )
+
+    @patch("gita.common.get_config_fname")
     def test_integration(self, mock_path_fname, tmp_path, capfd):
         def side_effect(input, _=None):
-            return tmp_path / f'{input}.csv'
+            return tmp_path / f"{input}.csv"
+
         mock_path_fname.side_effect = side_effect
 
-        __main__.main('add .'.split())
+        __main__.main("add .".split())
         utils.get_repos.cache_clear()
-        __main__.main('group add gita -n test'.split())
+        __main__.main("group add gita -n test".split())
         utils.get_groups.cache_clear()
-        __main__.main('ll test'.split())
+        __main__.main("ll test".split())
         out, err = capfd.readouterr()
-        assert err == ''
-        assert 'gita' in out
+        assert err == ""
+        assert "gita" in out
 
 
-@patch('gita.utils.is_git', return_value=True)
-@patch('gita.common.get_config_fname', return_value=PATH_FNAME)
-@patch('gita.utils.rename_repo')
+@patch("gita.utils.is_git", return_value=True)
+@patch("gita.common.get_config_fname", return_value=PATH_FNAME)
+@patch("gita.utils.rename_repo")
 def test_rename(mock_rename, _, __):
     utils.get_repos.cache_clear()
-    args = ['rename', 'repo1', 'abc']
+    args = ["rename", "repo1", "abc"]
     __main__.main(args)
     mock_rename.assert_called_once_with(
-            {'repo1': {'path': '/a/bcd/repo1', 'type': '', 'flags': []},
-                'xxx': {'path': '/a/b/c/repo3', 'type': '', 'flags': []},
-                'repo2': {'path': '/e/fgh/repo2', 'type': '', 'flags': []}},
-        'repo1', 'abc')
+        {
+            "repo1": {"path": "/a/bcd/repo1", "type": "", "flags": []},
+            "xxx": {"path": "/a/b/c/repo3", "type": "", "flags": []},
+            "repo2": {"path": "/e/fgh/repo2", "type": "", "flags": []},
+        },
+        "repo1",
+        "abc",
+    )
 
 
 class TestInfo:
-
-    @patch('gita.common.get_config_fname', return_value='')
+    @patch("gita.common.get_config_fname", return_value="")
     def test_ll(self, _, capfd):
         args = argparse.Namespace()
         args.info_cmd = None
         __main__.f_info(args)
         out, err = capfd.readouterr()
-        assert 'In use: branch,commit_msg,commit_time\nUnused: path\n' == out
-        assert err == ''
+        assert "In use: branch,commit_msg,commit_time\nUnused: path\n" == out
+        assert err == ""
 
-    @patch('gita.common.get_config_fname')
+    @patch("gita.common.get_config_fname")
     def test_add(self, mock_get_fname, tmpdir):
         args = argparse.Namespace()
-        args.info_cmd = 'add'
-        args.info_item = 'path'
+        args.info_cmd = "add"
+        args.info_item = "path"
         with tmpdir.as_cwd():
-            csv_config = Path.cwd() / 'info.csv'
+            csv_config = Path.cwd() / "info.csv"
             mock_get_fname.return_value = csv_config
             __main__.f_info(args)
             items = info.get_info_items()
-        assert items == ['branch', 'commit_msg', 'commit_time', 'path']
+        assert items == ["branch", "commit_msg", "commit_time", "path"]
 
-    @patch('gita.common.get_config_fname')
+    @patch("gita.common.get_config_fname")
     def test_rm(self, mock_get_fname, tmpdir):
         args = argparse.Namespace()
-        args.info_cmd = 'rm'
-        args.info_item = 'commit_msg'
+        args.info_cmd = "rm"
+        args.info_item = "commit_msg"
         with tmpdir.as_cwd():
-            csv_config = Path.cwd() / 'info.csv'
+            csv_config = Path.cwd() / "info.csv"
             mock_get_fname.return_value = csv_config
             __main__.f_info(args)
             items = info.get_info_items()
-        assert items == ['branch', 'commit_time']
+        assert items == ["branch", "commit_time"]
 
 
-@patch('gita.common.get_config_fname')
+@patch("gita.common.get_config_fname")
 def test_set_color(mock_get_fname, tmpdir):
-        args = argparse.Namespace()
-        args.color_cmd = 'set'
-        args.color = 'b_white'
-        args.situation = 'no-remote'
-        with tmpdir.as_cwd():
-            csv_config = Path.cwd() / 'colors.csv'
-            mock_get_fname.return_value = csv_config
-            __main__.f_color(args)
+    args = argparse.Namespace()
+    args.color_cmd = "set"
+    args.color = "b_white"
+    args.situation = "no-remote"
+    with tmpdir.as_cwd():
+        csv_config = Path.cwd() / "colors.csv"
+        mock_get_fname.return_value = csv_config
+        __main__.f_color(args)
 
-            info.get_color_encoding.cache_clear()  # avoid side effect
-            items = info.get_color_encoding()
         info.get_color_encoding.cache_clear()  # avoid side effect
-        assert items == {'no-remote': 'b_white', 'in-sync': 'green',
-                'diverged': 'red', 'local-ahead': 'purple',
-                'remote-ahead': 'yellow'}
+        items = info.get_color_encoding()
+    info.get_color_encoding.cache_clear()  # avoid side effect
+    assert items == {
+        "no-remote": "b_white",
+        "in-sync": "green",
+        "diverged": "red",
+        "local-ahead": "purple",
+        "remote-ahead": "yellow",
+    }
+
+
+@pytest.mark.parametrize(
+    "input, expected",
+    [
+        ({"repo1": {"path": "/a/"}, "repo2": {"path": "/b/"}}, ""),
+    ],
+)
+@patch("gita.utils.write_to_groups_file")
+@patch("gita.utils.write_to_repo_file")
+@patch("gita.utils.get_repos")
+def test_clear(
+    mock_repos,
+    mock_write_to_repo_file,
+    mock_write_to_groups_file,
+    input,
+    expected,
+    capfd,
+):
+    mock_repos.return_value = input
+    __main__.main(["clear"])
+    assert mock_write_to_repo_file.call_count == 1
+    mock_write_to_repo_file.assert_called_once_with({}, "w")
+    assert mock_write_to_groups_file.call_count == 1
+    mock_write_to_groups_file.assert_called_once_with({}, "w")
+    out, err = capfd.readouterr()
+    assert err == ""
+    assert out == expected