Move some functions to gitrepo package (#35543)

Refactor Git command functions to use WithXXX methods instead of
exposing RunOpts.
This change simplifies reuse across gitrepo and improves consistency,
encapsulation, and maintainability of command options.

---------

Co-authored-by: wxiaoguang <wxiaoguang@gmail.com>

tests/integration/api_repo_git_tags_test.go

@@ -12,7 +12,6 @@ import (
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unittest"
 	user_model "code.gitea.io/gitea/models/user"
-	"code.gitea.io/gitea/modules/git/gitcmd"
 	"code.gitea.io/gitea/modules/gitrepo"
 	api "code.gitea.io/gitea/modules/structs"
 	"code.gitea.io/gitea/modules/util"
@@ -30,8 +29,8 @@ func TestAPIGitTags(t *testing.T) {
 	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeReadRepository)
 
 	// Set up git config for the tagger
-	_ = gitcmd.NewCommand("config", "user.name").AddDynamicArguments(user.Name).Run(t.Context(), &gitcmd.RunOpts{Dir: repo.RepoPath()})
-	_ = gitcmd.NewCommand("config", "user.email").AddDynamicArguments(user.Email).Run(t.Context(), &gitcmd.RunOpts{Dir: repo.RepoPath()})
+	_ = gitrepo.GitConfigSet(t.Context(), repo, "user.name", user.Name)
+	_ = gitrepo.GitConfigSet(t.Context(), repo, "user.email", user.Email)
 
 	gitRepo, _ := gitrepo.OpenRepository(t.Context(), repo)
 	defer gitRepo.Close()

tests/integration/editor_test.go

@@ -20,6 +20,7 @@ import (
 	"code.gitea.io/gitea/models/unittest"
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/gitrepo"
 	"code.gitea.io/gitea/modules/test"
 	"code.gitea.io/gitea/modules/translation"
 	"code.gitea.io/gitea/modules/util"
@@ -187,7 +188,7 @@ func testEditorWebGitCommitEmail(t *testing.T) {
 	require.True(t, user.KeepEmailPrivate)
 
 	repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
-	gitRepo, _ := git.OpenRepository(t.Context(), repo1.RepoPath())
+	gitRepo, _ := gitrepo.OpenRepository(t.Context(), repo1)
 	defer gitRepo.Close()
 	getLastCommit := func(t *testing.T) *git.Commit {
 		c, err := gitRepo.GetBranchCommit("master")

tests/integration/git_general_test.go

@@ -194,9 +194,10 @@ func lfsCommitAndPushTest(t *testing.T, dstPath string, sizes ...int) (pushedFil
 	t.Run("CommitAndPushLFS", func(t *testing.T) {
 		defer tests.PrintCurrentTest(t)()
 		prefix := "lfs-data-file-"
-		err := gitcmd.NewCommand("lfs").AddArguments("install").Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		err := gitcmd.NewCommand("lfs").AddArguments("install").WithDir(dstPath).Run(t.Context())
 		assert.NoError(t, err)
-		_, _, err = gitcmd.NewCommand("lfs").AddArguments("track").AddDynamicArguments(prefix+"*").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err = gitcmd.NewCommand("lfs").AddArguments("track").AddDynamicArguments(prefix + "*").
+			WithDir(dstPath).RunStdString(t.Context())
 		assert.NoError(t, err)
 		err = git.AddChanges(t.Context(), dstPath, false, ".gitattributes")
 		assert.NoError(t, err)
@@ -312,20 +313,20 @@ func lockTest(t *testing.T, repoPath string) {
 }
 
 func lockFileTest(t *testing.T, filename, repoPath string) {
-	_, _, err := gitcmd.NewCommand("lfs").AddArguments("locks").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: repoPath})
+	_, _, err := gitcmd.NewCommand("lfs").AddArguments("locks").WithDir(repoPath).RunStdString(t.Context())
 	assert.NoError(t, err)
-	_, _, err = gitcmd.NewCommand("lfs").AddArguments("lock").AddDynamicArguments(filename).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: repoPath})
+	_, _, err = gitcmd.NewCommand("lfs").AddArguments("lock").AddDynamicArguments(filename).WithDir(repoPath).RunStdString(t.Context())
 	assert.NoError(t, err)
-	_, _, err = gitcmd.NewCommand("lfs").AddArguments("locks").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: repoPath})
+	_, _, err = gitcmd.NewCommand("lfs").AddArguments("locks").WithDir(repoPath).RunStdString(t.Context())
 	assert.NoError(t, err)
-	_, _, err = gitcmd.NewCommand("lfs").AddArguments("unlock").AddDynamicArguments(filename).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: repoPath})
+	_, _, err = gitcmd.NewCommand("lfs").AddArguments("unlock").AddDynamicArguments(filename).WithDir(repoPath).RunStdString(t.Context())
 	assert.NoError(t, err)
 }
 
 func doCommitAndPush(t *testing.T, size int, repoPath, prefix string) string {
 	name, err := generateCommitWithNewData(t.Context(), size, repoPath, "user2@example.com", "User Two", prefix)
 	assert.NoError(t, err)
-	_, _, err = gitcmd.NewCommand("push", "origin", "master").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: repoPath}) // Push
+	_, _, err = gitcmd.NewCommand("push", "origin", "master").WithDir(repoPath).RunStdString(t.Context())
 	assert.NoError(t, err)
 	return name
 }
