update integration test utilities to tage group id as argument

tests/integration/actions_approve_test.go

@@ -34,7 +34,7 @@ func TestApproveAllRunsOnPullRequestPage(t *testing.T) {
 
 		apiBaseRepo := createActionsTestRepo(t, user2Token, "approve-all-runs", false)
 		baseRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiBaseRepo.ID})
-		user2APICtx := NewAPITestContext(t, baseRepo.OwnerName, baseRepo.Name, auth_model.AccessTokenScopeWriteRepository)
+		user2APICtx := NewAPITestContext(t, baseRepo.OwnerName, baseRepo.Name, baseRepo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(user2APICtx)(t)
 
 		runner := newMockRunner()
@@ -51,7 +51,7 @@ jobs:
       - run: echo unit-test
 `
 		opts1 := getWorkflowCreateFileOptions(user2, baseRepo.DefaultBranch, "create %s"+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, baseRepo.GroupID, wf1TreePath, opts1)
 		wf2TreePath := ".gitea/workflows/pull_2.yml"
 		wf2FileContent := `name: Pull 2
 on: pull_request
@@ -62,7 +62,7 @@ jobs:
       - run: echo integration-test
 `
 		opts2 := getWorkflowCreateFileOptions(user2, baseRepo.DefaultBranch, "create %s"+wf2TreePath, wf2FileContent)
-		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, wf2TreePath, opts2)
+		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, baseRepo.GroupID, wf2TreePath, opts2)
 
 		// user4 forks the repo
 		req := NewRequestWithJSON(t, "POST", fmt.Sprintf("/api/v1/repos/%s/%s/forks", baseRepo.OwnerName, baseRepo.Name),
@@ -73,7 +73,7 @@ jobs:
 		var apiForkRepo api.Repository
 		DecodeJSON(t, resp, &apiForkRepo)
 		forkRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiForkRepo.ID})
-		user4APICtx := NewAPITestContext(t, user4.Name, forkRepo.Name, auth_model.AccessTokenScopeWriteRepository)
+		user4APICtx := NewAPITestContext(t, user4.Name, forkRepo.Name, forkRepo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(user4APICtx)(t)
 
 		// user4 creates a pull request from branch "bugfix/user4"

tests/integration/actions_concurrency_test.go

@@ -34,12 +34,11 @@ func TestWorkflowConcurrency(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner := newMockRunner()
 		runner.registerAsRepoRunner(t, user2.Name, repo.Name, "mock-runner", []string{"ubuntu-latest"}, false)
-
 		// add a variable for test
 		req := NewRequestWithJSON(t, "POST",
 			fmt.Sprintf("/api/v1/repos/%s/%s/actions/variables/myvar", user2.Name, repo.Name), &api.CreateVariableOption{
@@ -92,7 +91,7 @@ jobs:
 `
 		// push workflow1
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 		// fetch and exec workflow1
 		task := runner.fetchTask(t)
 		_, _, run := getTaskAndJobAndRunByTaskID(t, task.Id)
@@ -105,7 +104,7 @@ jobs:
 
 		// push workflow2
 		opts2 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf2TreePath, wf2FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf2TreePath, opts2)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf2TreePath, opts2)
 		// fetch workflow2
 		task = runner.fetchTask(t)
 		_, _, run = getTaskAndJobAndRunByTaskID(t, task.Id)
@@ -114,7 +113,7 @@ jobs:
 
 		// push workflow3
 		opts3 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf3TreePath, wf3FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf3TreePath, opts3)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf3TreePath, opts3)
 		runner.fetchNoTask(t)
 
 		// exec workflow2
@@ -142,7 +141,7 @@ func TestWorkflowConcurrencyShort(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner := newMockRunner()
@@ -197,7 +196,7 @@ jobs:
 `
 		// push workflow1
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 		// fetch and exec workflow1
 		task := runner.fetchTask(t)
 		_, _, run := getTaskAndJobAndRunByTaskID(t, task.Id)
@@ -210,7 +209,7 @@ jobs:
 
 		// push workflow2
 		opts2 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf2TreePath, wf2FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf2TreePath, opts2)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf2TreePath, opts2)
 		// fetch workflow2
 		task = runner.fetchTask(t)
 		_, _, run = getTaskAndJobAndRunByTaskID(t, task.Id)
@@ -219,7 +218,7 @@ jobs:
 
 		// push workflow3
 		opts3 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf3TreePath, wf3FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf3TreePath, opts3)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf3TreePath, opts3)
 		runner.fetchNoTask(t)
 
 		// exec workflow2
@@ -247,7 +246,7 @@ func TestWorkflowConcurrencyShortJson(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner := newMockRunner()
@@ -314,7 +313,7 @@ jobs:
 `
 		// push workflow1
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 		// fetch and exec workflow1
 		task := runner.fetchTask(t)
 		_, _, run := getTaskAndJobAndRunByTaskID(t, task.Id)
@@ -327,7 +326,7 @@ jobs:
 
 		// push workflow2
 		opts2 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf2TreePath, wf2FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf2TreePath, opts2)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf2TreePath, opts2)
 		// fetch workflow2
 		task = runner.fetchTask(t)
 		_, _, run = getTaskAndJobAndRunByTaskID(t, task.Id)
@@ -336,7 +335,7 @@ jobs:
 
 		// push workflow3
 		opts3 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf3TreePath, wf3FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf3TreePath, opts3)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf3TreePath, opts3)
 		runner.fetchNoTask(t)
 
 		// exec workflow2
@@ -368,7 +367,7 @@ func TestPullRequestWorkflowConcurrency(t *testing.T) {
 
 		apiBaseRepo := createActionsTestRepo(t, user2Token, "actions-concurrency", false)
 		baseRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiBaseRepo.ID})
-		user2APICtx := NewAPITestContext(t, baseRepo.OwnerName, baseRepo.Name, auth_model.AccessTokenScopeWriteRepository)
+		user2APICtx := NewAPITestContext(t, baseRepo.OwnerName, baseRepo.Name, baseRepo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(user2APICtx)(t)
 
 		runner := newMockRunner()
@@ -388,7 +387,7 @@ jobs:
       - run: echo 'test the pull'
 `
 		opts1 := getWorkflowCreateFileOptions(user2, baseRepo.DefaultBranch, "create %s"+wfTreePath, wfFileContent)
-		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, wfTreePath, opts1)
+		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, baseRepo.GroupID, wfTreePath, opts1)
 		// user2 creates a pull request
 		doAPICreateFile(user2APICtx, "user2-fix.txt", &api.CreateFileOptions{
 			FileOptions: api.FileOptions{
@@ -425,7 +424,7 @@ jobs:
 		var apiForkRepo api.Repository
 		DecodeJSON(t, resp, &apiForkRepo)
 		forkRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiForkRepo.ID})
-		user4APICtx := NewAPITestContext(t, user4.Name, forkRepo.Name, auth_model.AccessTokenScopeWriteRepository)
+		user4APICtx := NewAPITestContext(t, user4.Name, forkRepo.Name, forkRepo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(user4APICtx)(t)
 
 		// user4 creates a pull request from branch "bugfix/bbb"
@@ -509,7 +508,7 @@ func TestJobConcurrency(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner1 := newMockRunner()
@@ -578,9 +577,9 @@ jobs:
 `
 
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 		opts2 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf2TreePath, wf2FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf2TreePath, opts2)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf2TreePath, opts2)
 
 		// fetch wf1-job1
 		wf1Job1Task := runner1.fetchTask(t)
@@ -608,7 +607,7 @@ jobs:
 		assert.Equal(t, actions_model.StatusRunning, wf2Job2ActionJob.Status)
 		// push workflow3 to trigger wf3-job1
 		opts3 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf3TreePath, wf3FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf3TreePath, opts3)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf3TreePath, opts3)
 		// fetch wf3-job1
 		wf3Job1Task := runner1.fetchTask(t)
 		_, wf3Job1ActionJob, _ := getTaskAndJobAndRunByTaskID(t, wf3Job1Task.Id)
@@ -663,7 +662,7 @@ func TestMatrixConcurrency(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		linuxRunner := newMockRunner()
@@ -710,7 +709,7 @@ jobs:
 `
 
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 
 		job1WinTask := windowsRunner.fetchTask(t)
 		job1LinuxTask := linuxRunner.fetchTask(t)
@@ -724,7 +723,7 @@ jobs:
 		assert.Equal(t, "job-os-linux", job1LinuxJob.ConcurrencyGroup)
 
 		opts2 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf2TreePath, wf2FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf2TreePath, opts2)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf2TreePath, opts2)
 		job2DarwinTask := darwinRunner.fetchTask(t)
 		_, job2DarwinJob, _ := getTaskAndJobAndRunByTaskID(t, job2DarwinTask.Id)
 		assert.Equal(t, "wf2-job (darwin)", job2DarwinJob.Name)
@@ -756,7 +755,7 @@ func TestWorkflowDispatchConcurrency(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner := newMockRunner()
@@ -792,7 +791,7 @@ jobs:
 `
 
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 
 		// run the workflow with appVersion=v1.21 and cancel=false
 		urlStr := fmt.Sprintf("/%s/%s/actions/run?workflow=%s", user2.Name, repo.Name, "workflow-dispatch-concurrency.yml")
@@ -846,7 +845,7 @@ func TestWorkflowDispatchRerunAllJobsConcurrency(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner := newMockRunner()
@@ -882,7 +881,7 @@ jobs:
 `
 
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 
 		// run the workflow with appVersion=v1.21 and cancel=false
 		urlStr := fmt.Sprintf("/%s/%s/actions/run?workflow=%s", user2.Name, repo.Name, "workflow-dispatch-concurrency.yml")
@@ -984,7 +983,7 @@ func TestWorkflowDispatchRerunSingleJobConcurrency(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner := newMockRunner()
@@ -1020,7 +1019,7 @@ jobs:
 `
 
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 
 		// run the workflow with appVersion=v1.21 and cancel=false
 		urlStr := fmt.Sprintf("/%s/%s/actions/run?workflow=%s", user2.Name, repo.Name, "workflow-dispatch-concurrency.yml")
@@ -1119,7 +1118,7 @@ func TestScheduleConcurrency(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner := newMockRunner()
@@ -1142,7 +1141,7 @@ jobs:
 `
 
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 
 		// fetch the task triggered by push
 		task1 := runner.fetchTask(t)
@@ -1221,7 +1220,7 @@ func TestWorkflowAndJobConcurrency(t *testing.T) {
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
 
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner1 := newMockRunner()
@@ -1310,7 +1309,7 @@ jobs:
 
 		// push workflow 1
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 
 		// fetch wf1-job1 and wf1-job2
 		w1j1Task := runner1.fetchTask(t)
@@ -1326,7 +1325,7 @@ jobs:
 
 		// push workflow 2
 		opts2 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf2TreePath, wf2FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf2TreePath, opts2)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf2TreePath, opts2)
 		// cannot fetch wf2-job1 and wf2-job2 because workflow-2 is blocked by workflow-1's concurrency group "workflow-group-1"
 		runner1.fetchNoTask(t)
 		runner2.fetchNoTask(t)
@@ -1337,7 +1336,7 @@ jobs:
 
 		// push workflow 3
 		opts3 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf3TreePath, wf3FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf3TreePath, opts3)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf3TreePath, opts3)
 		// cannot fetch wf3-job1 because it is blocked by wf1-job1's concurrency group "job-group-1"
 		runner1.fetchNoTask(t)
 		// query wf3-job1 from db and check its status
@@ -1376,7 +1375,7 @@ jobs:
 
 		// push workflow-4
 		opts4 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf4TreePath, wf4FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf4TreePath, opts4)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf4TreePath, opts4)
 		// cannot fetch wf4-job1 because it is blocked by workflow-3's concurrency group "workflow-group-2"
 		runner2.fetchNoTask(t)
 
@@ -1410,7 +1409,7 @@ func TestCancelConcurrentRun(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, user2Token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		user2APICtx := NewAPITestContext(t, repo.OwnerName, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		user2APICtx := NewAPITestContext(t, repo.OwnerName, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(user2APICtx)(t)
 
 		runner := newMockRunner()
@@ -1430,7 +1429,7 @@ jobs:
       - run: echo 'test'
 `
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wfTreePath, wfFileContent)
-		createWorkflowFile(t, user2Token, repo.OwnerName, repo.Name, wfTreePath, opts1)
+		createWorkflowFile(t, user2Token, repo.OwnerName, repo.Name, repo.GroupID, wfTreePath, opts1)
 
 		// fetch and check the first task
 		task1 := runner.fetchTask(t)
@@ -1487,7 +1486,7 @@ func TestAbandonConcurrentRun(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, user2Token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		user2APICtx := NewAPITestContext(t, repo.OwnerName, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		user2APICtx := NewAPITestContext(t, repo.OwnerName, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(user2APICtx)(t)
 
 		runner := newMockRunner()
@@ -1528,7 +1527,7 @@ jobs:
 `
 		// push workflow1
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, user2Token, repo.OwnerName, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, user2Token, repo.OwnerName, repo.Name, repo.GroupID, wf1TreePath, opts1)
 
 		// fetch wf1-job1
 		w1j1Task := runner.fetchTask(t)
@@ -1546,7 +1545,7 @@ jobs:
 
 		// push workflow2
 		opts2 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf2TreePath, wf2FileContent)
-		createWorkflowFile(t, user2Token, repo.OwnerName, repo.Name, wf2TreePath, opts2)
+		createWorkflowFile(t, user2Token, repo.OwnerName, repo.Name, repo.GroupID, wf2TreePath, opts2)
 
 		// query run2 from db and check its status
 		run2 := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{RepoID: repo.ID, WorkflowID: "workflow-2.yml"})
@@ -1586,7 +1585,7 @@ func TestRunAndJobWithSameConcurrencyGroup(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner := newMockRunner()
@@ -1637,7 +1636,7 @@ jobs:
 `
 		// push workflow1
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 		// fetch run1
 		task := runner.fetchTask(t)
 		_, job1, run1 := getTaskAndJobAndRunByTaskID(t, task.Id)
@@ -1646,7 +1645,7 @@ jobs:
 
 		// push workflow2
 		opts2 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf2TreePath, wf2FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf2TreePath, opts2)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf2TreePath, opts2)
 		// cannot fetch run2 because run1 is still running
 		runner.fetchNoTask(t)
 		run2 := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{RepoID: repo.ID, WorkflowID: "concurrent-workflow-2.yml"})
@@ -1665,7 +1664,7 @@ jobs:
 
 		// push workflow3
 		opts3 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wf3TreePath, wf3FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf3TreePath, opts3)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf3TreePath, opts3)
 		// fetch run3
 		task3 := runner.fetchTask(t)
 		_, job3, run3 := getTaskAndJobAndRunByTaskID(t, task3.Id)

