feat: bump the minimum required Git version from 2.0.0 to 2.34.1 (#8328)

- Resolves forgejo/discussions#324
- Remove all checks of `CheckGitVersionAtLeast` that checked for a version below 2.34.1
- The version was chosen because Debian stable supports 2.39.5 and Ubuntu 22.04 LTS supports 2.34.1

Reviewed-on: https://codeberg.org/forgejo/forgejo/pulls/8328
Reviewed-by: 0ko <0ko@noreply.codeberg.org>
Reviewed-by: Earl Warren <earl-warren@noreply.codeberg.org>
Co-authored-by: Gusted <postmaster@gusted.xyz>
Co-committed-by: Gusted <postmaster@gusted.xyz>

.forgejo/workflows/testing-integration.yml

@@ -33,11 +33,20 @@ jobs:
     steps:
       - uses: https://data.forgejo.org/actions/checkout@v4
       - uses: ./.forgejo/workflows-composite/setup-env
-      - name: install git 2.30
-        uses: ./.forgejo/workflows-composite/apt-install-from
-        with:
-          packages: git/bullseye git-lfs/bullseye
-          release: bullseye
+      - name: install git 2.34.1
+        run: |
+          export DEBIAN_FRONTEND=noninteractive
+
+          apt-get update -qq
+          apt-get -q install -y -qq curl ca-certificates
+
+          curl -sS -o git-man.deb http://archive.ubuntu.com/ubuntu/pool/main/g/git/git-man_2.34.1-1ubuntu1_all.deb
+          curl -sS -o git.deb https://archive.ubuntu.com/ubuntu/pool/main/g/git/git_2.34.1-1ubuntu1_amd64.deb
+          curl -sS -o git-lfs.deb https://archive.ubuntu.com/ubuntu/pool/universe/g/git-lfs/git-lfs_3.0.2-1_amd64.deb
+
+          apt-get -q install -y -qq ./git-man.deb
+          apt-get -q install -y -qq ./git.deb
+          apt-get -q install -y -qq ./git-lfs.deb
       - uses: ./.forgejo/workflows-composite/build-backend
       - run: |
           su forgejo -c 'make test-backend test-check'

cmd/hook.go

@@ -231,8 +231,6 @@ Forgejo or set your environment appropriately.`, "")
 		}
 	}
 
-	supportProcReceive := git.CheckGitVersionAtLeast("2.29") == nil
-
 	for scanner.Scan() {
 		// TODO: support news feeds for wiki
 		if isWiki {
@@ -250,31 +248,25 @@ Forgejo or set your environment appropriately.`, "")
 		total++
 		lastline++
 