@@ -425,7 +426,7 @@ func doBranchProtectPRMerge(baseCtx *APITestContext, dstPath string) func(t *tes
 		// Try to force push without force push permissions, which should fail
 		t.Run("ForcePushWithoutForcePermissions", func(t *testing.T) {
 			t.Run("CreateDivergentHistory", func(t *testing.T) {
-				gitcmd.NewCommand("reset", "--hard", "HEAD~1").Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+				gitcmd.NewCommand("reset", "--hard", "HEAD~1").WithDir(dstPath).Run(t.Context())
 				_, err := generateCommitWithNewData(t.Context(), testFileSizeSmall, dstPath, "user2@example.com", "User Two", "branch-data-file-new")
 				assert.NoError(t, err)
 			})
@@ -848,7 +849,10 @@ func doCreateAgitFlowPull(dstPath string, ctx *APITestContext, headBranch string
 		})
 
 		t.Run("Push", func(t *testing.T) {
-			err := gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master", "-o").AddDynamicArguments("topic="+headBranch).Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			err := gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master", "-o").
+				AddDynamicArguments("topic=" + headBranch).
+				WithDir(dstPath).
+				Run(t.Context())
 			require.NoError(t, err)
 
 			unittest.AssertCount(t, &issues_model.PullRequest{}, pullNum+1)
@@ -866,7 +870,10 @@ func doCreateAgitFlowPull(dstPath string, ctx *APITestContext, headBranch string
 			assert.Contains(t, "Testing commit 1", prMsg.Body)
 			assert.Equal(t, commit, prMsg.Head.Sha)
 
-			_, _, err = gitcmd.NewCommand("push", "origin").AddDynamicArguments("HEAD:refs/for/master/test/"+headBranch).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			_, _, err = gitcmd.NewCommand("push", "origin").
+				AddDynamicArguments("HEAD:refs/for/master/test/" + headBranch).
+				WithDir(dstPath).
+				RunStdString(t.Context())
 			require.NoError(t, err)
 
 			unittest.AssertCount(t, &issues_model.PullRequest{}, pullNum+2)
@@ -914,7 +921,10 @@ func doCreateAgitFlowPull(dstPath string, ctx *APITestContext, headBranch string
 		})
 
 		t.Run("Push2", func(t *testing.T) {
-			err := gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master", "-o").AddDynamicArguments("topic="+headBranch).Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			err := gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master", "-o").
+				AddDynamicArguments("topic=" + headBranch).
+				WithDir(dstPath).
+				Run(t.Context())
 			require.NoError(t, err)
 
 			unittest.AssertCount(t, &issues_model.PullRequest{}, pullNum+2)
@@ -924,7 +934,10 @@ func doCreateAgitFlowPull(dstPath string, ctx *APITestContext, headBranch string
 			assert.False(t, prMsg.HasMerged)
 			assert.Equal(t, commit, prMsg.Head.Sha)
 
-			_, _, err = gitcmd.NewCommand("push", "origin").AddDynamicArguments("HEAD:refs/for/master/test/"+headBranch).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			_, _, err = gitcmd.NewCommand("push", "origin").
+				AddDynamicArguments("HEAD:refs/for/master/test/" + headBranch).
+				WithDir(dstPath).
+				RunStdString(t.Context())
 			require.NoError(t, err)
 
 			unittest.AssertCount(t, &issues_model.PullRequest{}, pullNum+2)

tests/integration/git_helper_for_declarative_test.go

@@ -123,7 +123,9 @@ func doGitInitTestRepository(dstPath string) func(*testing.T) {
 		// Init repository in dstPath
 		assert.NoError(t, git.InitRepository(t.Context(), dstPath, false, git.Sha1ObjectFormat.Name()))
 		// forcibly set default branch to master
-		_, _, err := gitcmd.NewCommand("symbolic-ref", "HEAD", git.BranchPrefix+"master").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err := gitcmd.NewCommand("symbolic-ref", "HEAD", git.BranchPrefix+"master").
+			WithDir(dstPath).
+			RunStdString(t.Context())
 		assert.NoError(t, err)
 		assert.NoError(t, os.WriteFile(filepath.Join(dstPath, "README.md"), []byte("# Testing Repository\n\nOriginally created in: "+dstPath), 0o644))
 		assert.NoError(t, git.AddChanges(t.Context(), dstPath, true))
@@ -142,21 +144,27 @@ func doGitInitTestRepository(dstPath string) func(*testing.T) {
 
 func doGitAddRemote(dstPath, remoteName string, u *url.URL) func(*testing.T) {
 	return func(t *testing.T) {
-		_, _, err := gitcmd.NewCommand("remote", "add").AddDynamicArguments(remoteName, u.String()).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err := gitcmd.NewCommand("remote", "add").AddDynamicArguments(remoteName, u.String()).
+			WithDir(dstPath).
+			RunStdString(t.Context())
 		assert.NoError(t, err)
 	}
 }
 
 func doGitPushTestRepository(dstPath string, args ...string) func(*testing.T) {
 	return func(t *testing.T) {
-		_, _, err := gitcmd.NewCommand("push", "-u").AddArguments(gitcmd.ToTrustedCmdArgs(args)...).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err := gitcmd.NewCommand("push", "-u").AddArguments(gitcmd.ToTrustedCmdArgs(args)...).
+			WithDir(dstPath).
+			RunStdString(t.Context())
 		assert.NoError(t, err)
 	}
 }
 
 func doGitPushTestRepositoryFail(dstPath string, args ...string) func(*testing.T) {
 	return func(t *testing.T) {
-		_, _, err := gitcmd.NewCommand("push").AddArguments(gitcmd.ToTrustedCmdArgs(args)...).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err := gitcmd.NewCommand("push").AddArguments(gitcmd.ToTrustedCmdArgs(args)...).
+			WithDir(dstPath).
+			RunStdString(t.Context())
 		assert.Error(t, err)
 	}
 }
@@ -188,28 +196,36 @@ func doGitCheckoutWriteFileCommit(opts localGitAddCommitOptions) func(*testing.T
 
 func doGitCreateBranch(dstPath, branch string) func(*testing.T) {
 	return func(t *testing.T) {
-		_, _, err := gitcmd.NewCommand("checkout", "-b").AddDynamicArguments(branch).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err := gitcmd.NewCommand("checkout", "-b").AddDynamicArguments(branch).
+			WithDir(dstPath).RunStdString(t.Context())
 		assert.NoError(t, err)
 	}
 }
 
 func doGitCheckoutBranch(dstPath string, args ...string) func(*testing.T) {
 	return func(t *testing.T) {
-		_, _, err := gitcmd.NewCommand().AddArguments("checkout").AddArguments(gitcmd.ToTrustedCmdArgs(args)...).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err := gitcmd.NewCommand().AddArguments("checkout").
+			AddArguments(gitcmd.ToTrustedCmdArgs(args)...).
+			WithDir(dstPath).
+			RunStdString(t.Context())
 		assert.NoError(t, err)
 	}
 }
 
 func doGitMerge(dstPath string, args ...string) func(*testing.T) {
 	return func(t *testing.T) {
-		_, _, err := gitcmd.NewCommand("merge").AddArguments(gitcmd.ToTrustedCmdArgs(args)...).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err := gitcmd.NewCommand("merge").AddArguments(gitcmd.ToTrustedCmdArgs(args)...).
+			WithDir(dstPath).
+			RunStdString(t.Context())
 		assert.NoError(t, err)
 	}
 }
 
 func doGitPull(dstPath string, args ...string) func(*testing.T) {
 	return func(t *testing.T) {
-		_, _, err := gitcmd.NewCommand().AddArguments("pull").AddArguments(gitcmd.ToTrustedCmdArgs(args)...).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err := gitcmd.NewCommand().AddArguments("pull").AddArguments(gitcmd.ToTrustedCmdArgs(args)...).
+			WithDir(dstPath).
+			RunStdString(t.Context())
 		assert.NoError(t, err)
 	}
 }

tests/integration/git_lfs_ssh_test.go

@@ -45,7 +45,9 @@ func TestGitLFSSSH(t *testing.T) {
 			setting.LFS.AllowPureSSH = true
 			require.NoError(t, cfg.Save())
 
-			_, _, cmdErr := gitcmd.NewCommand("config", "lfs.sshtransfer", "always").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			_, _, cmdErr := gitcmd.NewCommand("config", "lfs.sshtransfer", "always").
+				WithDir(dstPath).
+				RunStdString(t.Context())
 			assert.NoError(t, cmdErr)
 			lfsCommitAndPushTest(t, dstPath, 10)
 		})

tests/integration/git_misc_test.go

@@ -104,7 +104,8 @@ func TestAgitPullPush(t *testing.T) {
 		err = gitcmd.NewCommand("push", "origin",
 			"-o", "title=test-title", "-o", "description=test-description",
 			"HEAD:refs/for/master/test-agit-push",
-		).Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		).WithDir(dstPath).
+			Run(t.Context())
 		assert.NoError(t, err)
 
 		// check pull request exist
@@ -118,20 +119,26 @@ func TestAgitPullPush(t *testing.T) {
 		assert.NoError(t, err)
 
 		// push 2
-		err = gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master/test-agit-push").Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		err = gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master/test-agit-push").
+			WithDir(dstPath).
+			Run(t.Context())
 		assert.NoError(t, err)
 
 		// reset to first commit
-		err = gitcmd.NewCommand("reset", "--hard", "HEAD~1").Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		err = gitcmd.NewCommand("reset", "--hard", "HEAD~1").WithDir(dstPath).Run(t.Context())
 		assert.NoError(t, err)
 
 		// test force push without confirm
-		_, stderr, err := gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master/test-agit-push").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, stderr, err := gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master/test-agit-push").
+			WithDir(dstPath).
+			RunStdString(t.Context())
 		assert.Error(t, err)
 		assert.Contains(t, stderr, "[remote rejected] HEAD -> refs/for/master/test-agit-push (request `force-push` push option)")
 
 		// test force push with confirm
-		err = gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master/test-agit-push", "-o", "force-push").Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		err = gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master/test-agit-push", "-o", "force-push").
+			WithDir(dstPath).
+			Run(t.Context())
 		assert.NoError(t, err)
 	})
 }
@@ -160,7 +167,7 @@ func TestAgitReviewStaleness(t *testing.T) {
 		err = gitcmd.NewCommand("push", "origin",
 			"-o", "title=Test agit Review Staleness", "-o", "description=Testing review staleness",
 			"HEAD:refs/for/master/test-agit-review",
-		).Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		).WithDir(dstPath).Run(t.Context())
 		assert.NoError(t, err)
 
 		pr := unittest.AssertExistsAndLoadBean(t, &issues_model.PullRequest{
@@ -200,7 +207,9 @@ func TestAgitReviewStaleness(t *testing.T) {
 		_, err = generateCommitWithNewData(t.Context(), testFileSizeSmall, dstPath, "user2@example.com", "User Two", "updated-")
 		assert.NoError(t, err)
 
-		err = gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master/test-agit-review").Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		err = gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master/test-agit-review").
+			WithDir(dstPath).
+			Run(t.Context())
 		assert.NoError(t, err)
 
 		// Reload PR to get updated commit ID

tests/integration/git_push_test.go

@@ -210,9 +210,7 @@ func TestPushPullRefs(t *testing.T) {
 		doGitClone(dstPath, u)(t)
 
 		cmd := gitcmd.NewCommand("push", "--delete", "origin", "refs/pull/2/head")
-		stdout, stderr, err := cmd.RunStdString(t.Context(), &gitcmd.RunOpts{
-			Dir: dstPath,
-		})
+		stdout, stderr, err := cmd.WithDir(dstPath).RunStdString(t.Context())
 		assert.Error(t, err)
 		assert.Empty(t, stdout)
 		assert.NotContains(t, stderr, "[deleted]", "stderr: %s", stderr)

tests/integration/pull_create_test.go

@@ -268,7 +268,10 @@ func TestCreateAgitPullWithReadPermission(t *testing.T) {
 			TreeFileContent: "temp content",
 		})(t)
 
-		err := gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master", "-o").AddDynamicArguments("topic="+"test-topic").Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		err := gitcmd.NewCommand("push", "origin", "HEAD:refs/for/master", "-o").
+			AddDynamicArguments("topic=test-topic").
+			WithDir(dstPath).
+			Run(t.Context())
 		assert.NoError(t, err)
 	})
 }

tests/integration/pull_merge_test.go

@@ -11,7 +11,6 @@ import (
 	"net/url"
 	"os"
 	"path"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"testing"
@@ -295,24 +294,27 @@ func TestCantMergeUnrelated(t *testing.T) {
 		})
 		path := repo_model.RepoPath(user1.Name, repo1.Name)
 
-		err := gitcmd.NewCommand("read-tree", "--empty").Run(t.Context(), &gitcmd.RunOpts{Dir: path})
+		err := gitcmd.NewCommand("read-tree", "--empty").WithDir(path).Run(t.Context())
 		assert.NoError(t, err)
 
 		stdin := strings.NewReader("Unrelated File")
 		var stdout strings.Builder
-		err = gitcmd.NewCommand("hash-object", "-w", "--stdin").Run(t.Context(), &gitcmd.RunOpts{
-			Dir:    path,
-			Stdin:  stdin,
-			Stdout: &stdout,
-		})
+		err = gitcmd.NewCommand("hash-object", "-w", "--stdin").
+			WithDir(path).
+			WithStdin(stdin).
+			WithStdout(&stdout).
+			Run(t.Context())
 
 		assert.NoError(t, err)
 		sha := strings.TrimSpace(stdout.String())
 
-		_, _, err = gitcmd.NewCommand("update-index", "--add", "--replace", "--cacheinfo").AddDynamicArguments("100644", sha, "somewher-over-the-rainbow").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: path})
+		_, _, err = gitcmd.NewCommand("update-index", "--add", "--replace", "--cacheinfo").
+			AddDynamicArguments("100644", sha, "somewher-over-the-rainbow").
+			WithDir(path).
+			RunStdString(t.Context())
 		assert.NoError(t, err)
 
