From dd42e38f5201ff6858c6b787fa8dab16c6cbc7a9 Mon Sep 17 00:00:00 2001 From: Eliah Kagan Date: Thu, 15 Feb 2024 09:35:15 -0500 Subject: [PATCH] Keep temp files out of project dir and improve cleanup This fixes a test bug in TestTree.test_tree_modifier_ordering where: - A `tmp` subdirectory of the directory the tests are run from (almost always the root of the GitPython source tree) was created, instead of creating it in /tmp or elsewhere configured. - That directory was never deleted afterward, creating new untracked files in GitPython's own working tree, and also making it so running the tests twice would always fail the second time, unless a manual intervening deletion was performed. (This had not broken CI, since CI checks clone the repository anew each time.) - The directory was changed into to set up the test, but not deterministically changed back out of. It would typically be exited, but this was not guaranteed to occur if some subprocess commands were to fail unexpectedly. In addition to fixing all three aspects of that bug, this also: - Remains in the temporary directory only as long as necessary to execute the subprocesses in it that produce the expected value for the test (including not entering it until running them). - Deletes the temporary directory immediately after exiting it, since it is only used to produce a file list to compare to. - Avoids interleaving file creation and git subprocess commands, since doing so made it harder to understand what was being set up and since the difference is not relevant to the test. - Does the work in that temporary directory before performing any operations with the code under test, because it is conceptually an "arrange" step, and because doing so makes its limited purpose clearer on reading the tests. - Some other refactoring to support the fixes and accompanying changes, including extracting the temporary directory logic to a helper method. This deliberately does not change the order in which any files are created. It also keeps the approach of using subprocess functions directly to operate on the temporary git repository (and changing directory while doing so, keeping each of the commands the same), since there might be good reasons to do this, such as to make very clear that the file order being obtained to compare to is really coming from git itself. Even if this is to be changed, it seems outside the scope of this bugfix. The test still fails if the fix to git/objects/tree.py from 365d44f (#1799) is absent. This was verified by running: git revert --no-commit 365d44f50a3d72d7ebfa063b142d2abd4082cfaa pytest --no-cov -vv test/test_tree.py git revert --abort --- test/test_tree.py | 54 ++++++++++++++++++++++++++++------------------- 1 file changed, 32 insertions(+), 22 deletions(-) diff --git a/test/test_tree.py b/test/test_tree.py index 695cb803e..b44392e15 100644 --- a/test/test_tree.py +++ b/test/test_tree.py @@ -4,14 +4,15 @@ # 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/ from io import BytesIO +import os.path as osp +from pathlib import Path +import subprocess +import tempfile from git.objects import Tree, Blob +from git.util import cwd from test.lib import TestBase -import os -import os.path as osp -import subprocess - class TestTree(TestBase): def test_serializable(self): @@ -42,29 +43,41 @@ def test_serializable(self): testtree._deserialize(stream) # END for each item in tree - def test_tree_modifier_ordering(self): - def setup_git_repository_and_get_ordered_files(): - os.mkdir("tmp") - os.chdir("tmp") - subprocess.run(["git", "init", "-q"], check=True) - os.mkdir("file") - for filename in [ + @staticmethod + def _get_git_ordered_files(): + """Get files as git orders them, to compare in test_tree_modifier_ordering.""" + with tempfile.TemporaryDirectory() as tdir: + # Create directory contents. + Path(tdir, "file").mkdir() + for filename in ( "bin", "bin.d", "file.to", "file.toml", "file.toml.bin", "file0", - "file/a", - ]: - open(filename, "a").close() - - subprocess.run(["git", "add", "."], check=True) - subprocess.run(["git", "commit", "-m", "c1"], check=True) - tree_hash = subprocess.check_output(["git", "rev-parse", "HEAD^{tree}"]).decode().strip() - cat_file_output = subprocess.check_output(["git", "cat-file", "-p", tree_hash]).decode() + ): + Path(tdir, filename).touch() + Path(tdir, "file", "a").touch() + + with cwd(tdir): + # Prepare the repository. + subprocess.run(["git", "init", "-q"], check=True) + subprocess.run(["git", "add", "."], check=True) + subprocess.run(["git", "commit", "-m", "c1"], check=True) + + # Get git output from which an ordered file list can be parsed. + rev_parse_command = ["git", "rev-parse", "HEAD^{tree}"] + tree_hash = subprocess.check_output(rev_parse_command).decode().strip() + cat_file_command = ["git", "cat-file", "-p", tree_hash] + cat_file_output = subprocess.check_output(cat_file_command).decode() + return [line.split()[-1] for line in cat_file_output.split("\n") if line] + def test_tree_modifier_ordering(self): + """TreeModifier.set_done() sorts files in the same order git does.""" + git_file_names_in_order = self._get_git_ordered_files() + hexsha = "6c1faef799095f3990e9970bc2cb10aa0221cf9c" roottree = self.rorepo.tree(hexsha) blob_mode = Tree.blob_id << 12 @@ -92,9 +105,6 @@ def names_in_mod_cache(): here = file_names_in_order() return [e for e in a if e in here] - git_file_names_in_order = setup_git_repository_and_get_ordered_files() - os.chdir("..") - mod.set_done() assert names_in_mod_cache() == git_file_names_in_order, "set_done() performs git-sorting"