tests/integration/actions_delete_run_test.go

@@ -120,7 +120,7 @@ jobs:
 		runner.registerAsRepoRunner(t, user2.Name, apiRepo.Name, "mock-runner", []string{"ubuntu-latest"}, false)
 
 		opts := getWorkflowCreateFileOptions(user2, apiRepo.DefaultBranch, "create "+testCase.treePath, testCase.fileContent)
-		createWorkflowFile(t, token, user2.Name, apiRepo.Name, testCase.treePath, apiRepo.GroupID, opts)
+		createWorkflowFile(t, token, user2.Name, apiRepo.Name, apiRepo.GroupID, testCase.treePath, opts)
 
 		var runID int64
 		for i := 0; i < len(testCase.outcomes); i++ {

tests/integration/actions_inputs_test.go

@@ -26,7 +26,7 @@ func TestWorkflowWithInputsContext(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-inputs-context", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		wRunner := newMockRunner()
@@ -57,7 +57,7 @@ jobs:
 `
 
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create %s"+wf1TreePath, wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wf1TreePath, opts1)
 
 		// run the workflow with os=windows
 		urlStr := fmt.Sprintf("/%s/%s/actions/run?workflow=%s", user2.Name, repo.Name, "test-inputs-context.yml")

tests/integration/actions_job_test.go

@@ -142,7 +142,7 @@ jobs:
 			t.Run("test "+tc.treePath, func(t *testing.T) {
 				// create the workflow file
 				opts := getWorkflowCreateFileOptions(user2, apiRepo.DefaultBranch, "create "+tc.treePath, tc.fileContent)
-				fileResp := createWorkflowFile(t, token, user2.Name, apiRepo.Name, tc.treePath, apiRepo.GroupID, opts)
+				fileResp := createWorkflowFile(t, token, user2.Name, apiRepo.Name, apiRepo.GroupID, tc.treePath, opts)
 
 				// fetch and execute task
 				for i := 0; i < len(tc.outcomes); i++ {
@@ -154,7 +154,11 @@ jobs:
 				}
 
 				// check result
-				req := NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/%d/%s/actions/tasks", user2.Name, apiRepo.GroupID, apiRepo.Name)).
+				var groupSegment string
+				if apiRepo.GroupID > 0 {
+					groupSegment = fmt.Sprintf("%d/", apiRepo.GroupID)
+				}
+				req := NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/%s%s/actions/tasks", user2.Name, groupSegment, apiRepo.Name)).
 					AddTokenAuth(token)
 				resp := MakeRequest(t, req, http.StatusOK)
 				var actionTaskRespAfter api.ActionTaskResponse
@@ -324,7 +328,7 @@ jobs:
 		for _, tc := range testCases {
 			t.Run("test "+tc.treePath, func(t *testing.T) {
 				opts := getWorkflowCreateFileOptions(user2, apiRepo.DefaultBranch, "create "+tc.treePath, tc.fileContent)
-				createWorkflowFile(t, token, user2.Name, apiRepo.Name, tc.treePath, apiRepo.GroupID, opts)
+				createWorkflowFile(t, token, user2.Name, apiRepo.Name, apiRepo.GroupID, tc.treePath, opts)
 
 				for i := 0; i < len(tc.outcomes); i++ {
 					task := runner.fetchTask(t)
@@ -441,7 +445,7 @@ jobs:
       - run: echo %s
 `, workflowName, workflowName)
 	opts := getWorkflowCreateFileOptions(user, apiRepo.DefaultBranch, "create workflow", wfContent)
-	createWorkflowFile(t, authToken, user.Name, apiRepo.Name, wfTreePath, opts)
+	createWorkflowFile(t, authToken, user.Name, apiRepo.Name, apiRepo.GroupID, wfTreePath, opts)
 
 	return &runnerDisableEnableTestData{
 		repo:     apiRepo,
@@ -453,7 +457,7 @@ jobs:
 func triggerRunnerDisableEnableRun(t *testing.T, user *user_model.User, authToken string, repo *api.Repository, treePath string) {
 	t.Helper()
 	opts := getWorkflowCreateFileOptions(user, repo.DefaultBranch, "second push", "second run")
-	createWorkflowFile(t, authToken, user.Name, repo.Name, treePath, opts)
+	createWorkflowFile(t, authToken, user.Name, repo.Name, repo.GroupID, treePath, opts)
 }
 
 func getRepoRunnerID(t *testing.T, authToken, ownerName, repoName string) int64 {
@@ -490,7 +494,7 @@ jobs:
       - run: echo 'test the pull'
 `
 		opts := getWorkflowCreateFileOptions(user2, baseRepo.DefaultBranch, "create "+wfTreePath, wfFileContent)
-		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, wfTreePath, baseRepo.GroupID, opts)
+		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, baseRepo.GroupID, wfTreePath, opts)
 		// user2 creates a pull request
 		doAPICreateFile(user2APICtx, "user2-patch.txt", &api.CreateFileOptions{
 			FileOptions: api.FileOptions{
@@ -582,7 +586,7 @@ jobs:
       - run: echo 'test the pull'
 `
 		opts := getWorkflowCreateFileOptions(user2, baseRepo.DefaultBranch, "create "+wfTreePath, wfFileContent)
-		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, wfTreePath, baseRepo.GroupID, opts)
+		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, baseRepo.GroupID, wfTreePath, opts)
 		// user2 creates a pull request
 		doAPICreateFile(user2APICtx, "user2-patch.txt", &api.CreateFileOptions{
 			FileOptions: api.FileOptions{
@@ -734,8 +738,12 @@ func getWorkflowCreateFileOptions(u *user_model.User, branch, msg, content strin
 	}
 }
 
-func createWorkflowFile(t *testing.T, authToken, ownerName, repoName, treePath string, groupID int64, opts *api.CreateFileOptions) *api.FileResponse {
-	req := NewRequestWithJSON(t, "POST", fmt.Sprintf("/api/v1/repos/%s/%d/%s/contents/%s", ownerName, groupID, repoName, treePath), opts).
+func createWorkflowFile(t *testing.T, authToken, ownerName, repoName string, groupID int64, treePath string, opts *api.CreateFileOptions) *api.FileResponse {
+	var groupSegment string
+	if groupID > 0 {
+		groupSegment = fmt.Sprintf("%d/", groupID)
+	}
+	req := NewRequestWithJSON(t, "POST", fmt.Sprintf("/api/v1/repos/%s/%s%s/contents/%s", ownerName, groupSegment, repoName, treePath), opts).
 		AddTokenAuth(authToken)
 	resp := MakeRequest(t, req, http.StatusCreated)
 	var fileResponse api.FileResponse

tests/integration/actions_job_token_test.go

@@ -418,7 +418,7 @@ jobs:
       - run: echo "test perms"
 `
 		opts := getWorkflowCreateFileOptions(user2, repo1.DefaultBranch, "create "+wfTreePath, wfFileContent)
-		createWorkflowFile(t, token, user2.Name, repo1.Name, wfTreePath, opts)
+		createWorkflowFile(t, token, user2.Name, repo1.Name, repo1.GroupID, wfTreePath, opts)
 
 		task1 := runner1.fetchTask(t)
 		task1Token := task1.Secrets["GITEA_TOKEN"]

tests/integration/actions_log_test.go

@@ -166,7 +166,7 @@ jobs:
 
 				// create the workflow file
 				opts := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+tc.treePath, tc.fileContent)
-				createWorkflowFile(t, token, user2.Name, repo.Name, tc.treePath, repo.GroupID, opts)
+				createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, tc.treePath, opts)
 
 				// fetch and execute tasks
 				for _, outcome := range tc.outcome {
@@ -198,7 +198,11 @@ jobs:
 					}
 
 					// download task logs from API and check content
-					req = NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/%d/%s/actions/jobs/%d/logs", user2.Name, repo.GroupID, repo.Name, job.ID)).
+					var groupSegment string
+					if repo.GroupID > 0 {
+						groupSegment = fmt.Sprintf("%d/", repo.GroupID)
+					}
+					req = NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/%s%s/actions/jobs/%d/logs", user2.Name, groupSegment, repo.Name, job.ID)).
 						AddTokenAuth(token)
 					resp = MakeRequest(t, req, http.StatusOK)
 					logTextLines = strings.Split(strings.TrimSpace(resp.Body.String()), "\n")

tests/integration/actions_rerun_test.go

@@ -25,7 +25,7 @@ func TestActionsRerun(t *testing.T) {
 
 		apiRepo := createActionsTestRepo(t, token, "actions-rerun", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		runner := newMockRunner()
@@ -50,7 +50,7 @@ jobs:
 `
 
 		opts := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create"+wfTreePath, wfFileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wfTreePath, opts)
+		createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wfTreePath, opts)
 
 		// fetch and exec job1
 		job1Task := runner.fetchTask(t)

tests/integration/actions_schedule_test.go

@@ -88,7 +88,7 @@ jobs:
 				assert.NoError(t, err)
 
 				// merge pull request
-				testPullMerge(t, testContext.Session, repo.OwnerName, repo.Name, strconv.FormatInt(apiPull.Index, 10), MergeOptions{
+				testPullMerge(t, testContext.Session, repo.OwnerName, repo.Name, repo.GroupID, strconv.FormatInt(apiPull.Index, 10), MergeOptions{
 					Style: mergeStyle,
 				})
 
@@ -164,7 +164,7 @@ func testScheduleUpdateMirrorSync(t *testing.T) {
 		assert.True(t, mirrorRepo.IsMirror)
 		mirrorRepo, err = repo_service.MigrateRepositoryGitData(t.Context(), user, mirrorRepo, opts, nil)
 		assert.NoError(t, err)
-		mirrorContext := NewAPITestContext(t, user.Name, mirrorRepo.Name, auth_model.AccessTokenScopeWriteRepository)
+		mirrorContext := NewAPITestContext(t, user.Name, mirrorRepo.Name, mirrorRepo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 
 		// enable actions unit for mirror repo
 		assert.False(t, mirrorRepo.UnitEnabled(t.Context(), unit_model.TypeActions))
@@ -238,7 +238,7 @@ func doTestScheduleUpdate(t *testing.T, updateTrigger scheduleUpdateTrigger) {
 		apiRepo := createActionsTestRepo(t, token, "actions-schedule", false)
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
 		assert.NoError(t, repo.LoadAttributes(t.Context()))
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, user2.Name, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		defer doAPIDeleteRepository(httpContext)(t)
 
 		wfTreePath := ".gitea/workflows/actions-schedule.yml"
@@ -254,7 +254,7 @@ jobs:
 `
 
 		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wfTreePath, wfFileContent)
-		apiFileResp := createWorkflowFile(t, token, user2.Name, repo.Name, wfTreePath, opts1)
+		apiFileResp := createWorkflowFile(t, token, user2.Name, repo.Name, repo.GroupID, wfTreePath, opts1)
 
 		actionSchedule := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionSchedule{RepoID: repo.ID, CommitSHA: apiFileResp.Commit.SHA})
 		scheduleSpec := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionScheduleSpec{RepoID: repo.ID, ScheduleID: actionSchedule.ID})

tests/integration/actions_trigger_test.go

@@ -1560,7 +1560,7 @@ jobs:
       - run: echo 'Hello World'
 `
 		opts1 := getWorkflowCreateFileOptions(user2, baseRepo.DefaultBranch, "create "+wfTreePath, wfFileContent)
-		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, wfTreePath, baseRepo.GroupID, opts1)
+		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, baseRepo.GroupID, wfTreePath, opts1)
 
 		// user4 forks the repo
 		req := NewRequestWithJSON(t, "POST", fmt.Sprintf("/api/v1/repos/%s/%d/%s/forks", baseRepo.OwnerName, baseRepo.GroupID, baseRepo.Name),

tests/integration/api_private_serv_test.go

@@ -43,7 +43,7 @@ func TestAPIPrivateServ(t *testing.T) {
 		defer cancel()
 
 		// Can push to a repo we own
-		results, extra := private.ServCommand(ctx, 1, "user2", "repo1", perm.AccessModeWrite, "git-upload-pack", "")
+		results, extra := private.ServCommand(ctx, 1, "user2", "repo1", 0, perm.AccessModeWrite, "git-upload-pack", "")
 		assert.NoError(t, extra.Error)
 		assert.False(t, results.IsWiki)
 		assert.Zero(t, results.DeployKeyID)
@@ -56,17 +56,17 @@ func TestAPIPrivateServ(t *testing.T) {
 		assert.Equal(t, int64(1), results.RepoID)
 
 		// Cannot push to a private repo we're not associated with
-		results, extra = private.ServCommand(ctx, 1, "user15", "big_test_private_1", perm.AccessModeWrite, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, 1, "user15", "big_test_private_1", 0, perm.AccessModeWrite, "git-upload-pack", "")
 		assert.Error(t, extra.Error)
 		assert.Empty(t, results)
 
 		// Cannot pull from a private repo we're not associated with
-		results, extra = private.ServCommand(ctx, 1, "user15", "big_test_private_1", perm.AccessModeRead, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, 1, "user15", "big_test_private_1", 0, perm.AccessModeRead, "git-upload-pack", "")
 		assert.Error(t, extra.Error)
 		assert.Empty(t, results)
 
 		// Can pull from a public repo we're not associated with
-		results, extra = private.ServCommand(ctx, 1, "user15", "big_test_public_1", perm.AccessModeRead, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, 1, "user15", "big_test_public_1", 0, perm.AccessModeRead, "git-upload-pack", "")
 		assert.NoError(t, extra.Error)
 		assert.False(t, results.IsWiki)
 		assert.Zero(t, results.DeployKeyID)
@@ -79,7 +79,7 @@ func TestAPIPrivateServ(t *testing.T) {
 		assert.Equal(t, int64(17), results.RepoID)
 
 		// Cannot push to a public repo we're not associated with
-		results, extra = private.ServCommand(ctx, 1, "user15", "big_test_public_1", perm.AccessModeWrite, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, 1, "user15", "big_test_public_1", 0, perm.AccessModeWrite, "git-upload-pack", "")
 		assert.Error(t, extra.Error)
 		assert.Empty(t, results)
 
@@ -88,7 +88,7 @@ func TestAPIPrivateServ(t *testing.T) {
 		assert.NoError(t, err)
 
 		// Can pull from repo we're a deploy key for
-		results, extra = private.ServCommand(ctx, deployKey.KeyID, "user15", "big_test_private_1", perm.AccessModeRead, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, deployKey.KeyID, "user15", "big_test_private_1", 0, perm.AccessModeRead, "git-upload-pack", "")
 		assert.NoError(t, extra.Error)
 		assert.False(t, results.IsWiki)
 		assert.NotZero(t, results.DeployKeyID)
@@ -101,17 +101,17 @@ func TestAPIPrivateServ(t *testing.T) {
 		assert.Equal(t, int64(19), results.RepoID)
 
 		// Cannot push to a private repo with reading key
-		results, extra = private.ServCommand(ctx, deployKey.KeyID, "user15", "big_test_private_1", perm.AccessModeWrite, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, deployKey.KeyID, "user15", "big_test_private_1", 0, perm.AccessModeWrite, "git-upload-pack", "")
 		assert.Error(t, extra.Error)
 		assert.Empty(t, results)
 
 		// Cannot pull from a private repo we're not associated with
-		results, extra = private.ServCommand(ctx, deployKey.ID, "user15", "big_test_private_2", perm.AccessModeRead, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, deployKey.ID, "user15", "big_test_private_2", 0, perm.AccessModeRead, "git-upload-pack", "")
 		assert.Error(t, extra.Error)
 		assert.Empty(t, results)
 
 		// Cannot pull from a public repo we're not associated with
-		results, extra = private.ServCommand(ctx, deployKey.ID, "user15", "big_test_public_1", perm.AccessModeRead, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, deployKey.ID, "user15", "big_test_public_1", 0, perm.AccessModeRead, "git-upload-pack", "")
 		assert.Error(t, extra.Error)
 		assert.Empty(t, results)
 
@@ -120,12 +120,12 @@ func TestAPIPrivateServ(t *testing.T) {
 		assert.NoError(t, err)
 
 		// Cannot push to a private repo with reading key
-		results, extra = private.ServCommand(ctx, deployKey.KeyID, "user15", "big_test_private_1", perm.AccessModeWrite, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, deployKey.KeyID, "user15", "big_test_private_1", 0, perm.AccessModeWrite, "git-upload-pack", "")
 		assert.Error(t, extra.Error)
 		assert.Empty(t, results)
 
 		// Can pull from repo we're a writing deploy key for
-		results, extra = private.ServCommand(ctx, deployKey.KeyID, "user15", "big_test_private_2", perm.AccessModeRead, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, deployKey.KeyID, "user15", "big_test_private_2", 0, perm.AccessModeRead, "git-upload-pack", "")
 		assert.NoError(t, extra.Error)
 		assert.False(t, results.IsWiki)
 		assert.NotZero(t, results.DeployKeyID)
@@ -138,7 +138,7 @@ func TestAPIPrivateServ(t *testing.T) {
 		assert.Equal(t, int64(20), results.RepoID)
 
 		// Can push to repo we're a writing deploy key for
-		results, extra = private.ServCommand(ctx, deployKey.KeyID, "user15", "big_test_private_2", perm.AccessModeWrite, "git-upload-pack", "")
+		results, extra = private.ServCommand(ctx, deployKey.KeyID, "user15", "big_test_private_2", 0, perm.AccessModeWrite, "git-upload-pack", "")
 		assert.NoError(t, extra.Error)
 		assert.False(t, results.IsWiki)
 		assert.NotZero(t, results.DeployKeyID)

tests/integration/api_pull_test.go

@@ -41,7 +41,7 @@ func TestAPIViewPulls(t *testing.T) {
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
 	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
 
-	ctx := NewAPITestContext(t, "user2", repo.Name, auth_model.AccessTokenScopeReadRepository)
+	ctx := NewAPITestContext(t, "user2", repo.Name, repo.GroupID, auth_model.AccessTokenScopeReadRepository)
 
 	req := NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/pulls?state=all", owner.Name, repo.GroupID, repo.Name).
 		AddTokenAuth(ctx.Token)
@@ -150,7 +150,7 @@ func TestAPIViewPullsByBaseHead(t *testing.T) {
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
 	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
 
-	ctx := NewAPITestContext(t, "user2", repo.Name, auth_model.AccessTokenScopeReadRepository)
+	ctx := NewAPITestContext(t, "user2", repo.Name, repo.GroupID, auth_model.AccessTokenScopeReadRepository)
 
 	req := NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/pulls/master/branch2", owner.Name, repo.GroupID, repo.Name).
 		AddTokenAuth(ctx.Token)
@@ -194,7 +194,7 @@ func TestAPIMergePull(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, giteaURL *url.URL) {
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
 		owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
-		apiCtx := NewAPITestContext(t, repo.OwnerName, repo.Name, auth_model.AccessTokenScopeWriteRepository)
+		apiCtx := NewAPITestContext(t, repo.OwnerName, repo.Name, repo.GroupID, auth_model.AccessTokenScopeWriteRepository)
 
 		checkBranchExists := func(t *testing.T, branchName string, status int) {
 			req := NewRequest(t, "GET", fmt.Sprintf("/api/v1/repos/%s/%s/branches/%s", owner.Name, repo.Name, branchName)).AddTokenAuth(apiCtx.Token)
@@ -310,7 +310,7 @@ func TestAPICreatePullBasePermission(t *testing.T) {
 	MakeRequest(t, req, http.StatusForbidden)
 
 	// add user4 to be a collaborator to base repo
-	ctx := NewAPITestContext(t, repo10.OwnerName, repo10.Name, auth_model.AccessTokenScopeWriteRepository)
+	ctx := NewAPITestContext(t, repo10.OwnerName, repo10.Name, repo10.GroupID, auth_model.AccessTokenScopeWriteRepository)
 	t.Run("AddUser4AsCollaborator", doAPIAddCollaborator(ctx, user4.Name, perm.AccessModeRead))
 
 	// create again
@@ -343,7 +343,7 @@ func TestAPICreatePullHeadPermission(t *testing.T) {
 	MakeRequest(t, req, http.StatusForbidden)
 
 	// add user4 to be a collaborator to head repo with read permission
-	ctx := NewAPITestContext(t, repo11.OwnerName, repo11.Name, auth_model.AccessTokenScopeWriteRepository)
+	ctx := NewAPITestContext(t, repo11.OwnerName, repo11.Name, repo11.GroupID, auth_model.AccessTokenScopeWriteRepository)
 	t.Run("AddUser4AsCollaboratorWithRead", doAPIAddCollaborator(ctx, user4.Name, perm.AccessModeRead))
 	req = NewRequestWithJSON(t, http.MethodPost, fmt.Sprintf("/api/v1/repos/%s/%d/%s/pulls", owner10.Name, repo10.GroupID, repo10.Name), &opts).AddTokenAuth(token)
 	MakeRequest(t, req, http.StatusForbidden)
@@ -564,7 +564,7 @@ func TestAPICommitPullRequest(t *testing.T) {
 	repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
 	owner := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: repo.OwnerID})
 
-	ctx := NewAPITestContext(t, "user2", repo.Name, auth_model.AccessTokenScopeReadRepository)
+	ctx := NewAPITestContext(t, "user2", repo.Name, repo.GroupID, auth_model.AccessTokenScopeReadRepository)
 
 	mergedCommitSHA := "1a8823cd1a9549fde083f992f6b9b87a7ab74fb3"
 	req := NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/commits/%s/pull", owner.Name, repo.GroupID, repo.Name, mergedCommitSHA).AddTokenAuth(ctx.Token)
@@ -580,7 +580,7 @@ func TestAPIViewPullFilesWithHeadRepoDeleted(t *testing.T) {
 		baseRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})
 		user1 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
 
-		ctx := NewAPITestContext(t, "user1", baseRepo.Name, auth_model.AccessTokenScopeAll)
+		ctx := NewAPITestContext(t, "user1", baseRepo.Name, baseRepo.GroupID, auth_model.AccessTokenScopeAll)
 
 		doAPIForkRepository(ctx, "user2")(t)
 
@@ -637,7 +637,7 @@ func TestAPIViewPullFilesWithHeadRepoDeleted(t *testing.T) {
 		assert.NoError(t, err)
 		pr := convert.ToAPIPullRequest(t.Context(), pullRequest, user1)
 
-		ctx = NewAPITestContext(t, "user2", baseRepo.Name, auth_model.AccessTokenScopeAll)
+		ctx = NewAPITestContext(t, "user2", baseRepo.Name, baseRepo.GroupID, auth_model.AccessTokenScopeAll)
 		doAPIGetPullFiles(ctx, pr, func(t *testing.T, files []*api.ChangedFile) {
 			if assert.Len(t, files, 1) {
 				assert.Equal(t, "file_1.txt", files[0].Filename)
@@ -650,7 +650,7 @@ func TestAPIViewPullFilesWithHeadRepoDeleted(t *testing.T) {
 		})(t)
 
 		// delete the head repository of the pull request
-		forkCtx := NewAPITestContext(t, "user1", forkedRepo.Name, auth_model.AccessTokenScopeAll)
+		forkCtx := NewAPITestContext(t, "user1", forkedRepo.Name, forkedRepo.GroupID, auth_model.AccessTokenScopeAll)
 		doAPIDeleteRepository(forkCtx)(t)
 
 		doAPIGetPullFiles(ctx, pr, func(t *testing.T, files []*api.ChangedFile) {

tests/integration/api_repo_collaborator_test.go

@@ -29,7 +29,7 @@ func TestAPIRepoCollaboratorPermission(t *testing.T) {
 	user11 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 11})
 	user34 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 34})
 
-	testCtx := NewAPITestContext(t, repo2Owner.Name, repo2.Name, auth_model.AccessTokenScopeWriteRepository)
+	testCtx := NewAPITestContext(t, repo2Owner.Name, repo2.Name, repo2.GroupID, auth_model.AccessTokenScopeWriteRepository)
 
 	t.Run("RepoOwnerShouldBeOwner", func(t *testing.T) {
 		req := NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/collaborators/%s/permission", repo2Owner.Name, repo2.GroupID, repo2.Name, repo2Owner.Name).
@@ -88,7 +88,7 @@ func TestAPIRepoCollaboratorPermission(t *testing.T) {
 	})
 
 	t.Run("CollaboratorBlocked", func(t *testing.T) {
-		ctx := NewAPITestContext(t, repo2Owner.Name, repo2.Name, auth_model.AccessTokenScopeWriteRepository)
+		ctx := NewAPITestContext(t, repo2Owner.Name, repo2.Name, repo2.GroupID, auth_model.AccessTokenScopeWriteRepository)
 		ctx.ExpectedCode = http.StatusForbidden
 		doAPIAddCollaborator(ctx, user34.Name, perm.AccessModeAdmin)(t)
 	})
@@ -97,7 +97,7 @@ func TestAPIRepoCollaboratorPermission(t *testing.T) {
 		t.Run("AddUserAsCollaboratorWithReadAccess", doAPIAddCollaborator(testCtx, user5.Name, perm.AccessModeRead))
 
 		_session := loginUser(t, user5.Name)
-		_testCtx := NewAPITestContext(t, user5.Name, repo2.Name, auth_model.AccessTokenScopeReadRepository)
+		_testCtx := NewAPITestContext(t, user5.Name, repo2.Name, repo2.GroupID, auth_model.AccessTokenScopeReadRepository)
 
 		req := NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/collaborators/%s/permission", repo2Owner.Name, repo2.GroupID, repo2.Name, user5.Name).
 			AddTokenAuth(_testCtx.Token)
@@ -126,7 +126,7 @@ func TestAPIRepoCollaboratorPermission(t *testing.T) {
 		t.Run("AddUserAsCollaboratorWithReadAccess", doAPIAddCollaborator(testCtx, user5.Name, perm.AccessModeRead))
 
 		_session := loginUser(t, user5.Name)
-		_testCtx := NewAPITestContext(t, user5.Name, repo2.Name, auth_model.AccessTokenScopeReadRepository)
+		_testCtx := NewAPITestContext(t, user5.Name, repo2.Name, repo2.GroupID, auth_model.AccessTokenScopeReadRepository)
 
 		req := NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/collaborators/%s/permission", repo2Owner.Name, repo2.GroupID, repo2.Name, user5.Name).
 			AddTokenAuth(_testCtx.Token)
@@ -143,7 +143,7 @@ func TestAPIRepoCollaboratorPermission(t *testing.T) {
 		t.Run("AddUserAsCollaboratorWithReadAccess", doAPIAddCollaborator(testCtx, user11.Name, perm.AccessModeRead))
 
 		_session := loginUser(t, user10.Name)
-		_testCtx := NewAPITestContext(t, user10.Name, repo2.Name, auth_model.AccessTokenScopeReadRepository)
+		_testCtx := NewAPITestContext(t, user10.Name, repo2.Name, repo2.GroupID, auth_model.AccessTokenScopeReadRepository)
 
 		req := NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/collaborators/%s/permission", repo2Owner.Name, repo2.GroupID, repo2.Name, user11.Name).
 			AddTokenAuth(_testCtx.Token)

tests/integration/api_repo_file_create_test.go

@@ -300,7 +300,7 @@ func TestAPICreateFile(t *testing.T) {
 		MakeRequest(t, req, http.StatusForbidden)
 
 		// Test creating a file in an empty repository
-		doAPICreateRepository(NewAPITestContext(t, "user2", "empty-repo", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser), true)(t)
+		doAPICreateRepository(NewAPITestContext(t, "user2", "empty-repo", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser), true)(t)
 		createFileOptions = getCreateFileOptions()
 		fileID++
 		treePath = fmt.Sprintf("new/file%d.txt", fileID)

tests/integration/api_repo_file_get_test.go

@@ -25,7 +25,7 @@ func TestAPIGetRawFileOrLFS(t *testing.T) {
 	// Test with LFS
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
 		createLFSTestRepository(t, "repo-lfs-test")
-		httpContext := NewAPITestContext(t, "user2", "repo-lfs-test", auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, "user2", "repo-lfs-test", 0, auth_model.AccessTokenScopeWriteRepository)
 		t.Run("repo-lfs-test", func(t *testing.T) {
 			u.Path = httpContext.GitPath()
 			dstPath := t.TempDir()

tests/integration/api_repo_git_blobs_test.go

@@ -67,7 +67,7 @@ func TestAPIReposGitBlobs(t *testing.T) {
 	MakeRequest(t, req, http.StatusOK)
 
 	// Test using org repo "org3/repo3" with no user token
-	req = NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/git/blobs/%s", org3.Name, repo3ReadmeSHA, repo3.GroupID, repo3.Name)
+	req = NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/git/blobs/%s", org3.Name, repo3.GroupID, repo3.Name, repo3ReadmeSHA)
 	MakeRequest(t, req, http.StatusNotFound)
 
 	// Login as User4.

tests/integration/api_repo_git_trees_test.go

@@ -76,7 +76,7 @@ func TestAPIReposGitTrees(t *testing.T) {
 	MakeRequest(t, req, http.StatusOK)
 
 	// Test using org repo "org3/repo3" with no user token
-	req = NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/git/trees/%s", org3.Name, repo3TreeSHA, repo3.GroupID, repo3.Name)
+	req = NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/git/trees/%s", org3.Name, repo3.GroupID, repo3.Name, repo3TreeSHA)
 	MakeRequest(t, req, http.StatusNotFound)
 
 	// Login as User4.

tests/integration/api_repo_tags_test.go

@@ -56,7 +56,7 @@ func TestAPIRepoTags(t *testing.T) {
 	}
 
 	// get created tag
-	req = NewRequestf(t, "GET", "/api/v1/repos/%s/%d/%s/tags/%s", user.Name, repoName, newTag.GroupID, newTag.Name).
+	req = NewRequestf(t, "GET", "/api/v1/repos/%s/%s/tags/%s", user.Name, repoName, newTag.Name).
 		AddTokenAuth(token)
 	resp = MakeRequest(t, req, http.StatusOK)
 	var tag *api.Tag
@@ -64,7 +64,7 @@ func TestAPIRepoTags(t *testing.T) {
 	assert.Equal(t, newTag, tag)
 
 	// delete tag
-	delReq := NewRequestf(t, "DELETE", "/api/v1/repos/%s/%d/%s/tags/%s", user.Name, repoName, newTag.GroupID, newTag.Name).
+	delReq := NewRequestf(t, "DELETE", "/api/v1/repos/%s/%s/tags/%s", user.Name, repoName, newTag.Name).
 		AddTokenAuth(token)
 	MakeRequest(t, delReq, http.StatusNoContent)
 

tests/integration/api_repo_test.go

@@ -407,7 +407,7 @@ func TestAPIRepoMigrateConflict(t *testing.T) {
 
 func testAPIRepoMigrateConflict(t *testing.T, u *url.URL) {
 	username := "user2"
-	baseAPITestContext := NewAPITestContext(t, username, "repo1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+	baseAPITestContext := NewAPITestContext(t, username, "repo1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
 	u.Path = baseAPITestContext.GitPath()
 
@@ -495,7 +495,7 @@ func TestAPIRepoCreateConflict(t *testing.T) {
 
 func testAPIRepoCreateConflict(t *testing.T, u *url.URL) {
 	username := "user2"
-	baseAPITestContext := NewAPITestContext(t, username, "repo1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+	baseAPITestContext := NewAPITestContext(t, username, "repo1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
 	u.Path = baseAPITestContext.GitPath()
 

tests/integration/compare_test.go

@@ -136,13 +136,13 @@ func TestCompareCodeExpand(t *testing.T) {
 		assert.NoError(t, err)
 
 		session := loginUser(t, user1.Name)
-		testEditFile(t, session, user1.Name, repo.Name, "main", "README.md", strings.Repeat("a\n", 30))
+		testEditFile(t, session, repo.GroupID, user1.Name, repo.Name, "main", "README.md", strings.Repeat("a\n", 30))
 
 		user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
 		session = loginUser(t, user2.Name)
 		testRepoFork(t, session, user1.Name, repo.Name, user2.Name, "test_blob_excerpt-fork", "")
 		testCreateBranch(t, session, user2.Name, "test_blob_excerpt-fork", "branch/main", "forked-branch", http.StatusSeeOther)
-		testEditFile(t, session, user2.Name, "test_blob_excerpt-fork", "forked-branch", "README.md", strings.Repeat("a\n", 15)+"CHANGED\n"+strings.Repeat("a\n", 15))
+		testEditFile(t, session, repo.GroupID, user2.Name, "test_blob_excerpt-fork", "forked-branch", "README.md", strings.Repeat("a\n", 15)+"CHANGED\n"+strings.Repeat("a\n", 15))
 
 		req := NewRequest(t, "GET", "/user1/test_blob_excerpt/compare/main...user2/test_blob_excerpt-fork:forked-branch")
 		resp := session.MakeRequest(t, req, http.StatusOK)

tests/integration/git_lfs_ssh_test.go

@@ -27,7 +27,7 @@ func TestGitLFSSSH(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
 		localRepoForUpload := filepath.Join(t.TempDir(), "test-upload")
 		localRepoForDownload := filepath.Join(t.TempDir(), "test-download")
-		apiTestContext := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+		apiTestContext := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
 		var mu sync.Mutex
 		var routerCalls []string

tests/integration/git_misc_test.go

@@ -82,7 +82,7 @@ func TestDataAsyncDoubleRead_Issue29101(t *testing.T) {
 
 func TestAgitPullPush(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
-		baseAPITestContext := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+		baseAPITestContext := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
 		u.Path = baseAPITestContext.GitPath()
 		u.User = url.UserPassword("user2", userPassword)
@@ -145,7 +145,7 @@ func TestAgitPullPush(t *testing.T) {
 
 func TestAgitReviewStaleness(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
-		baseAPITestContext := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+		baseAPITestContext := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
 		u.Path = baseAPITestContext.GitPath()
 		u.User = url.UserPassword("user2", userPassword)

tests/integration/git_push_test.go

@@ -201,7 +201,7 @@ func runTestGitPush(t *testing.T, u *url.URL, gitOperation func(t *testing.T, gi
 
 func TestPushPullRefs(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
-		baseAPITestContext := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+		baseAPITestContext := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
 		u.Path = baseAPITestContext.GitPath()
 		u.User = url.UserPassword("user2", userPassword)

tests/integration/git_ssh_redirect_test.go

@@ -20,7 +20,7 @@ func TestGitSSHRedirect(t *testing.T) {
 }
 
 func testGitSSHRedirect(t *testing.T, u *url.URL) {
-	apiTestContext := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser, auth_model.AccessTokenScopeWriteOrganization)
+	apiTestContext := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser, auth_model.AccessTokenScopeWriteOrganization)
 	session := loginUser(t, "user2")
 
 	withKeyFile(t, "my-testing-key", func(keyFile string) {
@@ -56,7 +56,7 @@ func testGitSSHRedirect(t *testing.T, u *url.URL) {
 			Name:     "repo1",
 			AutoInit: true,
 		})(t)
-		testEditFile(t, session, "olduser2", "repo1", "master", "README.md", "This is olduser2's repo1\n")
+		testEditFile(t, session, 0, "olduser2", "repo1", "master", "README.md", "This is olduser2's repo1\n")
 
 		dstDir := t.TempDir()
 		t.Run("Clone", doGitClone(dstDir, cloneURL))
@@ -64,9 +64,9 @@ func testGitSSHRedirect(t *testing.T, u *url.URL) {
 		assert.NoError(t, err)
 		assert.Equal(t, "This is olduser2's repo1\n", string(readMEContent))
 
-		apiTestContext2 := NewAPITestContext(t, "user2", "oldrepo1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser, auth_model.AccessTokenScopeWriteOrganization)
+		apiTestContext2 := NewAPITestContext(t, "user2", "oldrepo1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser, auth_model.AccessTokenScopeWriteOrganization)
 		doAPICreateRepository(apiTestContext2, false)(t)
-		testEditFile(t, session, "user2", "oldrepo1", "master", "README.md", "This is user2's oldrepo1\n")
+		testEditFile(t, session, 0, "user2", "oldrepo1", "master", "README.md", "This is user2's oldrepo1\n")
 
 		dstDir = t.TempDir()
 		cloneURL = createSSHUrl("user2/oldrepo1.git", u)

tests/integration/gpg_ssh_git_test.go

@@ -79,14 +79,14 @@ func TestSSHGit(t *testing.T) {
 func testGitSigning(t *testing.T) {
 	username := "user2"
 	user := unittest.AssertExistsAndLoadBean(t, &user_model.User{Name: username})
-	baseAPITestContext := NewAPITestContext(t, username, "repo1")
+	baseAPITestContext := NewAPITestContext(t, username, "repo1", 0)
 
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
 		u.Path = baseAPITestContext.GitPath()
 
 		t.Run("Unsigned-Initial", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-unsigned", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-unsigned", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreateRepository", doAPICreateRepository(testCtx, false))
 			t.Run("CheckMasterBranchUnsigned", doAPIGetBranch(testCtx, "master", func(t *testing.T, branch api.Branch) {
 				assert.NotNil(t, branch.Commit)
@@ -107,7 +107,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.CRUDActions = []string{"parentsigned"}
 		t.Run("Unsigned-Initial-CRUD-ParentSigned", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-unsigned", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-unsigned", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreateCRUDFile-ParentSigned", crudActionCreateFile(
 				t, testCtx, user, "master", "parentsigned", "signed-parent.txt", func(t *testing.T, response api.FileResponse) {
 					assert.False(t, response.Verification.Verified)
@@ -121,7 +121,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.CRUDActions = []string{"never"}
 		t.Run("Unsigned-Initial-CRUD-Never", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-unsigned", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-unsigned", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreateCRUDFile-Never", crudActionCreateFile(
 				t, testCtx, user, "parentsigned", "parentsigned-never", "unsigned-never2.txt", func(t *testing.T, response api.FileResponse) {
 					assert.False(t, response.Verification.Verified)
@@ -131,7 +131,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.CRUDActions = []string{"always"}
 		t.Run("Unsigned-Initial-CRUD-Always", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-unsigned", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-unsigned", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreateCRUDFile-Always", crudActionCreateFile(
 				t, testCtx, user, "master", "always", "signed-always.txt", func(t *testing.T, response api.FileResponse) {
 					require.NotNil(t, response.Verification, "no verification provided with response! %v", response)
@@ -149,7 +149,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.CRUDActions = []string{"parentsigned"}
 		t.Run("Unsigned-Initial-CRUD-ParentSigned", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-unsigned", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-unsigned", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreateCRUDFile-Always-ParentSigned", crudActionCreateFile(
 				t, testCtx, user, "always", "always-parentsigned", "signed-always-parentsigned.txt", func(t *testing.T, response api.FileResponse) {
 					require.NotNil(t, response.Verification, "no verification provided with response! %v", response)
@@ -161,7 +161,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.InitialCommit = []string{"always"}
 		t.Run("AlwaysSign-Initial", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-always", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-always", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreateRepository", doAPICreateRepository(testCtx, false))
 			t.Run("CheckMasterBranchSigned", doAPIGetBranch(testCtx, "master", func(t *testing.T, branch api.Branch) {
 				require.NotNil(t, branch.Commit, "no commit provided with branch! %v", branch)
@@ -174,7 +174,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.CRUDActions = []string{"never"}
 		t.Run("AlwaysSign-Initial-CRUD-Never", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-always-never", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-always-never", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreateRepository", doAPICreateRepository(testCtx, false))
 			t.Run("CreateCRUDFile-Never", crudActionCreateFile(
 				t, testCtx, user, "master", "never", "unsigned-never.txt", func(t *testing.T, response api.FileResponse) {
@@ -185,7 +185,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.CRUDActions = []string{"parentsigned"}
 		t.Run("AlwaysSign-Initial-CRUD-ParentSigned-On-Always", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-always-parent", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-always-parent", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreateRepository", doAPICreateRepository(testCtx, false))
 			t.Run("CreateCRUDFile-ParentSigned", crudActionCreateFile(
 				t, testCtx, user, "master", "parentsigned", "signed-parent.txt", func(t *testing.T, response api.FileResponse) {
@@ -197,7 +197,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.CRUDActions = []string{"always"}
 		t.Run("AlwaysSign-Initial-CRUD-Always", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-always-always", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-always-always", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreateRepository", doAPICreateRepository(testCtx, false))
 			t.Run("CreateCRUDFile-Always", crudActionCreateFile(
 				t, testCtx, user, "master", "always", "signed-always.txt", func(t *testing.T, response api.FileResponse) {
@@ -209,7 +209,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.Merges = []string{"commitssigned"}
 		t.Run("UnsignedMerging", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-unsigned", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-unsigned", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreatePullRequest", func(t *testing.T) {
 				pr, err := doAPICreatePullRequest(testCtx, testCtx.Username, testCtx.Reponame, "master", "never2")(t)
 				assert.NoError(t, err)
@@ -226,7 +226,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.Merges = []string{"basesigned"}
 		t.Run("BaseSignedMerging", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-unsigned", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-unsigned", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreatePullRequest", func(t *testing.T) {
 				pr, err := doAPICreatePullRequest(testCtx, testCtx.Username, testCtx.Reponame, "master", "parentsigned2")(t)
 				assert.NoError(t, err)
@@ -243,7 +243,7 @@ func testGitSigning(t *testing.T) {
 		setting.Repository.Signing.Merges = []string{"commitssigned"}
 		t.Run("CommitsSignedMerging", func(t *testing.T) {
 			defer tests.PrintCurrentTest(t)()
-			testCtx := NewAPITestContext(t, username, "initial-unsigned", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+			testCtx := NewAPITestContext(t, username, "initial-unsigned", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 			t.Run("CreatePullRequest", func(t *testing.T) {
 				pr, err := doAPICreatePullRequest(testCtx, testCtx.Username, testCtx.Reponame, "master", "always-parentsigned")(t)
 				assert.NoError(t, err)

tests/integration/org_count_test.go

@@ -27,7 +27,7 @@ func testOrgCounts(t *testing.T) {
 	orgOwner := "user2"
 	orgName := "testOrg"
 	orgCollaborator := "user4"
-	ctx := NewAPITestContext(t, orgOwner, "repo1", auth_model.AccessTokenScopeWriteOrganization)
+	ctx := NewAPITestContext(t, orgOwner, "repo1", 0, auth_model.AccessTokenScopeWriteOrganization)
 
 	var ownerCountRepos map[string]int
 	var collabCountRepos map[string]int

tests/integration/org_profile_test.go

@@ -38,7 +38,7 @@ func getCreateProfileReadmeFileOptions(content string) api.CreateFileOptions {
 func createTestProfile(t *testing.T, orgName, profileRepoName, readmeContent string) {
 	isPrivate := profileRepoName == user.RepoNameProfilePrivate
 
-	ctx := NewAPITestContext(t, "user1", profileRepoName, auth_model.AccessTokenScopeAll)
+	ctx := NewAPITestContext(t, "user1", profileRepoName, 0, auth_model.AccessTokenScopeAll)
 	session := loginUser(t, "user1")
 	tokenAdmin := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeAll)
 

tests/integration/pull_comment_test.go

@@ -32,10 +32,10 @@ func testWaitForPullRequestStatus(t *testing.T, prIssue *issues_model.Issue, exp
 func testPullCommentRebase(t *testing.T, u *url.URL, session *TestSession) {
 	testPRTitle := "Test PR for rebase comment"
 	// make a change on forked branch
-	testEditFile(t, session, "user1", "repo1", "test-branch/rebase", "README.md", "Hello, World (Edited)\n")
+	testEditFile(t, session, 0, "user1", "repo1", "test-branch/rebase", "README.md", "Hello, World (Edited)\n")
 	testPullCreate(t, session, "user1", "repo1", false, "test-branch/rebase", "test-branch/rebase", testPRTitle)
 	// create a conflict on base repo branch
-	testEditFile(t, session, "user2", "repo1", "test-branch/rebase", "README.md", "Hello, World (Edited Conflicted)\n")
+	testEditFile(t, session, 0, "user2", "repo1", "test-branch/rebase", "README.md", "Hello, World (Edited Conflicted)\n")
 
 	// Now the pull request status should be conflicted
 	testWaitForPullRequestStatus(t, &issues_model.Issue{Title: testPRTitle}, issues_model.PullRequestStatusConflict)
@@ -79,10 +79,10 @@ func testPullCommentRetarget(t *testing.T, _ *url.URL, session *TestSession) {
 	// keep a non-conflict branch
 	testCreateBranch(t, session, "user2", "repo1", "branch/test-branch/retarget", "test-branch/retarget-no-conflict", http.StatusSeeOther)
 	// make a change on forked branch
-	testEditFile(t, session, "user1", "repo1", "test-branch/retarget", "README.md", "Hello, World (Edited)\n")
+	testEditFile(t, session, 0, "user1", "repo1", "test-branch/retarget", "README.md", "Hello, World (Edited)\n")
 	testPullCreate(t, session, "user1", "repo1", false, "test-branch/retarget", "test-branch/retarget", testPRTitle)
 	// create a conflict line on user2/repo1 README.md
-	testEditFile(t, session, "user2", "repo1", "test-branch/retarget", "README.md", "Hello, World (Edited Conflicted)\n")
+	testEditFile(t, session, 0, "user2", "repo1", "test-branch/retarget", "README.md", "Hello, World (Edited Conflicted)\n")
 
 	// Now the pull request status should be conflicted
 	prIssue := testWaitForPullRequestStatus(t, &issues_model.Issue{Title: testPRTitle}, issues_model.PullRequestStatusConflict)

tests/integration/pull_compare_test.go

@@ -61,7 +61,7 @@ func TestPullCompare(t *testing.T) {
 		session := loginUser(t, "user1")
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
 		testCreateBranch(t, session, "user1", "repo1", "branch/master", "master1", http.StatusSeeOther)
-		testEditFile(t, session, "user1", "repo1", "master1", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master1", "README.md", "Hello, World (Edited)\n")
 		testPullCreate(t, session, "user1", "repo1", false, "master", "master1", "This is a pull title")
 
 		repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user2", Name: "repo1"})
@@ -101,7 +101,7 @@ func TestPullCompare_EnableAllowEditsFromMaintainer(t *testing.T) {
 		assert.True(t, forkedRepo.IsPrivate)
 
 		// user4 creates a new branch and a PR
-		testEditFileToNewBranch(t, user4Session, "user4", forkedRepoName, "master", "user4/update-readme", "README.md", "Hello, World\n(Edited by user4)\n")
+		testEditFileToNewBranch(t, user4Session, 0, "user4", forkedRepoName, "master", "user4/update-readme", "README.md", "Hello, World\n(Edited by user4)\n")
 		resp := testPullCreateDirectly(t, user4Session, createPullRequestOptions{
 			BaseRepoOwner: repo3.OwnerName,
 			BaseRepoName:  repo3.Name,

tests/integration/pull_create_test.go

@@ -138,7 +138,7 @@ func TestPullCreate(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
 		session := loginUser(t, "user1")
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 		repo1 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user2", Name: "repo1"})
 		assert.Equal(t, 3, repo1.NumPulls)
 		assert.Equal(t, 3, repo1.NumOpenPulls)
@@ -199,7 +199,7 @@ func TestPullBranchDelete(t *testing.T) {
 		session := loginUser(t, "user1")
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
 		testCreateBranch(t, session, "user1", "repo1", "branch/master", "master1", http.StatusSeeOther)
-		testEditFile(t, session, "user1", "repo1", "master1", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master1", "README.md", "Hello, World (Edited)\n")
 		resp := testPullCreate(t, session, "user1", "repo1", false, "master", "master1", "This is a pull title")
 
 		// check the redirected URL
@@ -237,7 +237,7 @@ func TestPullCreatePrFromBaseToFork(t *testing.T) {
 
 		// Edit base repository
 		sessionBase := loginUser(t, "user2")
-		testEditFile(t, sessionBase, "user2", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, sessionBase, 0, "user2", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 
 		// Create a PR
 		resp := testPullCreateDirectly(t, sessionFork, createPullRequestOptions{
@@ -357,7 +357,7 @@ func TestPullCreateParallel(t *testing.T) {
 		for i := range 5 {
 			wg.Go(func() {
 				branchName := fmt.Sprintf("new-branch-%d", i)
-				testEditFileToNewBranch(t, sessionFork, "user1", "repo1", "master", branchName, "README.md", fmt.Sprintf("Hello, World (Edited) %d\n", i))
+				testEditFileToNewBranch(t, sessionFork, 0, "user1", "repo1", "master", branchName, "README.md", fmt.Sprintf("Hello, World (Edited) %d\n", i))
 
 				// Create a PR
 				resp := testPullCreateDirectly(t, sessionFork, createPullRequestOptions{
@@ -443,7 +443,7 @@ func TestCreatePullWhenBlocked(t *testing.T) {
 		MakeRequest(t, req, http.StatusNoContent)
 
 		// 2. User1 adds changes to fork
-		testEditFile(t, sessionFork, ForkOwner, "forkrepo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, sessionFork, 0, ForkOwner, "forkrepo1", "master", "README.md", "Hello, World (Edited)\n")
 
 		// 3. User1 attempts to create a pull request
 		testPullCreateFailure(t, sessionFork, RepoOwner, "repo1", "master", ForkOwner, "forkrepo1", "master", "This is a pull title")

tests/integration/pull_merge_test.go

@@ -11,14 +11,12 @@ import (
 	"net/url"
 	"os"
 	"path"
-	"path/filepath"
 	"strconv"
 	"strings"
 	"testing"
 	"time"
 
 	auth_model "code.gitea.io/gitea/models/auth"
-	"code.gitea.io/gitea/models/db"
 	git_model "code.gitea.io/gitea/models/git"
 	issues_model "code.gitea.io/gitea/models/issues"
 	pull_model "code.gitea.io/gitea/models/pull"
@@ -52,7 +50,7 @@ type MergeOptions struct {
 	DeleteBranch bool
 }
 
-func testPullMerge(t *testing.T, session *TestSession, user, repo, pullNum string, mergeOptions MergeOptions) *httptest.ResponseRecorder {
+func testPullMerge(t *testing.T, session *TestSession, user, repo string, groupID int64, pullNum string, mergeOptions MergeOptions) *httptest.ResponseRecorder {
 	options := map[string]string{
 		"do":                        string(mergeOptions.Style),
 		"head_commit_id":            mergeOptions.HeadCommitID,
@@ -67,10 +65,15 @@ func testPullMerge(t *testing.T, session *TestSession, user, repo, pullNum strin
 
 	redirect := test.RedirectURL(resp)
 	assert.Equal(t, fmt.Sprintf("/%s/%s/pulls/%s", user, repo, pullNum), redirect)
+	var groupSegment string
+	if groupID > 0 {
+		groupSegment = fmt.Sprintf("%d/", groupID)
+	}
+	assert.Equal(t, fmt.Sprintf("/%s/%s%s/pulls/%s", user, groupSegment, repo, pullNum), redirect)
 
 	pullNumInt, err := strconv.ParseInt(pullNum, 10, 64)
 	assert.NoError(t, err)
-	repository, err := repo_model.GetRepositoryByOwnerAndName(t.Context(), user, repo)
+	repository, err := repo_model.GetRepositoryByOwnerAndName(t.Context(), user, repo, groupID)
 	assert.NoError(t, err)
 	pull, err := issues_model.GetPullRequestByIndex(t.Context(), repository.ID, pullNumInt)
 	assert.NoError(t, err)
@@ -101,7 +104,7 @@ func TestPullMerge(t *testing.T) {
 
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user2", Name: "repo1"})
 		assert.Equal(t, 3, repo.NumPulls)
@@ -115,7 +118,7 @@ func TestPullMerge(t *testing.T) {
 
 		elem := strings.Split(test.RedirectURL(resp), "/")
 		assert.Equal(t, "pulls", elem[3])
-		testPullMerge(t, session, elem[1], elem[2], elem[4], MergeOptions{
+		testPullMerge(t, session, elem[1], elem[2], 0, elem[4], MergeOptions{
 			Style:        repo_model.MergeStyleMerge,
 			DeleteBranch: false,
 		})
@@ -138,7 +141,7 @@ func TestPullRebase(t *testing.T) {
 
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user2", Name: "repo1"})
 		assert.Equal(t, 3, repo.NumPulls)
@@ -152,7 +155,7 @@ func TestPullRebase(t *testing.T) {
 
 		elem := strings.Split(test.RedirectURL(resp), "/")
 		assert.Equal(t, "pulls", elem[3])
-		testPullMerge(t, session, elem[1], elem[2], elem[4], MergeOptions{
+		testPullMerge(t, session, elem[1], elem[2], 0, elem[4], MergeOptions{
 			Style:        repo_model.MergeStyleRebase,
 			DeleteBranch: false,
 		})
@@ -175,7 +178,7 @@ func TestPullRebaseMerge(t *testing.T) {
 
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user2", Name: "repo1"})
 		assert.Equal(t, 3, repo.NumPulls)
@@ -189,7 +192,7 @@ func TestPullRebaseMerge(t *testing.T) {
 
 		elem := strings.Split(test.RedirectURL(resp), "/")
 		assert.Equal(t, "pulls", elem[3])
-		testPullMerge(t, session, elem[1], elem[2], elem[4], MergeOptions{
+		testPullMerge(t, session, elem[1], elem[2], 0, elem[4], MergeOptions{
 			Style:        repo_model.MergeStyleRebaseMerge,
 			DeleteBranch: false,
 		})
@@ -212,14 +215,14 @@ func TestPullSquash(t *testing.T) {
 
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited!)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited!)\n")
 
 		resp := testPullCreate(t, session, "user1", "repo1", false, "master", "master", "This is a pull title")
 
 		elem := strings.Split(test.RedirectURL(resp), "/")
 		assert.Equal(t, "pulls", elem[3])
-		testPullMerge(t, session, elem[1], elem[2], elem[4], MergeOptions{
+		testPullMerge(t, session, elem[1], elem[2], 0, elem[4], MergeOptions{
 			Style:        repo_model.MergeStyleSquash,
 			DeleteBranch: false,
 		})
@@ -238,8 +241,8 @@ func TestPullSquashWithHeadCommitID(t *testing.T) {
 
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited!)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited!)\n")
 
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user2", Name: "repo1"})
 		assert.Equal(t, 3, repo.NumPulls)
@@ -259,7 +262,7 @@ func TestPullSquashWithHeadCommitID(t *testing.T) {
 		assert.Equal(t, 4, repo.NumPulls)
 		assert.Equal(t, 4, repo.NumOpenPulls)
 
-		testPullMerge(t, session, elem[1], elem[2], elem[4], MergeOptions{
+		testPullMerge(t, session, elem[1], elem[2], 0, elem[4], MergeOptions{
 			Style:        repo_model.MergeStyleSquash,
 			DeleteBranch: false,
 			HeadCommitID: headBranch.CommitID,
@@ -278,7 +281,7 @@ func TestPullCleanUpAfterMerge(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, giteaURL *url.URL) {
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "feature/test", "README.md", "Hello, World (Edited - TestPullCleanUpAfterMerge)\n")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "feature/test", "README.md", "Hello, World (Edited - TestPullCleanUpAfterMerge)\n")
 
 		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user2", Name: "repo1"})
 		assert.Equal(t, 3, repo.NumPulls)
@@ -293,7 +296,7 @@ func TestPullCleanUpAfterMerge(t *testing.T) {
 		assert.Equal(t, 4, repo.NumPulls)
 		assert.Equal(t, 4, repo.NumOpenPulls)
 
-		testPullMerge(t, session, elem[1], elem[2], elem[4], MergeOptions{
+		testPullMerge(t, session, elem[1], elem[2], 0, elem[4], MergeOptions{
 			Style:        repo_model.MergeStyleMerge,
 			DeleteBranch: false,
 		})
@@ -329,7 +332,7 @@ func TestCantMergeWorkInProgress(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, giteaURL *url.URL) {
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 
 		resp := testPullCreate(t, session, "user1", "repo1", false, "master", "master", "[wip] This is a pull title")
 
@@ -348,8 +351,8 @@ func TestCantMergeConflict(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, giteaURL *url.URL) {
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "conflict", "README.md", "Hello, World (Edited Once)\n")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "base", "README.md", "Hello, World (Edited Twice)\n")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "conflict", "README.md", "Hello, World (Edited Once)\n")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "base", "README.md", "Hello, World (Edited Twice)\n")
 
 		// Use API to create a conflicting pr
 		token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
@@ -390,7 +393,7 @@ func TestCantMergeUnrelated(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, giteaURL *url.URL) {
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "base", "README.md", "Hello, World (Edited Twice)\n")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "base", "README.md", "Hello, World (Edited Twice)\n")
 
 		// Now we want to create a commit on a branch that is totally unrelated to our current head
 		// Drop down to pure code at this point
@@ -453,7 +456,7 @@ func TestCantMergeUnrelated(t *testing.T) {
 			RunStdString(t.Context())
 		assert.NoError(t, err)
 
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "conflict", "README.md", "Hello, World (Edited Once)\n")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "conflict", "README.md", "Hello, World (Edited Once)\n")
 
 		// Use API to create a conflicting pr
 		token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
@@ -482,7 +485,7 @@ func TestFastForwardOnlyMerge(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, giteaURL *url.URL) {
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "update", "README.md", "Hello, World 2\n")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "update", "README.md", "Hello, World 2\n")
 
 		// Use API to create a pr from update to master
 		token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
@@ -517,8 +520,8 @@ func TestCantFastForwardOnlyMergeDiverging(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, giteaURL *url.URL) {
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "diverging", "README.md", "Hello, World diverged\n")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World 2\n")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "diverging", "README.md", "Hello, World diverged\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World 2\n")
 
 		// Use API to create a pr from diverging to update
 		token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
@@ -553,9 +556,9 @@ func TestCantFastForwardOnlyMergeDiverging(t *testing.T) {
 func TestPullRetargetChildOnBranchDelete(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, giteaURL *url.URL) {
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
-		testEditFileToNewBranch(t, session, "user2", "repo1", "master", "base-pr", "README.md", "Hello, World\n(Edited - TestPullRetargetOnCleanup - base PR)\n")
+		testEditFileToNewBranch(t, session, 0, "user2", "repo1", "master", "base-pr", "README.md", "Hello, World\n(Edited - TestPullRetargetOnCleanup - base PR)\n")
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "base-pr", "child-pr", "README.md", "Hello, World\n(Edited - TestPullRetargetOnCleanup - base PR)\n(Edited - TestPullRetargetOnCleanup - child PR)")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "base-pr", "child-pr", "README.md", "Hello, World\n(Edited - TestPullRetargetOnCleanup - base PR)\n(Edited - TestPullRetargetOnCleanup - child PR)")
 
 		respBasePR := testPullCreate(t, session, "user2", "repo1", true, "master", "base-pr", "Base Pull Request")
 		elemBasePR := strings.Split(test.RedirectURL(respBasePR), "/")
@@ -565,7 +568,7 @@ func TestPullRetargetChildOnBranchDelete(t *testing.T) {
 		elemChildPR := strings.Split(test.RedirectURL(respChildPR), "/")
 		assert.Equal(t, "pulls", elemChildPR[3])
 
-		testPullMerge(t, session, elemBasePR[1], elemBasePR[2], elemBasePR[4], MergeOptions{
+		testPullMerge(t, session, elemBasePR[1], elemBasePR[2], 0, elemBasePR[4], MergeOptions{
 			Style:        repo_model.MergeStyleMerge,
 			DeleteBranch: true,
 		})
@@ -591,8 +594,8 @@ func TestPullDontRetargetChildOnWrongRepo(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, giteaURL *url.URL) {
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "base-pr", "README.md", "Hello, World\n(Edited - TestPullDontRetargetChildOnWrongRepo - base PR)\n")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "base-pr", "child-pr", "README.md", "Hello, World\n(Edited - TestPullDontRetargetChildOnWrongRepo - base PR)\n(Edited - TestPullDontRetargetChildOnWrongRepo - child PR)")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "base-pr", "README.md", "Hello, World\n(Edited - TestPullDontRetargetChildOnWrongRepo - base PR)\n")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "base-pr", "child-pr", "README.md", "Hello, World\n(Edited - TestPullDontRetargetChildOnWrongRepo - base PR)\n(Edited - TestPullDontRetargetChildOnWrongRepo - child PR)")
 
 		respBasePR := testPullCreate(t, session, "user1", "repo1", false, "master", "base-pr", "Base Pull Request")
 		elemBasePR := strings.Split(test.RedirectURL(respBasePR), "/")
@@ -604,7 +607,7 @@ func TestPullDontRetargetChildOnWrongRepo(t *testing.T) {
 
 		defer test.MockVariableValue(&setting.Repository.PullRequest.RetargetChildrenOnMerge, false)()
 
-		testPullMerge(t, session, elemBasePR[1], elemBasePR[2], elemBasePR[4], MergeOptions{
+		testPullMerge(t, session, elemBasePR[1], elemBasePR[2], 0, elemBasePR[4], MergeOptions{
 			Style:        repo_model.MergeStyleMerge,
 			DeleteBranch: true,
 		})
@@ -631,7 +634,7 @@ func TestPullRequestMergedWithNoPermissionDeleteBranch(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, giteaURL *url.URL) {
 		session := loginUser(t, "user4")
 		testRepoFork(t, session, "user2", "repo1", "user4", "repo1", "")
-		testEditFileToNewBranch(t, session, "user4", "repo1", "master", "base-pr", "README.md", "Hello, World\n(Edited - TestPullDontRetargetChildOnWrongRepo - base PR)\n")
+		testEditFileToNewBranch(t, session, 0, "user4", "repo1", "master", "base-pr", "README.md", "Hello, World\n(Edited - TestPullDontRetargetChildOnWrongRepo - base PR)\n")
 
 		respBasePR := testPullCreate(t, session, "user4", "repo1", false, "master", "base-pr", "Base Pull Request")
 		elemBasePR := strings.Split(test.RedirectURL(respBasePR), "/")
@@ -639,7 +642,7 @@ func TestPullRequestMergedWithNoPermissionDeleteBranch(t *testing.T) {
 
 		// user2 has no permission to delete branch of repo user1/repo1
 		session2 := loginUser(t, "user2")
-		testPullMerge(t, session2, elemBasePR[1], elemBasePR[2], elemBasePR[4], MergeOptions{
+		testPullMerge(t, session2, elemBasePR[1], elemBasePR[2], 0, elemBasePR[4], MergeOptions{
 			Style:        repo_model.MergeStyleMerge,
 			DeleteBranch: true,
 		})
@@ -656,7 +659,7 @@ func TestPullMergeIndexerNotifier(t *testing.T) {
 		// create a pull request
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 		createPullResp := testPullCreate(t, session, "user1", "repo1", false, "master", "master", "Indexer notifier test pull")
 
 		assert.NoError(t, queue.GetManager().FlushAll(t.Context(), 0))
@@ -690,7 +693,7 @@ func TestPullMergeIndexerNotifier(t *testing.T) {
 		// merge the pull request
 		elem := strings.Split(test.RedirectURL(createPullResp), "/")
 		assert.Equal(t, "pulls", elem[3])
-		testPullMerge(t, session, elem[1], elem[2], elem[4], MergeOptions{
+		testPullMerge(t, session, elem[1], elem[2], 0, elem[4], MergeOptions{
 			Style:        repo_model.MergeStyleMerge,
 			DeleteBranch: false,
 		})
@@ -721,7 +724,7 @@ func TestPullAutoMergeAfterCommitStatusSucceed(t *testing.T) {
 		user1 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 1})
 		forkedName := "repo1-1"
 		testRepoFork(t, session, "user2", "repo1", "user1", forkedName, "")
-		testEditFile(t, session, "user1", forkedName, "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", forkedName, "master", "README.md", "Hello, World (Edited)\n")
 		testPullCreate(t, session, "user1", forkedName, false, "master", "master", "Indexer notifier test pull")
 
 		baseRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user2", Name: "repo1"})
@@ -804,7 +807,7 @@ func TestPullAutoMergeAfterCommitStatusSucceedAndApproval(t *testing.T) {
 		forkSession := loginUser(t, "user5")
 		forkedName := "repo1-fork"
 		testRepoFork(t, forkSession, "user2", "repo1", forkUser.Name, forkedName, "")
-		testEditFile(t, forkSession, forkUser.Name, forkedName, "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, forkSession, 0, forkUser.Name, forkedName, "master", "README.md", "Hello, World (Edited)\n")
 		testPullCreate(t, forkSession, forkUser.Name, forkedName, false, "master", "master", "Indexer notifier test pull")
 
 		baseRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user2", Name: "repo1"})
@@ -877,7 +880,7 @@ func TestPullAutoMergeAfterCommitStatusSucceedAndApproval(t *testing.T) {
 func TestPullAutoMergeAfterCommitStatusSucceedAndApprovalForAgitFlow(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
 		// create a pull request
-		baseAPITestContext := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+		baseAPITestContext := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
 		dstPath := t.TempDir()
 
@@ -991,7 +994,7 @@ func TestPullNonMergeForAdminWithBranchProtection(t *testing.T) {
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
 		forkedName := "repo1-1"
 		testRepoFork(t, session, "user2", "repo1", "user1", forkedName, "")
-		testEditFile(t, session, "user1", forkedName, "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", forkedName, "master", "README.md", "Hello, World (Edited)\n")
 		testPullCreate(t, session, "user1", forkedName, false, "master", "master", "Indexer notifier test pull")
 
 		baseRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{OwnerName: "user2", Name: "repo1"})
@@ -1029,13 +1032,13 @@ func TestPullNonMergeForAdminWithBranchProtection(t *testing.T) {
 func TestPullSquashMergeEmpty(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
 		session := loginUser(t, "user1") // FIXME: don't use admin user for testing
-		testEditFileToNewBranch(t, session, "user2", "repo1", "master", "pr-squash-empty", "README.md", "Hello, World (Edited)\n")
+		testEditFileToNewBranch(t, session, 0, "user2", "repo1", "master", "pr-squash-empty", "README.md", "Hello, World (Edited)\n")
 		resp := testPullCreate(t, session, "user2", "repo1", false, "master", "pr-squash-empty", "This is a pull title")
 
 		elem := strings.Split(test.RedirectURL(resp), "/")
 		assert.Equal(t, "pulls", elem[3])
 
-		httpContext := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeWriteRepository)
+		httpContext := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeWriteRepository)
 		dstPath := t.TempDir()
 
 		u.Path = httpContext.GitPath()
@@ -1051,7 +1054,7 @@ func TestPullSquashMergeEmpty(t *testing.T) {
 
 		doGitPushTestRepository(dstPath)(t)
 
-		testPullMerge(t, session, elem[1], elem[2], elem[4], MergeOptions{
+		testPullMerge(t, session, elem[1], elem[2], 0, elem[4], MergeOptions{
 			Style:        repo_model.MergeStyleSquash,
 			DeleteBranch: false,
 		})

tests/integration/pull_review_test.go

@@ -224,11 +224,11 @@ func TestPullView_GivenApproveOrRejectReviewOnClosedPR(t *testing.T) {
 
 		t.Run("Submit approve/reject review on merged PR", func(t *testing.T) {
 			// Create a merged PR (made by user1) in the upstream repo1.
-			testEditFile(t, user1Session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+			testEditFile(t, user1Session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 			resp := testPullCreate(t, user1Session, "user1", "repo1", false, "master", "master", "This is a pull title")
 			elem := strings.Split(test.RedirectURL(resp), "/")
 			assert.Equal(t, "pulls", elem[3])
-			testPullMerge(t, user1Session, elem[1], elem[2], elem[4], MergeOptions{
+			testPullMerge(t, user1Session, elem[1], elem[2], 0, elem[4], MergeOptions{
 				Style:        repo_model.MergeStyleMerge,
 				DeleteBranch: false,
 			})
@@ -242,7 +242,7 @@ func TestPullView_GivenApproveOrRejectReviewOnClosedPR(t *testing.T) {
 
 		t.Run("Submit approve/reject review on closed PR", func(t *testing.T) {
 			// Created a closed PR (made by user1) in the upstream repo1.
-			testEditFileToNewBranch(t, user1Session, "user1", "repo1", "master", "a-test-branch", "README.md", "Hello, World (Edited...again)\n")
+			testEditFileToNewBranch(t, user1Session, 0, "user1", "repo1", "master", "a-test-branch", "README.md", "Hello, World (Edited...again)\n")
 			resp := testPullCreate(t, user1Session, "user1", "repo1", false, "master", "a-test-branch", "This is a pull title")
 			elem := strings.Split(test.RedirectURL(resp), "/")
 			assert.Equal(t, "pulls", elem[3])

tests/integration/pull_status_test.go

@@ -29,7 +29,7 @@ func TestPullCreate_CommitStatus(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
 		session := loginUser(t, "user1")
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "status1", "README.md", "status1")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "status1", "README.md", "status1")
 
 		url := path.Join("user1", "repo1", "compare", "master...status1")
 		req := NewRequestWithValues(t, "POST", url,
@@ -71,7 +71,7 @@ func TestPullCreate_CommitStatus(t *testing.T) {
 			commitstatus.CommitStatusWarning: "gitea-exclamation",
 		}
 
-		testCtx := NewAPITestContext(t, "user1", "repo1", auth_model.AccessTokenScopeWriteRepository)
+		testCtx := NewAPITestContext(t, "user1", "repo1", 0, auth_model.AccessTokenScopeWriteRepository)
 
 		// Update commit status, and check if icon is updated as well
 		for _, status := range statusList {
@@ -118,8 +118,8 @@ func TestPullCreate_EmptyChangesWithDifferentCommits(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
 		session := loginUser(t, "user1")
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "status1", "README.md", "status1")
-		testEditFile(t, session, "user1", "repo1", "status1", "README.md", "# repo1\n\nDescription for repo1")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "status1", "README.md", "status1")
+		testEditFile(t, session, 0, "user1", "repo1", "status1", "README.md", "# repo1\n\nDescription for repo1")
 
 		url := path.Join("user1", "repo1", "compare", "master...status1")
 		req := NewRequestWithValues(t, "POST", url,
@@ -199,7 +199,7 @@ func TestPullStatusDelayCheck(t *testing.T) {
 
 		// when base branch changes, PR status should be updated, but it is inactive for long time, so no real check
 		issue3, checkedPrID = run(t, func(t *testing.T) {
-			testEditFile(t, session, "user2", "repo1", "master", "README.md", "new content 1")
+			testEditFile(t, session, 0, "user2", "repo1", "master", "README.md", "new content 1")
 		})
 		assert.Equal(t, issues.PullRequestStatusChecking, issue3.PullRequest.Status)
 		assert.Zero(t, checkedPrID)
@@ -215,7 +215,7 @@ func TestPullStatusDelayCheck(t *testing.T) {
 
 		// when base branch changes, still so no real check
 		issue3, checkedPrID = run(t, func(t *testing.T) {
-			testEditFile(t, session, "user2", "repo1", "master", "README.md", "new content 2")
+			testEditFile(t, session, 0, "user2", "repo1", "master", "README.md", "new content 2")
 		})
 		assert.Equal(t, issues.PullRequestStatusChecking, issue3.PullRequest.Status)
 		assert.Zero(t, checkedPrID)
@@ -223,7 +223,7 @@ func TestPullStatusDelayCheck(t *testing.T) {
 		// then allow to check PRs without delay, when base branch changes, the PRs will be checked
 		setting.Repository.PullRequest.DelayCheckForInactiveDays = -1
 		issue3, checkedPrID = run(t, func(t *testing.T) {
-			testEditFile(t, session, "user2", "repo1", "master", "README.md", "new content 3")
+			testEditFile(t, session, 0, "user2", "repo1", "master", "README.md", "new content 3")
 		})
 		assert.Equal(t, issues.PullRequestStatusChecking, issue3.PullRequest.Status)
 		assert.Equal(t, issue3.PullRequest.ID, checkedPrID)

tests/integration/repo_activity_test.go

@@ -23,19 +23,19 @@ func TestRepoActivity(t *testing.T) {
 
 		// Create PRs (1 merged & 2 proposed)
 		testRepoFork(t, session, "user2", "repo1", "user1", "repo1", "")
-		testEditFile(t, session, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
+		testEditFile(t, session, 0, "user1", "repo1", "master", "README.md", "Hello, World (Edited)\n")
 		resp := testPullCreate(t, session, "user1", "repo1", false, "master", "master", "This is a pull title")
 		elem := strings.Split(test.RedirectURL(resp), "/")
 		assert.Equal(t, "pulls", elem[3])
-		testPullMerge(t, session, elem[1], elem[2], elem[4], MergeOptions{
+		testPullMerge(t, session, elem[1], elem[2], 0, elem[4], MergeOptions{
 			Style:        repo_model.MergeStyleMerge,
 			DeleteBranch: false,
 		})
 
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "feat/better_readme", "README.md", "Hello, World (Edited Again)\n")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "feat/better_readme", "README.md", "Hello, World (Edited Again)\n")
 		testPullCreate(t, session, "user1", "repo1", false, "master", "feat/better_readme", "This is a pull title")
 
-		testEditFileToNewBranch(t, session, "user1", "repo1", "master", "feat/much_better_readme", "README.md", "Hello, World (Edited More)\n")
+		testEditFileToNewBranch(t, session, 0, "user1", "repo1", "master", "feat/much_better_readme", "README.md", "Hello, World (Edited More)\n")
 		testPullCreate(t, session, "user1", "repo1", false, "master", "feat/much_better_readme", "This is a pull title")
 
 		// Create issues (3 new issues)

tests/integration/repo_branch_test.go

@@ -204,7 +204,7 @@ func prepareRepoPR(t *testing.T, baseSession, headSession *TestSession, baseRepo
 	testCreateBranch(t, headSession, headRepo.OwnerName, headRepo.Name, "branch/new-commit", "merged-pr", http.StatusSeeOther)
 	prID = testCreatePullToDefaultBranch(t, baseSession, baseRepo, headRepo, "merged-pr", "merged pr")
 	testAPINewFile(t, headSession, headRepo.OwnerName, headRepo.Name, "merged-pr", fmt.Sprintf("new-commit-%s.txt", headRepo.Name), "new-commit")
-	testPullMerge(t, baseSession, baseRepo.OwnerName, baseRepo.Name, prID, MergeOptions{
+	testPullMerge(t, baseSession, baseRepo.OwnerName, baseRepo.Name, baseRepo.GroupID, prID, MergeOptions{
 		Style:        repo_model.MergeStyleRebaseMerge,
 		DeleteBranch: false,
 	})
@@ -213,7 +213,7 @@ func prepareRepoPR(t *testing.T, baseSession, headSession *TestSession, baseRepo
 	testCreateBranch(t, headSession, headRepo.OwnerName, headRepo.Name, "branch/new-commit", "merged-pr-deleted", http.StatusSeeOther)
 	prID = testCreatePullToDefaultBranch(t, baseSession, baseRepo, headRepo, "merged-pr-deleted", "merged pr with deleted branch")
 	testAPINewFile(t, headSession, headRepo.OwnerName, headRepo.Name, "merged-pr-deleted", fmt.Sprintf("new-commit-%s-2.txt", headRepo.Name), "new-commit")
-	testPullMerge(t, baseSession, baseRepo.OwnerName, baseRepo.Name, prID, MergeOptions{
+	testPullMerge(t, baseSession, baseRepo.OwnerName, baseRepo.Name, baseRepo.GroupID, prID, MergeOptions{
 		Style:        repo_model.MergeStyleRebaseMerge,
 		DeleteBranch: true,
 	})

tests/integration/repo_commits_test.go

@@ -84,7 +84,7 @@ func TestRepoCommitsWithStatus(t *testing.T) {
 	defer tests.PrepareTestEnv(t)()
 
 	session := loginUser(t, "user2")
-	ctx := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeWriteRepository)
+	ctx := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeWriteRepository)
 
 	requestCommitStatuses := func(t *testing.T, linkList, linkCombined string) (statuses []*api.CommitStatus, status api.CombinedStatus) {
 		assert.NoError(t, json.Unmarshal(session.MakeRequest(t, NewRequest(t, "GET", linkList), http.StatusOK).Body.Bytes(), &statuses))
@@ -183,7 +183,7 @@ func TestRepoCommitsStatusParallel(t *testing.T) {
 		wg.Add(1)
 		go func(parentT *testing.T, i int) {
 			parentT.Run(fmt.Sprintf("ParallelCreateStatus_%d", i), func(t *testing.T) {
-				ctx := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeWriteRepository)
+				ctx := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeWriteRepository)
 				doAPICreateCommitStatusTest(ctx, path.Base(commitURL), commitstatus.CommitStatusPending, "testci")(t)
 				wg.Done()
 			})
@@ -208,7 +208,7 @@ func TestRepoCommitsStatusMultiple(t *testing.T) {
 	assert.NotEmpty(t, commitURL)
 
 	// Call API to add status for commit
-	ctx := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeWriteRepository)
+	ctx := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeWriteRepository)
 	t.Run("CreateStatus", doAPICreateCommitStatusTest(ctx, path.Base(commitURL), commitstatus.CommitStatusSuccess, "testci"))
 	t.Run("CreateStatus", doAPICreateCommitStatusTest(ctx, path.Base(commitURL), commitstatus.CommitStatusSuccess, "other_context"))
 	req = NewRequest(t, "GET", "/user2/repo1/commits/branch/master")

tests/integration/repo_tag_test.go

@@ -46,7 +46,7 @@ func TestCreateNewTagProtected(t *testing.T) {
 
 	t.Run("Git", func(t *testing.T) {
 		onGiteaRun(t, func(t *testing.T, u *url.URL) {
-			httpContext := NewAPITestContext(t, owner.Name, repo.Name)
+			httpContext := NewAPITestContext(t, owner.Name, repo.Name, repo.GroupID)
 
 			dstPath := t.TempDir()
 
@@ -66,7 +66,7 @@ func TestCreateNewTagProtected(t *testing.T) {
 
 	t.Run("GitTagForce", func(t *testing.T) {
 		onGiteaRun(t, func(t *testing.T, u *url.URL) {
-			httpContext := NewAPITestContext(t, owner.Name, repo.Name)
+			httpContext := NewAPITestContext(t, owner.Name, repo.Name, repo.GroupID)
 
 			dstPath := t.TempDir()
 
@@ -129,7 +129,7 @@ func TestRepushTag(t *testing.T) {
 		session := loginUser(t, owner.LowerName)
 		token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository)
 
-		httpContext := NewAPITestContext(t, owner.Name, repo.Name)
+		httpContext := NewAPITestContext(t, owner.Name, repo.Name, repo.GroupID)
 
 		dstPath := t.TempDir()
 

tests/integration/repo_watch_test.go

@@ -18,7 +18,7 @@ func TestRepoWatch(t *testing.T) {
 		setting.Service.AutoWatchOnChanges = true
 		session := loginUser(t, "user2")
 		unittest.AssertNotExistsBean(t, &repo_model.Watch{UserID: 2, RepoID: 3})
-		testEditFile(t, session, "org3", "repo3", "master", "README.md", "Hello, World (Edited for watch)\n")
+		testEditFile(t, session, 0, "org3", "repo3", "master", "README.md", "Hello, World (Edited for watch)\n")
 		unittest.AssertExistsAndLoadBean(t, &repo_model.Watch{UserID: 2, RepoID: 3, Mode: repo_model.WatchModeAuto})
 	})
 }

tests/integration/repo_webhook_test.go

@@ -679,7 +679,7 @@ func Test_WebhookPullRequest(t *testing.T) {
 		}, http.StatusOK)
 		defer provider.Close()
 
-		testCtx := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeAll)
+		testCtx := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeAll)
 		// add user4 as collabrator so that it can be a reviewer
 		doAPIAddCollaborator(testCtx, "user4", perm.AccessModeWrite)(t)
 
@@ -928,7 +928,7 @@ func Test_WebhookStatus(t *testing.T) {
 		assert.NoError(t, err)
 
 		// 2. trigger the webhook
-		testCtx := NewAPITestContext(t, "user2", "repo1", auth_model.AccessTokenScopeAll)
+		testCtx := NewAPITestContext(t, "user2", "repo1", 0, auth_model.AccessTokenScopeAll)
 
 		// update a status for a commit via API
 		doAPICreateCommitStatusTest(testCtx, commitID, commitstatus.CommitStatusSuccess, "testci")(t)
@@ -1021,7 +1021,7 @@ jobs:
       - run: echo 'cmd 2'
 `
 		opts := getWorkflowCreateFileOptions(user2, repo1.DefaultBranch, "create "+wfTreePath, wfFileContent)
-		createWorkflowFile(t, token, "user2", "repo1", wfTreePath, repo1.GroupID, opts)
+		createWorkflowFile(t, token, "user2", "repo1", repo1.GroupID, wfTreePath, opts)
 
 		commitID, err := gitRepo1.GetBranchCommitID(repo1.DefaultBranch)
 		assert.NoError(t, err)
@@ -1183,7 +1183,7 @@ func testWorkflowRunEvents(t *testing.T, webhookData *workflowRunWebhook) {
 	session := loginUser(t, "user2")
 	token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
-	testAPICreateWebhookForRepo(t, session, "user2", "repo1", webhookData.URL, "workflow_run")
+	testAPICreateWebhookForRepo(t, session, 0, "user2", "repo1", webhookData.URL, "workflow_run")
 
 	repo1 := unittest.AssertExistsAndLoadBean(t, &repo.Repository{ID: 1})
 
@@ -1262,7 +1262,7 @@ jobs:
     steps:
       - run: exit 0`
 	opts := getWorkflowCreateFileOptions(user2, repo1.DefaultBranch, "create "+wfTreePath, wfFileContent)
-	createWorkflowFile(t, token, "user2", "repo1", wfTreePath, opts)
+	createWorkflowFile(t, token, "user2", "repo1", 0, wfTreePath, opts)
 
 	commitID, err := gitRepo1.GetBranchCommitID(repo1.DefaultBranch)
 	assert.NoError(t, err)
@@ -1308,7 +1308,7 @@ func testWorkflowRunEventsOnRerun(t *testing.T, webhookData *workflowRunWebhook)
 		runners[i].registerAsRepoRunner(t, "user2", "repo1", fmt.Sprintf("mock-runner-%d", i), []string{"ubuntu-latest"}, false)
 	}
 
-	testAPICreateWebhookForRepo(t, session, "user2", "repo1", webhookData.URL, "workflow_run")
+	testAPICreateWebhookForRepo(t, session, 0, "user2", "repo1", webhookData.URL, "workflow_run")
 
 	repo1 := unittest.AssertExistsAndLoadBean(t, &repo.Repository{ID: 1})
 
@@ -1387,7 +1387,7 @@ jobs:
     steps:
       - run: exit 0`
 	opts := getWorkflowCreateFileOptions(user2, repo1.DefaultBranch, "create "+wfTreePath, wfFileContent)
-	createWorkflowFile(t, token, "user2", "repo1", wfTreePath, opts)
+	createWorkflowFile(t, token, "user2", "repo1", 0, wfTreePath, opts)
 
 	commitID, err := gitRepo1.GetBranchCommitID(repo1.DefaultBranch)
 	assert.NoError(t, err)
@@ -1479,7 +1479,7 @@ func testWorkflowRunEventsOnCancellingAbandonedRun(t *testing.T, webhookData *wo
 			fmt.Sprintf("mock-runner-%d", i), []string{"ubuntu-latest"}, false)
 	}
 
-	testAPICreateWebhookForRepo(t, session, "user2", repoName, webhookData.URL, "workflow_run")
+	testAPICreateWebhookForRepo(t, session, 0, "user2", repoName, webhookData.URL, "workflow_run")
 
 	ctx := t.Context()
 	gitRepo, err := gitrepo.OpenRepository(ctx, testRepo)
@@ -1559,7 +1559,7 @@ jobs:
       - run: exit 0`
 
 	opts := getWorkflowCreateFileOptions(user2, testRepo.DefaultBranch, "create "+wfTreePath, wfFileContent)
-	createWorkflowFile(t, token, "user2", repoName, wfTreePath, opts)
+	createWorkflowFile(t, token, "user2", repoName, 0, wfTreePath, opts)
 
 	commitID, err := gitRepo.GetBranchCommitID(testRepo.DefaultBranch)
 	assert.NoError(t, err)
@@ -1720,7 +1720,7 @@ jobs:
     steps:
       - run: echo 'test the webhook'
 `)
-	createWorkflowFile(t, token, "user2", "repo1", ".gitea/workflows/dispatch.yml", repo1.GroupID, opts)
+	createWorkflowFile(t, token, "user2", "repo1", 0, ".gitea/workflows/dispatch.yml", opts)
 
 	// 2.2 trigger the webhooks
 
@@ -1742,7 +1742,7 @@ jobs:
       - run: echo 'cmd 2'
 `
 	opts = getWorkflowCreateFileOptions(user2, repo1.DefaultBranch, "create "+wfTreePath, wfFileContent)
-	createWorkflowFile(t, token, "user2", "repo1", wfTreePath, repo1.GroupID, opts)
+	createWorkflowFile(t, token, "user2", "repo1", repo1.GroupID, wfTreePath, opts)
 
 	commitID, err := gitRepo1.GetBranchCommitID(repo1.DefaultBranch)
 	assert.NoError(t, err)
@@ -1822,7 +1822,7 @@ jobs:
       - run: echo 'test the webhook'
 `
 	opts := getWorkflowCreateFileOptions(user2, repo1.DefaultBranch, "create "+wfTreePath, wfFileContent)
-	createWorkflowFile(t, token, "user2", "repo1", wfTreePath, repo1.GroupID, opts)
+	createWorkflowFile(t, token, "user2", "repo1", repo1.GroupID, wfTreePath, opts)
 
 	commitID, err := gitRepo1.GetBranchCommitID(repo1.DefaultBranch)
 	assert.NoError(t, err)

tests/integration/ssh_key_test.go

@@ -48,8 +48,8 @@ func TestPushDeployKeyOnEmptyRepo(t *testing.T) {
 
 func testPushDeployKeyOnEmptyRepo(t *testing.T, u *url.URL) {
 	// OK login
-	ctx := NewAPITestContext(t, "user2", "deploy-key-empty-repo-1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
-	ctxWithDeleteRepo := NewAPITestContext(t, "user2", "deploy-key-empty-repo-1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+	ctx := NewAPITestContext(t, "user2", "deploy-key-empty-repo-1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+	ctxWithDeleteRepo := NewAPITestContext(t, "user2", "deploy-key-empty-repo-1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
 	keyname := ctx.Reponame + "-push"
 	u.Path = ctx.GitPath()
@@ -92,8 +92,8 @@ func testKeyOnlyOneType(t *testing.T, u *url.URL) {
 	keyname := reponame + "-push"
 
 	// OK login
-	ctx := NewAPITestContext(t, username, reponame, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
-	ctxWithDeleteRepo := NewAPITestContext(t, username, reponame, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+	ctx := NewAPITestContext(t, username, reponame, 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+	ctxWithDeleteRepo := NewAPITestContext(t, username, reponame, 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
 	otherCtx := ctx
 	otherCtx.Reponame = "ssh-key-test-repo-2"

tests/integration/wiki_test.go

@@ -80,7 +80,7 @@ func Test_WikiClone(t *testing.T) {
 		reponame := "repo1"
 		wikiPath := username + "/" + reponame + ".wiki.git"
 		keyname := "my-testing-key"
-		baseAPITestContext := NewAPITestContext(t, username, "repo1", auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+		baseAPITestContext := NewAPITestContext(t, username, "repo1", 0, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
 		u.Path = wikiPath