-		treeSha, _, err := gitcmd.NewCommand("write-tree").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: path})
+		treeSha, _, err := gitcmd.NewCommand("write-tree").WithDir(path).RunStdString(t.Context())
 		assert.NoError(t, err)
 		treeSha = strings.TrimSpace(treeSha)
 
@@ -333,16 +335,18 @@ func TestCantMergeUnrelated(t *testing.T) {
 
 		stdout.Reset()
 		err = gitcmd.NewCommand("commit-tree").AddDynamicArguments(treeSha).
-			Run(t.Context(), &gitcmd.RunOpts{
-				Env:    env,
-				Dir:    path,
-				Stdin:  messageBytes,
-				Stdout: &stdout,
-			})
+			WithEnv(env).
+			WithDir(path).
+			WithStdin(messageBytes).
+			WithStdout(&stdout).
+			Run(t.Context())
 		assert.NoError(t, err)
 		commitSha := strings.TrimSpace(stdout.String())
 
-		_, _, err = gitcmd.NewCommand("branch", "unrelated").AddDynamicArguments(commitSha).RunStdString(t.Context(), &gitcmd.RunOpts{Dir: path})
+		_, _, err = gitcmd.NewCommand("branch", "unrelated").
+			AddDynamicArguments(commitSha).
+			WithDir(path).
+			RunStdString(t.Context())
 		assert.NoError(t, err)
 
 		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "conflict", "README.md", "Hello, World (Edited Once)\n")
