Remove default-branch assumptions from tests

Author: codex

test/test_commit.py

@@ -276,14 +276,14 @@ def test_iteration(self):
         assert ltd_commits and len(ltd_commits) < len(all_commits)
 
         # Show commits of multiple paths, resulting in a union of commits.
-        less_ltd_commits = list(Commit.iter_items(self.rorepo, "master", paths=("CHANGES", "AUTHORS")))
+        less_ltd_commits = list(Commit.iter_items(self.rorepo, "HEAD", paths=("CHANGES", "AUTHORS")))
         assert len(ltd_commits) < len(less_ltd_commits)
 
         class Child(Commit):
             def __init__(self, *args, **kwargs):
                 super().__init__(*args, **kwargs)
 
-        child_commits = list(Child.iter_items(self.rorepo, "master", paths=("CHANGES", "AUTHORS")))
+        child_commits = list(Child.iter_items(self.rorepo, "HEAD", paths=("CHANGES", "AUTHORS")))
         assert type(child_commits[0]) is Child
 
     def test_iter_items(self):
@@ -536,7 +536,7 @@ def test_trailers(self):
             ),
         ]
         for msg in msgs:
-            commit = copy.copy(self.rorepo.commit("master"))
+            commit = copy.copy(self.rorepo.commit("HEAD"))
             commit.message = msg
             assert commit.trailers_list == [
                 (KEY_1, VALUE_1_1),
@@ -559,13 +559,13 @@ def test_trailers(self):
         ]
 
         for msg in msgs:
-            commit = copy.copy(self.rorepo.commit("master"))
+            commit = copy.copy(self.rorepo.commit("HEAD"))
             commit.message = msg
             assert commit.trailers_list == []
             assert commit.trailers_dict == {}
 
         # Check that only the last key value paragraph is evaluated.
-        commit = copy.copy(self.rorepo.commit("master"))
+        commit = copy.copy(self.rorepo.commit("HEAD"))
         commit.message = f"Subject\n\nMultiline\nBody\n\n{KEY_1}: {VALUE_1_1}\n\n{KEY_2}: {VALUE_2}\n"
         assert commit.trailers_list == [(KEY_2, VALUE_2)]
         assert commit.trailers_dict == {KEY_2: [VALUE_2]}

test/test_docs.py

@@ -72,21 +72,22 @@ def test_init_repo_object(self, rw_dir):
         # heads, tags and references
         # heads are branches in git-speak
         # [8-test_init_repo_object]
-        self.assertEqual(
-            repo.head.ref,
-            repo.heads.master,  # head is a sym-ref pointing to master.
-            "It's ok if TC not running from `master`.",
-        )
+        active_branch = repo.active_branch
+        self.assertEqual(repo.head.ref, active_branch)  # HEAD is a sym-ref pointing to the active branch.
         self.assertEqual(repo.tags["0.3.5"], repo.tag("refs/tags/0.3.5"))  # You can access tags in various ways too.
-        self.assertEqual(repo.refs.master, repo.heads["master"])  # .refs provides all refs, i.e. heads...
+        self.assertEqual(repo.refs[active_branch.name], repo.heads[active_branch.name])  # .refs provides all refs...
 
         if "TRAVIS" not in os.environ:
-            self.assertEqual(repo.refs["origin/master"], repo.remotes.origin.refs.master)  # ... remotes ...
+            remote_head = repo.remotes.origin.refs.HEAD.reference
+            self.assertEqual(
+                repo.refs[remote_head.name], repo.remotes.origin.refs[remote_head.remote_head]
+            )  # ...remotes...
         self.assertEqual(repo.refs["0.3.5"], repo.tags["0.3.5"])  # ... and tags.
         # ![8-test_init_repo_object]
 
         # Create a new head/branch.
         # [9-test_init_repo_object]
+        original_branch = cloned_repo.active_branch
         new_branch = cloned_repo.create_head("feature")  # Create a new branch ...
         assert cloned_repo.active_branch != new_branch  # which wasn't checked out yet ...
         self.assertEqual(new_branch.commit, cloned_repo.active_branch.commit)  # pointing to the checked-out commit.
@@ -146,10 +147,10 @@ def update(self, op_code, cur_count, max_count=None, message=""):
         assert origin.exists()
         for fetch_info in origin.fetch(progress=MyProgressPrinter()):
             print("Updated %s to %s" % (fetch_info.ref, fetch_info.commit))
-        # Create a local branch at the latest fetched master. We specify the name
-        # statically, but you have all information to do it programmatically as well.
-        bare_master = bare_repo.create_head("master", origin.refs.master)
-        bare_repo.head.set_reference(bare_master)
+        # Create a local branch at the remote's default branch.
+        remote_default_branch = origin.refs.HEAD.reference
+        bare_branch = bare_repo.create_head(remote_default_branch.remote_head, remote_default_branch)
+        bare_repo.head.set_reference(bare_branch)
         assert not bare_repo.delete_remote(origin).exists()
         # push and pull behave very similarly.
         # ![12-test_init_repo_object]
@@ -162,35 +163,39 @@ def update(self, op_code, cur_count, max_count=None, message=""):
         new_file_path = os.path.join(cloned_repo.working_tree_dir, "my-new-file")
         open(new_file_path, "wb").close()  # Create new file in working tree.
         cloned_repo.index.add([new_file_path])  # Add it to the index.
-        # Commit the changes to deviate masters history.
+        # Commit the changes to deviate from the original branch's history.
         cloned_repo.index.commit("Added a new file in the past - for later merge")
 
         # Prepare a merge.
