.pylintrc

@@ -82,7 +82,6 @@ limit-inference-results=100
 # List of plugins (as comma separated values of python module names) to load,
 # usually to register additional checkers.
 load-plugins=pylint.extensions.docparams,
-             pylint.extensions.bad_builtin,
              definition_order,
              import_order,
 
@@ -132,8 +131,6 @@ attr-naming-style=snake_case
 # style.
 #attr-rgx=
 
-bad-functions=print,
-
 # Bad variable names which should always be refused, separated by a comma.
 bad-names=foo,
           bar,

src/ahriman/application/handlers/patch.py

@@ -98,7 +98,6 @@ class Patch(Handler):
             PkgbuildPatch: created patch for the PKGBUILD function
         """
         if patch_path is None:
-            # pylint: disable=bad-builtin
             print("Post new function or variable value below. Press Ctrl-D to finish:", file=sys.stderr)
             patch = "".join(list(sys.stdin))
         else:

src/ahriman/application/handlers/update.py

@@ -77,5 +77,5 @@ class Update(Handler):
             Callable[[str], None]: in case if dry_run is set it will return print, logger otherwise
         """
         def inner(line: str) -> None:
-            return print(line) if dry_run else application.logger.info(line)  # pylint: disable=bad-builtin
+            return print(line) if dry_run else application.logger.info(line)
         return inner

src/ahriman/core/build_tools/sources.py

@@ -19,7 +19,6 @@
 #
 import shutil
 
-from collections.abc import Generator
 from pathlib import Path
 
 from ahriman.core.exceptions import CalledProcessError
@@ -39,14 +38,10 @@ class Sources(LazyLogging):
         DEFAULT_BRANCH(str): (class attribute) default branch to process git repositories.
             Must be used only for local stored repositories, use RemoteSource descriptor instead for real packages
         DEFAULT_COMMIT_AUTHOR(tuple[str, str]): (class attribute) default commit author to be used if none set
-        GITCONFIG(dict[str, str]): (class attribute) git config options to suppress annoying hints
     """
 
     DEFAULT_BRANCH = "master"  # default fallback branch
     DEFAULT_COMMIT_AUTHOR = ("ahriman", "ahriman@localhost")
-    GITCONFIG = {
-        "init.defaultBranch": DEFAULT_BRANCH,
-    }
 
     @staticmethod
     def changes(source_dir: Path, last_commit_sha: str | None) -> str | None:
@@ -111,15 +106,15 @@ class Sources(LazyLogging):
             instance.fetch_until(sources_dir, branch=branch)
         elif remote.git_url is not None:
             instance.logger.info("clone remote %s to %s using branch %s", remote.git_url, sources_dir, branch)
-            check_output(*instance.git(), "clone", "--quiet", "--depth", "1", "--branch", branch, "--single-branch",
+            check_output("git", "clone", "--quiet", "--depth", "1", "--branch", branch, "--single-branch",
                          remote.git_url, str(sources_dir), cwd=sources_dir.parent, logger=instance.logger)
         else:
             # it will cause an exception later
             instance.logger.error("%s is not initialized, but no remote provided", sources_dir)
 
         # and now force reset to our branch
-        check_output(*instance.git(), "checkout", "--force", branch, cwd=sources_dir, logger=instance.logger)
-        check_output(*instance.git(), "reset", "--quiet", "--hard", f"origin/{branch}",
+        check_output("git", "checkout", "--force", branch, cwd=sources_dir, logger=instance.logger)
+        check_output("git", "reset", "--quiet", "--hard", f"origin/{branch}",
                      cwd=sources_dir, logger=instance.logger)
 
         # move content if required
@@ -141,7 +136,7 @@ class Sources(LazyLogging):
             bool: True in case if there is any remote and false otherwise
         """
         instance = Sources()
-        remotes = check_output(*instance.git(), "remote", cwd=sources_dir, logger=instance.logger)
+        remotes = check_output("git", "remote", cwd=sources_dir, logger=instance.logger)
         return bool(remotes)
 
     @staticmethod
@@ -155,7 +150,7 @@ class Sources(LazyLogging):
         instance = Sources()
         if not (sources_dir / ".git").is_dir():
             # skip initializing in case if it was already