-		// If the ref is a branch or tag, check if it's protected
-		// if supportProcReceive all ref should be checked because
-		// permission check was delayed
-		if supportProcReceive || refFullName.IsBranch() || refFullName.IsTag() {
-			oldCommitIDs[count] = oldCommitID
-			newCommitIDs[count] = newCommitID
-			refFullNames[count] = refFullName
-			count++
-			fmt.Fprint(out, "*")
+		// All references should be checked because permission check was delayed.
+		oldCommitIDs[count] = oldCommitID
+		newCommitIDs[count] = newCommitID
+		refFullNames[count] = refFullName
+		count++
+		fmt.Fprint(out, "*")
 
-			if count >= hookBatchSize {
-				fmt.Fprintf(out, " Checking %d references\n", count)
+		if count >= hookBatchSize {
+			fmt.Fprintf(out, " Checking %d references\n", count)
 
-				hookOptions.OldCommitIDs = oldCommitIDs
-				hookOptions.NewCommitIDs = newCommitIDs
-				hookOptions.RefFullNames = refFullNames
-				extra := private.HookPreReceive(ctx, username, reponame, hookOptions)
-				if extra.HasError() {
-					return fail(ctx, extra.UserMsg, "HookPreReceive(batch) failed: %v", extra.Error)
-				}
-				count = 0
-				lastline = 0
+			hookOptions.OldCommitIDs = oldCommitIDs
+			hookOptions.NewCommitIDs = newCommitIDs
+			hookOptions.RefFullNames = refFullNames
+			extra := private.HookPreReceive(ctx, username, reponame, hookOptions)
+			if extra.HasError() {
+				return fail(ctx, extra.UserMsg, "HookPreReceive(batch) failed: %v", extra.Error)
 			}
-		} else {
-			fmt.Fprint(out, ".")
+			count = 0
+			lastline = 0
 		}
 		if lastline >= hookBatchSize {
 			fmt.Fprint(out, "\n")
@@ -513,10 +505,6 @@ Forgejo or set your environment appropriately.`, "")
 		return nil
 	}
 
-	if git.CheckGitVersionAtLeast("2.29") != nil {
-		return fail(ctx, "No proc-receive support", "current git version doesn't support proc-receive.")
-	}
-
 	reader := bufio.NewReader(os.Stdin)
 	repoUser := os.Getenv(repo_module.EnvRepoUsername)
 	repoName := os.Getenv(repo_module.EnvRepoName)

cmd/serv.go

@@ -193,12 +193,10 @@ func runServ(ctx context.Context, c *cli.Command) error {
 	}
 
 	if len(words) < 2 {
-		if git.CheckGitVersionAtLeast("2.29") == nil {
-			// for AGit Flow
-			if cmd == "ssh_info" {
-				fmt.Print(`{"type":"agit","version":1}`)
-				return nil
-			}
+		// for AGit Flow
+		if cmd == "ssh_info" {
+			fmt.Print(`{"type":"agit","version":1}`)
+			return nil
 		}
 		return fail(ctx, "Too few arguments", "Too few arguments in cmd: %s", cmd)
 	}

modules/git/blame.go

@@ -132,7 +132,7 @@ func (r *BlameReader) Close() error {
 // CreateBlameReader creates reader for given repository, commit and file
 func CreateBlameReader(ctx context.Context, objectFormat ObjectFormat, repoPath string, commit *Commit, file string, bypassBlameIgnore bool) (*BlameReader, error) {
 	var ignoreRevsFile *string
-	if CheckGitVersionAtLeast("2.23") == nil && !bypassBlameIgnore {
+	if !bypassBlameIgnore {
 		ignoreRevsFile = tryCreateBlameIgnoreRevsFile(commit)
 	}
 

modules/git/commit.go

@@ -412,11 +412,7 @@ func (c *Commit) GetSubModule(entryname string) (string, error) {
 
 // GetBranchName gets the closest branch name (as returned by 'git name-rev --name-only')
 func (c *Commit) GetBranchName() (string, error) {
-	cmd := NewCommand(c.repo.Ctx, "name-rev")
-	if CheckGitVersionAtLeast("2.13.0") == nil {
-		cmd.AddArguments("--exclude", "refs/tags/*")
-	}
-	cmd.AddArguments("--name-only", "--no-undefined").AddDynamicArguments(c.ID.String())
+	cmd := NewCommand(c.repo.Ctx, "name-rev", "--exclude", "refs/tags/*", "--name-only", "--no-undefined").AddDynamicArguments(c.ID.String())
 	data, _, err := cmd.RunStdString(&RunOpts{Dir: c.repo.Path})
 	if err != nil {
 		// handle special case where git can not describe commit

modules/git/git.go

@@ -23,7 +23,7 @@ import (
 )
 
 // RequiredVersion is the minimum Git version required
-const RequiredVersion = "2.0.0"
+const RequiredVersion = "2.34.1"
 
 var (
 	// GitExecutable is the command name of git
@@ -33,7 +33,6 @@ var (
 	// DefaultContext is the default context to run git commands in, must be initialized by git.InitXxx
 	DefaultContext context.Context
 
-	SupportProcReceive     bool // >= 2.29
 	SupportHashSha256      bool // >= 2.42, SHA-256 repositories no longer an ‘experimental curiosity’
 	InvertedGitFlushEnv    bool // 2.43.1
 	SupportCheckAttrOnBare bool // >= 2.40
@@ -113,7 +112,7 @@ func VersionInfo() string {
 	format := "%s"
 	args := []any{GitVersion.Original()}
 	// Since git wire protocol has been released from git v2.18
-	if setting.Git.EnableAutoGitWireProtocol && CheckGitVersionAtLeast("2.18") == nil {
+	if setting.Git.EnableAutoGitWireProtocol {
 		format += ", Wire Protocol %s Enabled"
 		args = append(args, "Version 2") // for focus color
 	}
@@ -172,16 +171,13 @@ func InitFull(ctx context.Context) (err error) {
 		_ = os.Setenv("GNUPGHOME", filepath.Join(HomeDir(), ".gnupg"))
 	}
 
-	// Since git wire protocol has been released from git v2.18
-	if setting.Git.EnableAutoGitWireProtocol && CheckGitVersionAtLeast("2.18") == nil {
+	if setting.Git.EnableAutoGitWireProtocol {
 		globalCommandArgs = append(globalCommandArgs, "-c", "protocol.version=2")
 	}
 
 	// Explicitly disable credential helper, otherwise Git credentials might leak
-	if CheckGitVersionAtLeast("2.9") == nil {
-		globalCommandArgs = append(globalCommandArgs, "-c", "credential.helper=")
-	}
-	SupportProcReceive = CheckGitVersionAtLeast("2.29") == nil
+	globalCommandArgs = append(globalCommandArgs, "-c", "credential.helper=")
+
 	SupportHashSha256 = CheckGitVersionAtLeast("2.42") == nil
 	SupportCheckAttrOnBare = CheckGitVersionAtLeast("2.40") == nil
 	if SupportHashSha256 {
@@ -195,9 +191,6 @@ func InitFull(ctx context.Context) (err error) {
 	SupportGrepMaxCount = CheckGitVersionAtLeast("2.38") == nil
 
 	if setting.LFS.StartServer {
-		if CheckGitVersionAtLeast("2.1.2") != nil {
-			return errors.New("LFS server support requires Git >= 2.1.2")
-		}
 		globalCommandArgs = append(globalCommandArgs, "-c", "filter.lfs.required=", "-c", "filter.lfs.smudge=", "-c", "filter.lfs.clean=")
 	}
 
@@ -234,38 +227,28 @@ func syncGitConfig() (err error) {
 		}
 	}
 
-	// Set git some configurations - these must be set to these values for gitea to work correctly
+	// Set git some configurations - these must be set to these values for forgejo to work correctly
 	if err := configSet("core.quotePath", "false"); err != nil {
 		return err
 	}
 
-	if CheckGitVersionAtLeast("2.10") == nil {
-		if err := configSet("receive.advertisePushOptions", "true"); err != nil {
-			return err
-		}
+	if err := configSet("receive.advertisePushOptions", "true"); err != nil {
+		return err
 	}
 
-	if CheckGitVersionAtLeast("2.18") == nil {
-		if err := configSet("core.commitGraph", "true"); err != nil {
-			return err
-		}
-		if err := configSet("gc.writeCommitGraph", "true"); err != nil {
-			return err
-		}
-		if err := configSet("fetch.writeCommitGraph", "true"); err != nil {
-			return err
-		}
+	if err := configSet("core.commitGraph", "true"); err != nil {
+		return err
+	}
+	if err := configSet("gc.writeCommitGraph", "true"); err != nil {
+		return err
+	}
+	if err := configSet("fetch.writeCommitGraph", "true"); err != nil {
+		return err
 	}
 
-	if SupportProcReceive {
-		// set support for AGit flow
-		if err := configAddNonExist("receive.procReceiveRefs", "refs/for"); err != nil {
-			return err
-		}
-	} else {
-		if err := configUnsetAll("receive.procReceiveRefs", "refs/for"); err != nil {
-			return err
-		}
+	// set support for AGit flow
+	if err := configAddNonExist("receive.procReceiveRefs", "refs/for"); err != nil {
+		return err
 	}
 
 	// Due to CVE-2022-24765, git now denies access to git directories which are not owned by current user
@@ -284,11 +267,6 @@ func syncGitConfig() (err error) {
 
 	switch setting.Repository.Signing.Format {
 	case "ssh":
-		// First do a git version check.
-		if CheckGitVersionAtLeast("2.34.0") != nil {
-			return errors.New("ssh signing requires Git >= 2.34.0")
-		}
-
 		// Get the ssh-keygen binary that Git will use.
 		// This can be overridden in app.ini in [git.config] section, so we must
 		// query this information.
@@ -325,8 +303,7 @@ func syncGitConfig() (err error) {
 		}
 	}
 
-	// By default partial clones are disabled, enable them from git v2.22
-	if !setting.Git.DisablePartialClone && CheckGitVersionAtLeast("2.22") == nil {
+	if !setting.Git.DisablePartialClone {
 		if err = configSet("uploadpack.allowfilter", "true"); err != nil {
 			return err
 		}

modules/git/git_test.go

@@ -14,7 +14,6 @@ import (
 	"forgejo.org/modules/test"
 	"forgejo.org/modules/util"
 
-	"github.com/hashicorp/go-version"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -105,10 +104,6 @@ func TestSyncConfigGPGFormat(t *testing.T) {
 	})
 
 	t.Run("SSH format", func(t *testing.T) {
-		if CheckGitVersionAtLeast("2.34.0") != nil {
-			t.SkipNow()
-		}
-
 		r, err := os.OpenRoot(t.TempDir())
 		require.NoError(t, err)
 		f, err := r.OpenFile("ssh-keygen", os.O_CREATE|os.O_TRUNC, 0o700)
@@ -121,13 +116,6 @@ func TestSyncConfigGPGFormat(t *testing.T) {
 		assert.True(t, gitConfigContains("[gpg]"))
 		assert.True(t, gitConfigContains("format = ssh"))
 
-		t.Run("Old version", func(t *testing.T) {
-			oldVersion, err := version.NewVersion("2.33.0")
-			require.NoError(t, err)
-			defer test.MockVariableValue(&GitVersion, oldVersion)()
-			require.ErrorContains(t, syncGitConfig(), "ssh signing requires Git >= 2.34.0")
-		})
-
 		t.Run("No ssh-keygen binary", func(t *testing.T) {
 			require.NoError(t, r.Remove("ssh-keygen"))
 			require.ErrorContains(t, syncGitConfig(), "git signing requires a ssh-keygen binary")

modules/git/pipeline/revlist.go

@@ -16,26 +16,6 @@ import (
 	"forgejo.org/modules/log"
 )
 
-// RevListAllObjects runs rev-list --objects --all and writes to a pipewriter
-func RevListAllObjects(ctx context.Context, revListWriter *io.PipeWriter, wg *sync.WaitGroup, basePath string, errChan chan<- error) {
-	defer wg.Done()
-	defer revListWriter.Close()
-
-	stderr := new(bytes.Buffer)
-	var errbuf strings.Builder
-	cmd := git.NewCommand(ctx, "rev-list", "--objects", "--all")
-	if err := cmd.Run(&git.RunOpts{
-		Dir:    basePath,
-		Stdout: revListWriter,
-		Stderr: stderr,
-	}); err != nil {
-		log.Error("git rev-list --objects --all [%s]: %v - %s", basePath, err, errbuf.String())
-		err = fmt.Errorf("git rev-list --objects --all [%s]: %w - %s", basePath, err, errbuf.String())
-		_ = revListWriter.CloseWithError(err)
-		errChan <- err
-	}
-}
-
 // RevListObjects run rev-list --objects from headSHA to baseSHA
 func RevListObjects(ctx context.Context, revListWriter *io.PipeWriter, wg *sync.WaitGroup, tmpBasePath, headSHA, baseSHA string, errChan chan<- error) {
 	defer wg.Done()

modules/git/remote.go

@@ -12,14 +12,7 @@ import (
 
 // GetRemoteAddress returns remote url of git repository in the repoPath with special remote name
 func GetRemoteAddress(ctx context.Context, repoPath, remoteName string) (string, error) {
-	var cmd *Command
-	if CheckGitVersionAtLeast("2.7") == nil {
-		cmd = NewCommand(ctx, "remote", "get-url").AddDynamicArguments(remoteName)
-	} else {
-		cmd = NewCommand(ctx, "config", "--get").AddDynamicArguments("remote." + remoteName + ".url")
-	}
-
-	result, _, err := cmd.RunStdString(&RunOpts{Dir: repoPath})
+	result, _, err := NewCommand(ctx, "remote", "get-url").AddDynamicArguments(remoteName).RunStdString(&RunOpts{Dir: repoPath})
 	if err != nil {
 		return "", err
 	}

modules/git/repo_commit.go

@@ -443,42 +443,18 @@ func (repo *Repository) getCommitsBeforeLimit(id ObjectID, num int) ([]*Commit,
 }
 
 func (repo *Repository) getBranches(commit *Commit, limit int) ([]string, error) {
-	if CheckGitVersionAtLeast("2.7.0") == nil {
-		command := NewCommand(repo.Ctx, "for-each-ref", "--format=%(refname:strip=2)").AddOptionValues("--contains", commit.ID.String(), BranchPrefix)
+	command := NewCommand(repo.Ctx, "for-each-ref", "--format=%(refname:strip=2)").AddOptionValues("--contains", commit.ID.String(), BranchPrefix)
 
-		if limit != -1 {
-			command = command.AddOptionFormat("--count=%d", limit)
-		}
-
-		stdout, _, err := command.RunStdString(&RunOpts{Dir: repo.Path})
-		if err != nil {
-			return nil, err
-		}
-
-		branches := strings.Fields(stdout)
-		return branches, nil
+	if limit != -1 {
+		command = command.AddOptionFormat("--count=%d", limit)
 	}
 
-	stdout, _, err := NewCommand(repo.Ctx, "branch").AddOptionValues("--contains", commit.ID.String()).RunStdString(&RunOpts{Dir: repo.Path})
+	stdout, _, err := command.RunStdString(&RunOpts{Dir: repo.Path})
 	if err != nil {
 		return nil, err
 	}
 
-	refs := strings.Split(stdout, "\n")
-
-	var max int
-	if len(refs) > limit {
-		max = limit
-	} else {
-		max = len(refs) - 1
-	}
-
-	branches := make([]string, max)
-	for i, ref := range refs[:max] {
-		parts := strings.Fields(ref)
-
-		branches[i] = parts[len(parts)-1]
-	}
+	branches := strings.Fields(stdout)
 	return branches, nil
 }
 

modules/git/repo_commitgraph.go

@@ -11,10 +11,8 @@ import (
 // WriteCommitGraph write commit graph to speed up repo access
 // this requires git v2.18 to be installed
 func WriteCommitGraph(ctx context.Context, repoPath string) error {
-	if CheckGitVersionAtLeast("2.18") == nil {
-		if _, _, err := NewCommand(ctx, "commit-graph", "write").RunStdString(&RunOpts{Dir: repoPath}); err != nil {
-			return fmt.Errorf("unable to write commit-graph for '%s' : %w", repoPath, err)
-		}
+	if _, _, err := NewCommand(ctx, "commit-graph", "write").RunStdString(&RunOpts{Dir: repoPath}); err != nil {
+		return fmt.Errorf("unable to write commit-graph for '%s' : %w", repoPath, err)
 	}
 	return nil
 }

modules/lfs/pointer_scanner.go

@@ -39,16 +39,7 @@ func SearchPointerBlobs(ctx context.Context, repo *git.Repository, pointerChan c
 	go pipeline.BlobsLessThan1024FromCatFileBatchCheck(catFileCheckReader, shasToBatchWriter, &wg)
 
 	// 1. Run batch-check on all objects in the repository
-	if git.CheckGitVersionAtLeast("2.6.0") != nil {
-		revListReader, revListWriter := io.Pipe()
-		shasToCheckReader, shasToCheckWriter := io.Pipe()
-		wg.Add(2)
-		go pipeline.CatFileBatchCheck(ctx, shasToCheckReader, catFileCheckWriter, &wg, basePath)
-		go pipeline.BlobsFromRevListObjects(revListReader, shasToCheckWriter, &wg)
-		go pipeline.RevListAllObjects(ctx, revListWriter, &wg, basePath, errChan)
-	} else {
-		go pipeline.CatFileBatchCheckAllObjects(ctx, catFileCheckWriter, &wg, basePath, errChan)
-	}
+	go pipeline.CatFileBatchCheckAllObjects(ctx, catFileCheckWriter, &wg, basePath, errChan)
 	wg.Wait()
 
 	close(pointerChan)

routers/private/hook_post_receive.go

@@ -205,7 +205,7 @@ func HookPostReceive(ctx *gitea_context.PrivateContext) {
 
 		// post update for agit pull request
 		// FIXME: use pr.Flow to test whether it's an Agit PR or a GH PR
-		if git.SupportProcReceive && refFullName.IsPull() {
+		if refFullName.IsPull() {
 			if repo == nil {
 				repo = loadRepository(ctx, ownerName, repoName)
 				if ctx.Written() {

routers/private/hook_pre_receive.go

@@ -205,7 +205,7 @@ func HookPreReceive(ctx *gitea_context.PrivateContext) {
 			preReceiveBranch(ourCtx, oldCommitID, newCommitID, refFullName)
 		case refFullName.IsTag():
 			preReceiveTag(ourCtx, oldCommitID, newCommitID, refFullName)
-		case git.SupportProcReceive && refFullName.IsFor():
+		case refFullName.IsFor():
 			preReceiveFor(ourCtx, oldCommitID, newCommitID, refFullName)
 		default:
 			if ourCtx.isOverQuota {

routers/private/hook_proc_receive.go

@@ -7,7 +7,6 @@ import (
 	"net/http"
 
 	repo_model "forgejo.org/models/repo"
-	"forgejo.org/modules/git"
 	"forgejo.org/modules/log"
 	"forgejo.org/modules/private"
 	"forgejo.org/modules/web"
@@ -18,10 +17,6 @@ import (
 // HookProcReceive proc-receive hook - only handles agit Proc-Receive requests at present
 func HookProcReceive(ctx *gitea_context.PrivateContext) {
 	opts := web.GetForm(ctx).(*private.HookOptions)
-	if !git.SupportProcReceive {
-		ctx.Status(http.StatusNotFound)
-		return
-	}
 
 	results, err := agit.ProcReceive(ctx, ctx.Repo.Repository, ctx.Repo.GitRepo, opts)
 	if err != nil {

routers/private/serv.go

@@ -14,7 +14,6 @@ import (
 	repo_model "forgejo.org/models/repo"
 	"forgejo.org/models/unit"
 	user_model "forgejo.org/models/user"
-	"forgejo.org/modules/git"
 	"forgejo.org/modules/log"
 	"forgejo.org/modules/private"
 	"forgejo.org/modules/setting"
@@ -303,7 +302,7 @@ func ServCommand(ctx *context.PrivateContext) {
 			// the permission check to read. The pre-receive hook will do another
 			// permission check which ensure for non AGit flow references the write
 			// permission is checked.
-			if git.SupportProcReceive && unitType == unit.TypeCode && ctx.FormString("verb") == "git-receive-pack" {
+			if unitType == unit.TypeCode && ctx.FormString("verb") == "git-receive-pack" {
 				mode = perm.AccessModeRead
 			}
 

routers/web/misc/misc.go

@@ -7,7 +7,6 @@ import (
 	"net/http"
 	"path"
 
-	"forgejo.org/modules/git"
 	"forgejo.org/modules/httpcache"
 	"forgejo.org/modules/log"
 	"forgejo.org/modules/setting"
@@ -15,10 +14,6 @@ import (
 )
 
 func SSHInfo(rw http.ResponseWriter, req *http.Request) {
-	if !git.SupportProcReceive {
-		rw.WriteHeader(http.StatusNotFound)
-		return
-	}
 	rw.Header().Set("content-type", "text/json;charset=UTF-8")
 	_, err := rw.Write([]byte(`{"type":"agit","version":1}`))
 	if err != nil {

routers/web/repo/githttp.go

@@ -183,9 +183,7 @@ func httpBase(ctx *context.Context) *serviceHandler {
 
 		if repoExist {
 			// Because of special ref "refs/for" .. , need delay write permission check
-			if git.SupportProcReceive {
-				accessMode = perm.AccessModeRead
-			}
+			accessMode = perm.AccessModeRead
 
 			if ctx.Data["IsActionsToken"] == true {
 				taskID := ctx.Data["ActionsTaskID"].(int64)

services/gitdiff/gitdiff.go

@@ -1157,7 +1157,7 @@ func GetDiffSimple(ctx context.Context, gitRepo *git.Repository, opts *DiffOptio
 	// so if we are using at least this version of git we don't have to tell ParsePatch to do
 	// the skipping for us
 	parsePatchSkipToFile := opts.SkipTo
-	if opts.SkipTo != "" && git.CheckGitVersionAtLeast("2.31") == nil {
+	if opts.SkipTo != "" {
 		cmdDiff.AddOptionFormat("--skip-to=%s", opts.SkipTo)
 		parsePatchSkipToFile = ""
 	}

services/pull/temp_repo.go

@@ -103,11 +103,7 @@ func createTemporaryRepoForPR(ctx context.Context, pr *issues_model.PullRequest)
 	remoteRepoName := "head_repo"
 	baseBranch := "base"
 
-	fetchArgs := git.TrustedCmdArgs{"--no-tags"}
-	if git.CheckGitVersionAtLeast("2.25.0") == nil {
-		// Writing the commit graph can be slow and is not needed here
-		fetchArgs = append(fetchArgs, "--no-write-commit-graph")
-	}
+	fetchArgs := git.TrustedCmdArgs{"--no-tags", "--no-write-commit-graph"}
 
 	// addCacheRepo adds git alternatives for the cacheRepoPath in the repoPath
 	addCacheRepo := func(repoPath, cacheRepoPath string) error {

services/repository/files/patch.go

@@ -147,11 +147,7 @@ func ApplyDiffPatch(ctx context.Context, repo *repo_model.Repository, doer *user
 	stdout := &strings.Builder{}
 	stderr := &strings.Builder{}
 
-	cmdApply := git.NewCommand(ctx, "apply", "--index", "--recount", "--cached", "--ignore-whitespace", "--whitespace=fix", "--binary")
-	if git.CheckGitVersionAtLeast("2.32") == nil {
-		cmdApply.AddArguments("-3")
-	}
-
+	cmdApply := git.NewCommand(ctx, "apply", "--index", "--recount", "--cached", "--ignore-whitespace", "--whitespace=fix", "--binary", "-3")
 	if err := cmdApply.Run(&git.RunOpts{
 		Dir:    t.basePath,
 		Stdout: stdout,

tests/integration/git_test.go

@@ -771,11 +771,6 @@ func doCreateAgitFlowPull(dstPath string, ctx *APITestContext, headBranch string
 	return func(t *testing.T) {
 		defer tests.PrintCurrentTest(t)()
 
-		// skip this test if git version is low
-		if git.CheckGitVersionAtLeast("2.29") != nil {
-			return
-		}
-
 		gitRepo, err := git.OpenRepository(git.DefaultContext, dstPath)
 		require.NoError(t, err)
 

tests/integration/repo_signed_tag_test.go

@@ -25,10 +25,6 @@ import (
 )
 
 func TestRepoSSHSignedTags(t *testing.T) {
-	if git.CheckGitVersionAtLeast("2.34") != nil {
-		t.Skip("Skipping, does not support SSH signing")
-		return
-	}
 	defer tests.PrepareTestEnv(t)()
 
 	// Preparations

tests/integration/signing_git_test.go

@@ -42,10 +42,6 @@ func TestInstanceSigning(t *testing.T) {
 		defer test.MockProtect(&setting.Repository.Signing.CRUDActions)()
 
 		t.Run("SSH", func(t *testing.T) {
-			if git.CheckGitVersionAtLeast("2.34") != nil {
-				t.Skip("Skipping, does not support git SSH signing")
-				return
-			}
 			defer tests.PrintCurrentTest(t)()
 
 			pubKeyContent, err := os.ReadFile("tests/integration/ssh-signing-key.pub")