-        master = cloned_repo.heads.master  # Right-hand side is ahead of us, in the future.
-        merge_base = cloned_repo.merge_base(new_branch, master)  # Allows for a three-way merge.
-        cloned_repo.index.merge_tree(master, base=merge_base)  # Write the merge result into index.
+        merge_base = cloned_repo.merge_base(new_branch, original_branch)  # Allows for a three-way merge.
+        cloned_repo.index.merge_tree(original_branch, base=merge_base)  # Write the merge result into index.
         cloned_repo.index.commit(
             "Merged past and now into future ;)",
-            parent_commits=(new_branch.commit, master.commit),
+            parent_commits=(new_branch.commit, original_branch.commit),
         )
 
-        # Now new_branch is ahead of master, which probably should be checked out and reset softly.
+        # Now new_branch is ahead of the original branch, which probably should be checked out and reset softly.
         # Note that all these operations didn't touch the working tree, as we managed it ourselves.
         # This definitely requires you to know what you are doing! :)
         assert os.path.basename(new_file_path) in new_branch.commit.tree  # New file is now in tree.
-        master.commit = new_branch.commit  # Let master point to most recent commit.
-        cloned_repo.head.reference = master  # We adjusted just the reference, not the working tree or index.
+        original_branch.commit = new_branch.commit  # Let the original branch point to the most recent commit.
+        cloned_repo.head.reference = original_branch  # We adjusted just the reference, not the working tree or index.
         # ![13-test_init_repo_object]
 
         # submodules
 
         # [14-test_init_repo_object]
-        # Create a new submodule and check it out on the spot, setup to track master
-        # branch of `bare_repo`. As our GitPython repository has submodules already that
-        # point to GitHub, make sure we don't interact with them.
+        # Create a new submodule and check it out on the spot, set up to track the
+        # default branch of `bare_repo`. As our GitPython repository has submodules
+        # already that point to GitHub, make sure we don't interact with them.
         for sm in cloned_repo.submodules:
             assert not sm.remove().exists()  # after removal, the sm doesn't exist anymore
-        sm = cloned_repo.create_submodule("mysubrepo", "path/to/subrepo", url=bare_repo.git_dir, branch="master")
+        sm = cloned_repo.create_submodule(
+            "mysubrepo",
+            "path/to/subrepo",
+            url=bare_repo.git_dir,
+            branch=bare_branch.name,
+        )
 
         # .gitmodules was written and added to the index, which is now being committed.
         cloned_repo.index.commit("Added submodule")

test/test_refs.py

@@ -258,7 +258,7 @@ def test_orig_head(self):
 
     @with_rw_repo("0.1.6")
     def test_head_checkout_detached_head(self, rw_repo):
-        res = rw_repo.remotes.origin.refs.master.checkout()
+        res = rw_repo.remotes.origin.refs.HEAD.reference.checkout()
         assert isinstance(res, SymbolicReference)
         assert res.name == "HEAD"
 
@@ -661,7 +661,7 @@ def test_dereference_recursive(self):
         assert SymbolicReference.dereference_recursive(self.rorepo, "HEAD")
 
     def test_reflog(self):
-        assert isinstance(self.rorepo.heads.master.log(), RefLog)
+        assert isinstance(self.rorepo.active_branch.log(), RefLog)
 
     def test_refs_outside_repo(self):
         # Create a file containing a valid reference outside the repository. Attempting

test/test_repo.py

@@ -128,8 +128,9 @@ def test_heads_should_populate_head_data(self):
             self.assertIsInstance(head.commit, Commit)
         # END for each head
 
-        self.assertIsInstance(self.rorepo.heads.master, Head)
-        self.assertIsInstance(self.rorepo.heads["master"], Head)
+        active_branch = self.rorepo.active_branch
+        self.assertIsInstance(self.rorepo.heads[active_branch.name], Head)
+        self.assertEqual(self.rorepo.heads[active_branch.name], active_branch)
 
     def test_tree_from_revision(self):
         tree = self.rorepo.tree("0.1.6")
@@ -1008,7 +1009,7 @@ def last_commit(repo, rev, path):
         for _ in range(64):
             for repo_type in (GitCmdObjectDB, GitDB):
                 repo = Repo(self.rorepo.working_tree_dir, odbt=repo_type)
-                last_commit(repo, "master", "test/test_base.py")
+                last_commit(repo, "HEAD", "test/test_base.py")
             # END for each repository type
         # END for each iteration
 
@@ -1125,11 +1126,11 @@ def test_is_ancestor(self):
         c1 = "f6aa8d1"
         c2 = "763ef75"
         self.assertTrue(repo.is_ancestor(c1, c1))
-        self.assertTrue(repo.is_ancestor("master", "master"))
+        self.assertTrue(repo.is_ancestor("HEAD", "HEAD"))
         self.assertTrue(repo.is_ancestor(c1, c2))
-        self.assertTrue(repo.is_ancestor(c1, "master"))
+        self.assertTrue(repo.is_ancestor(c1, "HEAD"))
         self.assertFalse(repo.is_ancestor(c2, c1))
-        self.assertFalse(repo.is_ancestor("master", c1))
+        self.assertFalse(repo.is_ancestor("HEAD", c1))
         for i, j in itertools.permutations([c1, "ffffff", ""], r=2):
             self.assertRaises(GitCommandError, repo.is_ancestor, i, j)