-            check_output(*instance.git(), "init", "--quiet", "--initial-branch", instance.DEFAULT_BRANCH,
+            check_output("git", "init", "--quiet", "--initial-branch", instance.DEFAULT_BRANCH,
                          cwd=sources_dir, logger=instance.logger)
 
         # extract local files...
@@ -225,7 +220,7 @@ class Sources(LazyLogging):
             return  # no changes to push, just skip action
 
         git_url, branch = remote.git_source()
-        check_output(*instance.git(), "push", "--quiet", git_url, branch, cwd=sources_dir, logger=instance.logger)
+        check_output("git", "push", "--quiet", git_url, branch, cwd=sources_dir, logger=instance.logger)
 
     def add(self, sources_dir: Path, *pattern: str, intent_to_add: bool = False) -> None:
         """
@@ -246,7 +241,7 @@ class Sources(LazyLogging):
         self.logger.info("found matching files %s", found_files)
         # add them to index
         args = ["--intent-to-add"] if intent_to_add else []
-        check_output(*self.git(), "add", *args, *[str(fn.relative_to(sources_dir)) for fn in found_files],
+        check_output("git", "add", *args, *[str(fn.relative_to(sources_dir)) for fn in found_files],
                      cwd=sources_dir, logger=self.logger)
 
     def commit(self, sources_dir: Path, message: str | None = None,
@@ -269,16 +264,15 @@ class Sources(LazyLogging):
         if message is None:
             message = f"Autogenerated commit at {utcnow()}"
         args = ["--message", message]
+        environment: dict[str, str] = {}
 
         if commit_author is None:
             commit_author = self.DEFAULT_COMMIT_AUTHOR
         user, email = commit_author
-        gitconfig = {
-            "user.email": email,
-            "user.name": user,
-        }
+        environment["GIT_AUTHOR_NAME"] = environment["GIT_COMMITTER_NAME"] = user
+        environment["GIT_AUTHOR_EMAIL"] = environment["GIT_COMMITTER_EMAIL"] = email
 
-        check_output(*self.git(gitconfig), "commit", "--quiet", *args, cwd=sources_dir, logger=self.logger)
+        check_output("git", "commit", "--quiet", *args, cwd=sources_dir, logger=self.logger, environment=environment)
 
         return True
 
@@ -296,7 +290,7 @@ class Sources(LazyLogging):
         args = []
         if sha is not None:
             args.append(sha)
-        return check_output(*self.git(), "diff", *args, cwd=sources_dir, logger=self.logger)
+        return check_output("git", "diff", *args, cwd=sources_dir, logger=self.logger)
 
     def fetch_until(self, sources_dir: Path, *, branch: str | None = None, commit_sha: str | None = None) -> None:
         """
@@ -312,37 +306,18 @@ class Sources(LazyLogging):
 
         commits_count = 1
         while commit_sha is not None:
-            command = self.git() + ["fetch", "--quiet", "--depth", str(commits_count)]
+            command = ["git", "fetch", "--quiet", "--depth", str(commits_count)]
             if branch is not None:
                 command += ["origin", branch]
             check_output(*command, cwd=sources_dir, logger=self.logger)  # fetch one more level
 
             try:
                 # check if there is an object in current git directory
-                check_output(*self.git(), "cat-file", "-e", commit_sha, cwd=sources_dir, logger=self.logger)
+                check_output("git", "cat-file", "-e", commit_sha, cwd=sources_dir, logger=self.logger)
                 commit_sha = None  # reset search
             except CalledProcessError:
                 commits_count += 1  # increase depth
 
-    def git(self, gitconfig: dict[str, str] | None = None) -> list[str]:
-        """
-        git command prefix
-
-        Args:
-            gitconfig(dict[str, str] | None, optional): additional git config flags if any (Default value = None)
-
-        Returns:
-            list[str]: git command prefix with valid default flags
-        """
-        gitconfig = gitconfig or {}
-
-        def configuration_flags() -> Generator[str, None, None]:
-            for option, value in (self.GITCONFIG | gitconfig).items():
-                yield "-c"
-                yield f"{option}=\"{value}\""
-
-        return ["git"] + list(configuration_flags())
-
     def has_changes(self, sources_dir: Path) -> bool:
         """
         check if there are changes in current git tree
@@ -354,7 +329,7 @@ class Sources(LazyLogging):
             bool: True if there are uncommitted changes and False otherwise
         """
         # there is --exit-code argument to diff, however, there might be other process errors
-        changes = check_output(*self.git(), "diff", "--cached", "--name-only", cwd=sources_dir, logger=self.logger)
+        changes = check_output("git", "diff", "--cached", "--name-only", cwd=sources_dir, logger=self.logger)
         return bool(changes)
 
     def head(self, sources_dir: Path, ref_name: str = "HEAD") -> str:
@@ -369,7 +344,7 @@ class Sources(LazyLogging):
             str: HEAD commit hash
         """
         # we might want to parse git files instead though
-        return check_output(*self.git(), "rev-parse", ref_name, cwd=sources_dir, logger=self.logger)
+        return check_output("git", "rev-parse", ref_name, cwd=sources_dir, logger=self.logger)
 
     def move(self, pkgbuild_dir: Path, sources_dir: Path) -> None:
         """
@@ -397,7 +372,7 @@ class Sources(LazyLogging):
         # create patch
         self.logger.info("apply patch %s from database at %s", patch.key, sources_dir)
         if patch.is_plain_diff:
-            check_output(*self.git(), "apply", "--ignore-space-change", "--ignore-whitespace",
+            check_output("git", "apply", "--ignore-space-change", "--ignore-whitespace",
                          cwd=sources_dir, input_data=patch.serialize(), logger=self.logger)
         else:
             patch.write(sources_dir / "PKGBUILD")

src/ahriman/models/waiter.py

@@ -67,7 +67,7 @@ class WaiterTaskFinished(WaiterResult):
         indicates whether the waiter completed with success or not
 
         Returns:
-            Literal[True]: always ``True``
+            Literal[True]: always False
         """
         return True
 
@@ -82,7 +82,7 @@ class WaiterTimedOut(WaiterResult):
         indicates whether the waiter completed with success or not
 
         Returns:
-            Literal[False]: always ``False``
+            Literal[False]: always False
         """
         return False
 
@@ -108,7 +108,7 @@ class Waiter:
         check if timer is out
 
         Returns:
-            bool: ``True`` in case current monotonic time is more than :attr:`start_time` and :attr:`wait_timeout`
+            bool: True in case current monotonic time is more than :attr:`start_time` and :attr:`wait_timeout`
             doesn't equal to 0
         """
         since_start = time.monotonic() - self.start_time
@@ -124,7 +124,7 @@ class Waiter:
             **kwargs(Params.kwargs): keyword arguments for check call
 
         Returns:
-            WaiterResult: waiter result object
+            WaiterResult: consumed time in seconds
         """
         while not (timed_out := self.is_timed_out()) and in_progress(*args, **kwargs):
             time.sleep(self.interval)

tests/ahriman/core/build_tools/test_sources.py

@@ -74,7 +74,7 @@ def test_fetch_empty(remote_source: RemoteSource, mocker: MockerFixture) -> None
     check_output_mock.assert_not_called()
 
 
-def test_fetch_existing(sources: Sources, remote_source: RemoteSource, mocker: MockerFixture) -> None:
+def test_fetch_existing(remote_source: RemoteSource, mocker: MockerFixture) -> None:
     """
     must fetch new package via fetch command
     """
@@ -86,19 +86,18 @@ def test_fetch_existing(sources: Sources, remote_source: RemoteSource, mocker: M
     head_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.head", return_value="sha")
 
     local = Path("local")
-    assert sources.fetch(local, remote_source) == "sha"
+    assert Sources.fetch(local, remote_source) == "sha"
     fetch_mock.assert_called_once_with(local, branch=remote_source.branch)
     check_output_mock.assert_has_calls([
-        MockCall(*sources.git(), "checkout", "--force", remote_source.branch,
-                 cwd=local, logger=pytest.helpers.anyvar(int)),
-        MockCall(*sources.git(), "reset", "--quiet", "--hard", f"origin/{remote_source.branch}",
+        MockCall("git", "checkout", "--force", remote_source.branch, cwd=local, logger=pytest.helpers.anyvar(int)),
+        MockCall("git", "reset", "--quiet", "--hard", f"origin/{remote_source.branch}",
                  cwd=local, logger=pytest.helpers.anyvar(int)),
     ])
     move_mock.assert_called_once_with(local.resolve(), local)
     head_mock.assert_called_once_with(local)
 
 
-def test_fetch_new(sources: Sources, remote_source: RemoteSource, mocker: MockerFixture) -> None:
+def test_fetch_new(remote_source: RemoteSource, mocker: MockerFixture) -> None:
     """
     must fetch new package via clone command
     """
@@ -108,21 +107,19 @@ def test_fetch_new(sources: Sources, remote_source: RemoteSource, mocker: Mocker
     head_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.head", return_value="sha")
 
     local = Path("local")
-    assert sources.fetch(local, remote_source) == "sha"
+    assert Sources.fetch(local, remote_source) == "sha"
     check_output_mock.assert_has_calls([
-        MockCall(*sources.git(), "clone", "--quiet", "--depth", "1", "--branch", remote_source.branch,
-                 "--single-branch", remote_source.git_url, str(local),
-                 cwd=local.parent, logger=pytest.helpers.anyvar(int)),
-        MockCall(*sources.git(), "checkout", "--force", remote_source.branch,
-                 cwd=local, logger=pytest.helpers.anyvar(int)),
-        MockCall(*sources.git(), "reset", "--quiet", "--hard", f"origin/{remote_source.branch}",
+        MockCall("git", "clone", "--quiet", "--depth", "1", "--branch", remote_source.branch, "--single-branch",
+                 remote_source.git_url, str(local), cwd=local.parent, logger=pytest.helpers.anyvar(int)),
+        MockCall("git", "checkout", "--force", remote_source.branch, cwd=local, logger=pytest.helpers.anyvar(int)),
+        MockCall("git", "reset", "--quiet", "--hard", f"origin/{remote_source.branch}",
                  cwd=local, logger=pytest.helpers.anyvar(int))
     ])
     move_mock.assert_called_once_with(local.resolve(), local)
     head_mock.assert_called_once_with(local)
 
 
-def test_fetch_new_without_remote(sources: Sources, mocker: MockerFixture) -> None:
+def test_fetch_new_without_remote(mocker: MockerFixture) -> None:
     """
     must fetch nothing in case if no remote set
     """
@@ -132,11 +129,10 @@ def test_fetch_new_without_remote(sources: Sources, mocker: MockerFixture) -> No
     head_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.head", return_value="sha")
 
     local = Path("local")
-    assert sources.fetch(local, RemoteSource(source=PackageSource.Archive)) == "sha"
+    assert Sources.fetch(local, RemoteSource(source=PackageSource.Archive)) == "sha"
     check_output_mock.assert_has_calls([
-        MockCall(*sources.git(), "checkout", "--force", sources.DEFAULT_BRANCH,
-                 cwd=local, logger=pytest.helpers.anyvar(int)),
-        MockCall(*sources.git(), "reset", "--quiet", "--hard", f"origin/{sources.DEFAULT_BRANCH}",
+        MockCall("git", "checkout", "--force", Sources.DEFAULT_BRANCH, cwd=local, logger=pytest.helpers.anyvar(int)),
+        MockCall("git", "reset", "--quiet", "--hard", f"origin/{Sources.DEFAULT_BRANCH}",
                  cwd=local, logger=pytest.helpers.anyvar(int))
     ])
     move_mock.assert_called_once_with(local.resolve(), local)
@@ -157,15 +153,15 @@ def test_fetch_relative(remote_source: RemoteSource, mocker: MockerFixture) -> N
     head_mock.assert_called_once_with(local)
 
 
-def test_has_remotes(sources: Sources, mocker: MockerFixture) -> None:
+def test_has_remotes(mocker: MockerFixture) -> None:
     """
     must ask for remotes
     """
     check_output_mock = mocker.patch("ahriman.core.build_tools.sources.check_output", return_value="origin")
 
     local = Path("local")
-    assert sources.has_remotes(local)
-    check_output_mock.assert_called_once_with(*sources.git(), "remote", cwd=local, logger=pytest.helpers.anyvar(int))
+    assert Sources.has_remotes(local)
+    check_output_mock.assert_called_once_with("git", "remote", cwd=local, logger=pytest.helpers.anyvar(int))
 
 
 def test_has_remotes_empty(mocker: MockerFixture) -> None:
@@ -176,7 +172,7 @@ def test_has_remotes_empty(mocker: MockerFixture) -> None:
     assert not Sources.has_remotes(Path("local"))
 
 
-def test_init(sources: Sources, mocker: MockerFixture) -> None:
+def test_init(mocker: MockerFixture) -> None:
     """
     must create empty repository at the specified path
     """
@@ -187,9 +183,9 @@ def test_init(sources: Sources, mocker: MockerFixture) -> None:
     commit_mock = mocker.patch("ahriman.core.build_tools.sources.Sources.commit")
 
     local = Path("local")
-    sources.init(local)
-    check_output_mock.assert_called_once_with(*sources.git(), "init", "--quiet", "--initial-branch",
-                                              sources.DEFAULT_BRANCH, cwd=local, logger=pytest.helpers.anyvar(int))
+    Sources.init(local)
+    check_output_mock.assert_called_once_with("git", "init", "--quiet", "--initial-branch", Sources.DEFAULT_BRANCH,
+                                              cwd=local, logger=pytest.helpers.anyvar(int))
     add_mock.assert_called_once_with(local, "PKGBUILD", ".SRCINFO", "local")
     commit_mock.assert_called_once_with(local)
 
@@ -271,7 +267,7 @@ def test_patch_create_with_newline(mocker: MockerFixture) -> None:
     assert Sources.patch_create(Path("local"), "glob").endswith("\n")
 
 
-def test_push(package_ahriman: Package, sources: Sources, mocker: MockerFixture) -> None:
+def test_push(package_ahriman: Package, mocker: MockerFixture) -> None:
     """
     must correctly push files to remote repository
     """
@@ -281,11 +277,11 @@ def test_push(package_ahriman: Package, sources: Sources, mocker: MockerFixture)
 
     commit_author = ("commit author", "user@host")
     local = Path("local")
-    sources.push(local, package_ahriman.remote, "glob", commit_author=commit_author)
+    Sources.push(local, package_ahriman.remote, "glob", commit_author=commit_author)
     add_mock.assert_called_once_with(local, "glob")
     commit_mock.assert_called_once_with(local, commit_author=commit_author)
     check_output_mock.assert_called_once_with(
-        *sources.git(), "push", "--quiet", package_ahriman.remote.git_url, package_ahriman.remote.branch,
+        "git", "push", "--quiet", package_ahriman.remote.git_url, package_ahriman.remote.branch,
         cwd=local, logger=pytest.helpers.anyvar(int))
 
 
@@ -312,7 +308,7 @@ def test_add(sources: Sources, mocker: MockerFixture) -> None:
     sources.add(local, "pattern1", "pattern2")
     glob_mock.assert_has_calls([MockCall("pattern1"), MockCall("pattern2")])
     check_output_mock.assert_called_once_with(
-        *sources.git(), "add", "1", "2", "1", "2", cwd=local, logger=sources.logger
+        "git", "add", "1", "2", "1", "2", cwd=local, logger=sources.logger
     )
 
 
@@ -327,7 +323,7 @@ def test_add_intent_to_add(sources: Sources, mocker: MockerFixture) -> None:
     sources.add(local, "pattern1", "pattern2", intent_to_add=True)
     glob_mock.assert_has_calls([MockCall("pattern1"), MockCall("pattern2")])
     check_output_mock.assert_called_once_with(
-        *sources.git(), "add", "--intent-to-add", "1", "2", "1", "2", cwd=local, logger=sources.logger
+        "git", "add", "--intent-to-add", "1", "2", "1", "2", cwd=local, logger=sources.logger
     )
 
 
@@ -354,8 +350,13 @@ def test_commit(sources: Sources, mocker: MockerFixture) -> None:
     user, email = sources.DEFAULT_COMMIT_AUTHOR
     assert sources.commit(local, message=message)
     check_output_mock.assert_called_once_with(
-        *sources.git(), "-c", f"user.email=\"{email}\"", "-c", f"user.name=\"{user}\"",
-        "commit", "--quiet", "--message", message, cwd=local, logger=sources.logger
+        "git", "commit", "--quiet", "--message", message,
+        cwd=local, logger=sources.logger, environment={
+            "GIT_AUTHOR_NAME": user,
+            "GIT_AUTHOR_EMAIL": email,
+            "GIT_COMMITTER_NAME": user,
+            "GIT_COMMITTER_EMAIL": email,
+        }
     )
 
 
@@ -382,8 +383,13 @@ def test_commit_author(sources: Sources, mocker: MockerFixture) -> None:
     user, email = author = ("commit author", "user@host")
     assert sources.commit(Path("local"), message=message, commit_author=author)
     check_output_mock.assert_called_once_with(
-        *sources.git(), "-c", f"user.email=\"{email}\"", "-c", f"user.name=\"{user}\"",
-        "commit", "--quiet", "--message", message, cwd=local, logger=sources.logger
+        "git", "commit", "--quiet", "--message", message,
+        cwd=local, logger=sources.logger, environment={
+            "GIT_AUTHOR_NAME": user,
+            "GIT_AUTHOR_EMAIL": email,
+            "GIT_COMMITTER_NAME": user,
+            "GIT_COMMITTER_EMAIL": email,
+        }
     )
 
 
@@ -398,8 +404,13 @@ def test_commit_autogenerated_message(sources: Sources, mocker: MockerFixture) -
     assert sources.commit(Path("local"))
     user, email = sources.DEFAULT_COMMIT_AUTHOR
     check_output_mock.assert_called_once_with(
-        *sources.git(), "-c", f"user.email=\"{email}\"", "-c", f"user.name=\"{user}\"",
-        "commit", "--quiet", "--message", pytest.helpers.anyvar(str, strict=True), cwd=local, logger=sources.logger
+        "git", "commit", "--quiet", "--message", pytest.helpers.anyvar(str, strict=True),
+        cwd=local, logger=sources.logger, environment={
+            "GIT_AUTHOR_NAME": user,
+            "GIT_AUTHOR_EMAIL": email,
+            "GIT_COMMITTER_NAME": user,
+            "GIT_COMMITTER_EMAIL": email,
+        }
     )
 
 
@@ -411,7 +422,7 @@ def test_diff(sources: Sources, mocker: MockerFixture) -> None:
 
     local = Path("local")
     assert sources.diff(local)
-    check_output_mock.assert_called_once_with(*sources.git(), "diff", cwd=local, logger=sources.logger)
+    check_output_mock.assert_called_once_with("git", "diff", cwd=local, logger=sources.logger)
 
 
 def test_diff_specific(sources: Sources, mocker: MockerFixture) -> None:
@@ -422,7 +433,7 @@ def test_diff_specific(sources: Sources, mocker: MockerFixture) -> None:
 
     local = Path("local")
     assert sources.diff(local, "hash")
-    check_output_mock.assert_called_once_with(*sources.git(), "diff", "hash", cwd=local, logger=sources.logger)
+    check_output_mock.assert_called_once_with("git", "diff", "hash", cwd=local, logger=sources.logger)
 
 
 def test_fetch_until(sources: Sources, mocker: MockerFixture) -> None:
@@ -439,12 +450,10 @@ def test_fetch_until(sources: Sources, mocker: MockerFixture) -> None:
     local = Path("local")
     sources.fetch_until(local, branch="master", commit_sha="sha")
     check_output_mock.assert_has_calls([
-        MockCall(*sources.git(), "fetch", "--quiet", "--depth", "1", "origin", "master",
-                 cwd=local, logger=sources.logger),
-        MockCall(*sources.git(), "cat-file", "-e", "sha", cwd=local, logger=sources.logger),
-        MockCall(*sources.git(), "fetch", "--quiet", "--depth", "2", "origin", "master",
-                 cwd=local, logger=sources.logger),
-        MockCall(*sources.git(), "cat-file", "-e", "sha", cwd=local, logger=sources.logger),
+        MockCall("git", "fetch", "--quiet", "--depth", "1", "origin", "master", cwd=local, logger=sources.logger),
+        MockCall("git", "cat-file", "-e", "sha", cwd=local, logger=sources.logger),
+        MockCall("git", "fetch", "--quiet", "--depth", "2", "origin", "master", cwd=local, logger=sources.logger),
+        MockCall("git", "cat-file", "-e", "sha", cwd=local, logger=sources.logger),
     ])
 
 
@@ -457,9 +466,8 @@ def test_fetch_until_first(sources: Sources, mocker: MockerFixture) -> None:
     local = Path("local")
     sources.fetch_until(local, branch="master")
     check_output_mock.assert_has_calls([
-        MockCall(*sources.git(), "fetch", "--quiet", "--depth", "1", "origin", "master",
-                 cwd=local, logger=sources.logger),
-        MockCall(*sources.git(), "cat-file", "-e", "HEAD", cwd=local, logger=sources.logger),
+        MockCall("git", "fetch", "--quiet", "--depth", "1", "origin", "master", cwd=local, logger=sources.logger),
+        MockCall("git", "cat-file", "-e", "HEAD", cwd=local, logger=sources.logger),
     ])
 
 
@@ -472,27 +480,11 @@ def test_fetch_until_all_branches(sources: Sources, mocker: MockerFixture) -> No
     local = Path("local")
     sources.fetch_until(local)
     check_output_mock.assert_has_calls([
-        MockCall(*sources.git(), "fetch", "--quiet", "--depth", "1", cwd=local, logger=sources.logger),
-        MockCall(*sources.git(), "cat-file", "-e", "HEAD", cwd=local, logger=sources.logger),
+        MockCall("git", "fetch", "--quiet", "--depth", "1", cwd=local, logger=sources.logger),
+        MockCall("git", "cat-file", "-e", "HEAD", cwd=local, logger=sources.logger),
     ])
 
 
-def test_git(sources: Sources) -> None:
-    """
-    must correctly generate git command
-    """
-    assert sources.git() == ["git", "-c", "init.defaultBranch=\"master\""]
-
-
-def test_git_overrides(sources: Sources) -> None:
-    """
-    must correctly generate git command with additional settings
-    """
-    assert sources.git({"user.email": "ahriman@localhost"}) == [
-        "git", "-c", "init.defaultBranch=\"master\"", "-c", "user.email=\"ahriman@localhost\""
-    ]
-
-
 def test_has_changes(sources: Sources, mocker: MockerFixture) -> None:
     """
     must correctly identify if there are changes
@@ -501,12 +493,12 @@ def test_has_changes(sources: Sources, mocker: MockerFixture) -> None:
 
     check_output_mock = mocker.patch("ahriman.core.build_tools.sources.check_output", return_value="M a.txt")
     assert sources.has_changes(local)
-    check_output_mock.assert_called_once_with(*sources.git(), "diff", "--cached", "--name-only",
+    check_output_mock.assert_called_once_with("git", "diff", "--cached", "--name-only",
                                               cwd=local, logger=sources.logger)
 
     check_output_mock = mocker.patch("ahriman.core.build_tools.sources.check_output", return_value="")
     assert not sources.has_changes(local)
-    check_output_mock.assert_called_once_with(*sources.git(), "diff", "--cached", "--name-only",
+    check_output_mock.assert_called_once_with("git", "diff", "--cached", "--name-only",
                                               cwd=local, logger=sources.logger)
 
 
@@ -518,7 +510,7 @@ def test_head(sources: Sources, mocker: MockerFixture) -> None:
     local = Path("local")
 
     assert sources.head(local) == "sha"
-    check_output_mock.assert_called_once_with(*sources.git(), "rev-parse", "HEAD", cwd=local, logger=sources.logger)
+    check_output_mock.assert_called_once_with("git", "rev-parse", "HEAD", cwd=local, logger=sources.logger)
 
 
 def test_head_specific(sources: Sources, mocker: MockerFixture) -> None:
@@ -529,7 +521,7 @@ def test_head_specific(sources: Sources, mocker: MockerFixture) -> None:
     local = Path("local")
 
     assert sources.head(local, "master") == "sha"
-    check_output_mock.assert_called_once_with(*sources.git(), "rev-parse", "master", cwd=local, logger=sources.logger)
+    check_output_mock.assert_called_once_with("git", "rev-parse", "master", cwd=local, logger=sources.logger)
 
 
 def test_move(sources: Sources, mocker: MockerFixture) -> None:
@@ -562,7 +554,7 @@ def test_patch_apply(sources: Sources, mocker: MockerFixture) -> None:
     local = Path("local")
     sources.patch_apply(local, patch)
     check_output_mock.assert_called_once_with(
-        *sources.git(), "apply", "--ignore-space-change", "--ignore-whitespace",
+        "git", "apply", "--ignore-space-change", "--ignore-whitespace",
         cwd=local, input_data=patch.value, logger=sources.logger
     )