@@ -689,17 +693,13 @@ func TestPullMergeIndexerNotifier(t *testing.T) {
 	})
 }
 
-func testResetRepo(t *testing.T, repoPath, branch, commitID string) {
-	f, err := os.OpenFile(filepath.Join(repoPath, "refs", "heads", branch), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
-	assert.NoError(t, err)
-	_, err = f.WriteString(commitID + "\n")
-	assert.NoError(t, err)
-	f.Close()
+func testResetRepo(t *testing.T, repo *repo_model.Repository, branch, commitID string) {
+	assert.NoError(t, gitrepo.UpdateRef(t.Context(), repo, git.BranchPrefix+branch, commitID))
 
-	repo, err := git.OpenRepository(t.Context(), repoPath)
+	gitRepo, err := gitrepo.OpenRepository(t.Context(), repo)
 	assert.NoError(t, err)
-	defer repo.Close()
-	id, err := repo.GetBranchCommitID(branch)
+	defer gitRepo.Close()
+	id, err := gitRepo.GetBranchCommitID(branch)
 	assert.NoError(t, err)
 	assert.Equal(t, commitID, id)
 }
@@ -778,7 +778,7 @@ func TestPullAutoMergeAfterCommitStatusSucceed(t *testing.T) {
 		assert.ElementsMatch(t, []string{"sub-home-md-img-check", "home-md-img-check", "pr-to-update", "branch2", "DefaultBranch", "develop", "feature/1", "master"}, branches)
 		baseGitRepo.Close()
 		defer func() {
-			testResetRepo(t, baseRepo.RepoPath(), "master", masterCommitID)
+			testResetRepo(t, baseRepo, "master", masterCommitID)
 		}()
 
 		err = commitstatus_service.CreateCommitStatus(t.Context(), baseRepo, user1, sha, &git_model.CommitStatus{
@@ -856,7 +856,7 @@ func TestPullAutoMergeAfterCommitStatusSucceedAndApproval(t *testing.T) {
 		assert.NoError(t, err)
 		baseGitRepo.Close()
 		defer func() {
-			testResetRepo(t, baseRepo.RepoPath(), "master", masterCommitID)
+			testResetRepo(t, baseRepo, "master", masterCommitID)
 		}()
 
 		err = commitstatus_service.CreateCommitStatus(t.Context(), baseRepo, user1, sha, &git_model.CommitStatus{
@@ -932,7 +932,9 @@ func TestPullAutoMergeAfterCommitStatusSucceedAndApprovalForAgitFlow(t *testing.
 			AddDynamicArguments(`title="create a test pull request with agit"`).
 			AddArguments("-o").
 			AddDynamicArguments(`description="This PR is a test pull request which created with agit"`).
-			Run(t.Context(), &gitcmd.RunOpts{Dir: dstPath, Stderr: stderrBuf})
+			WithDir(dstPath).
+			WithStderr(stderrBuf).
+			Run(t.Context())
 		assert.NoError(t, err)
 
 		assert.Contains(t, stderrBuf.String(), setting.AppURL+"user2/repo1/pulls/6")
@@ -985,7 +987,7 @@ func TestPullAutoMergeAfterCommitStatusSucceedAndApprovalForAgitFlow(t *testing.
 		assert.NoError(t, err)
 		baseGitRepo.Close()
 		defer func() {
-			testResetRepo(t, baseRepo.RepoPath(), "master", masterCommitID)
+			testResetRepo(t, baseRepo, "master", masterCommitID)
 		}()
 
 		err = commitstatus_service.CreateCommitStatus(t.Context(), baseRepo, user1, sha, &git_model.CommitStatus{

tests/integration/repo_branch_test.go

@@ -154,7 +154,7 @@ func prepareRecentlyPushedBranchTest(t *testing.T, headSession *TestSession, bas
 
 	// only `new-commit` branch has commits ahead the base branch
 	checkRecentlyPushedNewBranches(t, headSession, headRepoPath, []string{"new-commit"})
-	if baseRepo.RepoPath() != headRepo.RepoPath() {
+	if baseRepo.ID != headRepo.ID {
 		checkRecentlyPushedNewBranches(t, headSession, baseRepoPath, []string{fmt.Sprintf("%v:new-commit", headRepo.FullName())})
 	}
 
@@ -162,7 +162,7 @@ func prepareRecentlyPushedBranchTest(t *testing.T, headSession *TestSession, bas
 	testCreatePullToDefaultBranch(t, headSession, baseRepo, headRepo, "new-commit", "merge new-commit to default branch")
 	// No push message show because of active PR
 	checkRecentlyPushedNewBranches(t, headSession, headRepoPath, []string{})
-	if baseRepo.RepoPath() != headRepo.RepoPath() {
+	if baseRepo.ID != headRepo.ID {
 		checkRecentlyPushedNewBranches(t, headSession, baseRepoPath, []string{})
 	}
 }
@@ -179,7 +179,7 @@ func prepareRecentlyPushedBranchSpecialTest(t *testing.T, session *TestSession,
 
 	// Though we have new `no-commit` branch, but the headBranch is not newer or commits ahead baseBranch. No message show.
 	checkRecentlyPushedNewBranches(t, session, headRepoPath, []string{})
-	if baseRepo.RepoPath() != headRepo.RepoPath() {
+	if baseRepo.ID != headRepo.ID {
 		checkRecentlyPushedNewBranches(t, session, baseRepoPath, []string{})
 	}
 }

tests/integration/repo_tag_test.go

@@ -55,10 +55,10 @@ func TestCreateNewTagProtected(t *testing.T) {
 
 			doGitClone(dstPath, u)(t)
 
-			_, _, err := gitcmd.NewCommand("tag", "v-2").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			_, _, err := gitcmd.NewCommand("tag", "v-2").WithDir(dstPath).RunStdString(t.Context())
 			assert.NoError(t, err)
 
-			_, _, err = gitcmd.NewCommand("push", "--tags").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			_, _, err = gitcmd.NewCommand("push", "--tags").WithDir(dstPath).RunStdString(t.Context())
 			assert.Error(t, err)
 			assert.Contains(t, err.Error(), "Tag v-2 is protected")
 		})
@@ -75,20 +75,22 @@ func TestCreateNewTagProtected(t *testing.T) {
 
 			doGitClone(dstPath, u)(t)
 
-			_, _, err := gitcmd.NewCommand("tag", "v-1.1", "-m", "force update", "--force").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			_, _, err := gitcmd.NewCommand("tag", "v-1.1", "-m", "force update", "--force").
+				WithDir(dstPath).
+				RunStdString(t.Context())
 			require.NoError(t, err)
 
-			_, _, err = gitcmd.NewCommand("push", "--tags").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			_, _, err = gitcmd.NewCommand("push", "--tags").WithDir(dstPath).RunStdString(t.Context())
 			require.NoError(t, err)
 
-			_, _, err = gitcmd.NewCommand("tag", "v-1.1", "-m", "force update v2", "--force").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			_, _, err = gitcmd.NewCommand("tag", "v-1.1", "-m", "force update v2", "--force").WithDir(dstPath).RunStdString(t.Context())
 			require.NoError(t, err)
 
-			_, _, err = gitcmd.NewCommand("push", "--tags").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			_, _, err = gitcmd.NewCommand("push", "--tags").WithDir(dstPath).RunStdString(t.Context())
 			require.Error(t, err)
 			assert.Contains(t, err.Error(), "the tag already exists in the remote")
 
-			_, _, err = gitcmd.NewCommand("push", "--tags", "--force").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+			_, _, err = gitcmd.NewCommand("push", "--tags", "--force").WithDir(dstPath).RunStdString(t.Context())
 			require.NoError(t, err)
 			req := NewRequestf(t, "GET", "/%s/releases/tag/v-1.1", repo.FullName())
 			resp := MakeRequest(t, req, http.StatusOK)
@@ -137,15 +139,15 @@ func TestRepushTag(t *testing.T) {
 		doGitClone(dstPath, u)(t)
 
 		// create and push a tag
-		_, _, err := gitcmd.NewCommand("tag", "v2.0").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err := gitcmd.NewCommand("tag", "v2.0").WithDir(dstPath).RunStdString(t.Context())
 		assert.NoError(t, err)
-		_, _, err = gitcmd.NewCommand("push", "origin", "--tags", "v2.0").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err = gitcmd.NewCommand("push", "origin", "--tags", "v2.0").WithDir(dstPath).RunStdString(t.Context())
 		assert.NoError(t, err)
 		// create a release for the tag
 		createdRelease := createNewReleaseUsingAPI(t, token, owner, repo, "v2.0", "", "Release of v2.0", "desc")
 		assert.False(t, createdRelease.IsDraft)
 		// delete the tag
-		_, _, err = gitcmd.NewCommand("push", "origin", "--delete", "v2.0").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err = gitcmd.NewCommand("push", "origin", "--delete", "v2.0").WithDir(dstPath).RunStdString(t.Context())
 		assert.NoError(t, err)
 		// query the release by API and it should be a draft
 		req := NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/%s/releases/tags/%s", owner.Name, repo.Name, "v2.0"))
@@ -154,7 +156,7 @@ func TestRepushTag(t *testing.T) {
 		DecodeJSON(t, resp, &respRelease)
 		assert.True(t, respRelease.IsDraft)
 		// re-push the tag
-		_, _, err = gitcmd.NewCommand("push", "origin", "--tags", "v2.0").RunStdString(t.Context(), &gitcmd.RunOpts{Dir: dstPath})
+		_, _, err = gitcmd.NewCommand("push", "origin", "--tags", "v2.0").WithDir(dstPath).RunStdString(t.Context())
 		assert.NoError(t, err)
 		// query the release by API and it should not be a draft
 		req = NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/%s/releases/tags/%s", owner.Name, repo.Name, "v2.0"))