improve test

Author: Zettat123

tests/integration/actions_concurrency_test.go

@@ -1,11 +1,13 @@
 package integration
 
 import (
+	"encoding/base64"
 	"fmt"
 	"net/http"
 	"net/url"
 	"slices"
 	"testing"
+	"time"
 
 	runnerv1 "code.gitea.io/actions-proto-go/runner/v1"
 	actions_model "code.gitea.io/gitea/models/actions"
@@ -14,6 +16,7 @@ import (
 	"code.gitea.io/gitea/models/unittest"
 	user_model "code.gitea.io/gitea/models/user"
 	api "code.gitea.io/gitea/modules/structs"
+	"code.gitea.io/gitea/modules/util"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -29,6 +32,7 @@ func TestWorkflowConcurrency_NoCancellation(t *testing.T) {
 		runner := newMockRunner()
 		runner.registerAsRepoRunner(t, user2.Name, repo.Name, "mock-runner", []string{"ubuntu-latest"})
 
+		// add a variable for test
 		req := NewRequestWithJSON(t, "POST",
 			fmt.Sprintf("/api/v1/repos/%s/%s/actions/variables/qwe", user2.Name, repo.Name), &api.CreateVariableOption{
 				Value: "abc123",
@@ -87,11 +91,9 @@ jobs:
 
 		// fetch and exec workflow1, workflow2 and workflow3 are blocked
 		task := runner.fetchTask(t)
-		actionTask := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionTask{ID: task.Id})
-		actionRunJob := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRunJob{ID: actionTask.JobID})
-		actionRun := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: actionRunJob.RunID})
-		assert.Equal(t, "workflow-main-abc123", actionRun.ConcurrencyGroup)
-		assert.Equal(t, "concurrent-workflow-1.yml", actionRun.WorkflowID)
+		_, _, run := getTaskAndJobAndRunByTaskID(t, task.Id)
+		assert.Equal(t, "workflow-main-abc123", run.ConcurrencyGroup)
+		assert.Equal(t, "concurrent-workflow-1.yml", run.WorkflowID)
 		runner.fetchNoTask(t)
 		runner.execTask(t, task, &mockTaskOutcome{
 			result: runnerv1.Result_RESULT_SUCCESS,
@@ -100,24 +102,20 @@ jobs:
 		// fetch workflow2 or workflow3
 		workflowNames := []string{"concurrent-workflow-2.yml", "concurrent-workflow-3.yml"}
 		task = runner.fetchTask(t)
-		actionTask = unittest.AssertExistsAndLoadBean(t, &actions_model.ActionTask{ID: task.Id})
-		actionRunJob = unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRunJob{ID: actionTask.JobID})
-		actionRun = unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: actionRunJob.RunID})
-		assert.Contains(t, workflowNames, actionRun.WorkflowID)
-		workflowNames = slices.DeleteFunc(workflowNames, func(wfn string) bool { return wfn == actionRun.WorkflowID })
-		assert.Equal(t, "workflow-main-abc123", actionRun.ConcurrencyGroup)
+		_, _, run = getTaskAndJobAndRunByTaskID(t, task.Id)
+		assert.Contains(t, workflowNames, run.WorkflowID)
+		workflowNames = slices.DeleteFunc(workflowNames, func(wfn string) bool { return wfn == run.WorkflowID })
+		assert.Equal(t, "workflow-main-abc123", run.ConcurrencyGroup)
 		runner.fetchNoTask(t)
 		runner.execTask(t, task, &mockTaskOutcome{
 			result: runnerv1.Result_RESULT_SUCCESS,
 		})
 
 		// fetch the last workflow (workflow2 or workflow3)
 		task = runner.fetchTask(t)
-		actionTask = unittest.AssertExistsAndLoadBean(t, &actions_model.ActionTask{ID: task.Id})
-		actionRunJob = unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRunJob{ID: actionTask.JobID})
-		actionRun = unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: actionRunJob.RunID})
-		assert.Equal(t, "workflow-main-abc123", actionRun.ConcurrencyGroup)
-		assert.Equal(t, workflowNames[0], actionRun.WorkflowID)
+		_, _, run = getTaskAndJobAndRunByTaskID(t, task.Id)
+		assert.Equal(t, "workflow-main-abc123", run.ConcurrencyGroup)
+		assert.Equal(t, workflowNames[0], run.WorkflowID)
 		runner.fetchNoTask(t)
 		runner.execTask(t, task, &mockTaskOutcome{
 			result: runnerv1.Result_RESULT_SUCCESS,
@@ -130,84 +128,121 @@ jobs:
 
 func TestWorkflowConcurrency_WithCancellation(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
+		// user2 is the owner of the base repo
 		user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
-		session := loginUser(t, user2.Name)
-		token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+		user2Session := loginUser(t, user2.Name)
+		user2Token := getTokenForLoggedInUser(t, user2Session, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
+		// user4 is the owner of the forked repo
+		user4 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 4})
+		user4Token := getTokenForLoggedInUser(t, loginUser(t, user4.Name), auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
 
-		apiRepo := createActionsTestRepo(t, token, "actions-concurrency", false)
-		repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: apiRepo.ID})
-		runner := newMockRunner()
-		runner.registerAsRepoRunner(t, user2.Name, repo.Name, "mock-runner", []string{"ubuntu-latest"})
+		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)
 
-		req := NewRequestWithJSON(t, "POST",
-			fmt.Sprintf("/api/v1/repos/%s/%s/actions/variables/qwe", user2.Name, repo.Name), &api.CreateVariableOption{
-				Value: "abc123",
-			}).
-			AddTokenAuth(token)
-		MakeRequest(t, req, http.StatusNoContent)
+		runner := newMockRunner()
+		runner.registerAsRepoRunner(t, baseRepo.OwnerName, baseRepo.Name, "mock-runner", []string{"ubuntu-latest"})
 
-		wf1TreePath := ".gitea/workflows/concurrent-workflow-1.yml"
-		wf1FileContent := `name: concurrent-workflow-1
-on: 
-  push:
-    paths:
-      - '.gitea/workflows/concurrent-workflow-1.yml'
+		// init the workflow
+		wfTreePath := ".gitea/workflows/pull.yml"
+		wfFileContent := `name: Pull Request
+on: pull_request
 concurrency:
-  group: workflow-main-abc123
+  group: pull-request-test
+  cancel-in-progress: ${{ !startsWith(github.ref_name, 'dev-pub/') }}
 jobs:
   wf1-job:
     runs-on: ubuntu-latest
     steps:
-      - run: echo 'job from workflow1'
+      - run: echo 'test the pull'
 `
-		wf2TreePath := ".gitea/workflows/concurrent-workflow-2.yml"
-		wf2FileContent := `name: concurrent-workflow-2
-on: 
-  push:
-    paths:
-      - '.gitea/workflows/concurrent-workflow-2.yml'
-concurrency:
-  group: workflow-${{ github.ref_name }}-${{ vars.qwe }}
-  cancel-in-progress: ${{ github.ref_name == 'main' }}
-jobs:
-  wf2-job:
-    runs-on: ubuntu-latest
-    steps:
-      - run: echo 'job from workflow2'
-`
-
-		// push workflow1
-		opts1 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, fmt.Sprintf("create %s", wf1TreePath), wf1FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf1TreePath, opts1)
-		// fetch the task of workflow1
-		task1 := runner.fetchTask(t)
-		actionTask1 := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionTask{ID: task1.Id})
-		actionRunJob1 := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRunJob{ID: actionTask1.JobID})
-		actionRun1 := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: actionRunJob1.RunID})
-		assert.Equal(t, "workflow-main-abc123", actionRun1.ConcurrencyGroup)
-		assert.Equal(t, "concurrent-workflow-1.yml", actionRun1.WorkflowID)
-		assert.False(t, actionRun1.ConcurrencyCancel)
-		assert.True(t, actionRun1.Status.IsRunning())
-
-		// push workflow2
-		opts2 := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, fmt.Sprintf("create %s", wf2TreePath), wf2FileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wf2TreePath, opts2)
-		// fetch the task of workflow2
-		task2 := runner.fetchTask(t)
-		actionTask2 := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionTask{ID: task2.Id})
-		actionRunJob2 := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRunJob{ID: actionTask2.JobID})
-		actionRun2 := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: actionRunJob2.RunID})
-		assert.Equal(t, "workflow-main-abc123", actionRun2.ConcurrencyGroup)
-		assert.Equal(t, "concurrent-workflow-2.yml", actionRun2.WorkflowID)
-		assert.True(t, actionRun2.ConcurrencyCancel)
-		assert.True(t, actionRun2.Status.IsRunning())
-
-		// after pushing workflow2, the status of the run of workflow1 should be "cancelled"
-		// fetch the last workflow (workflow2 or workflow3)
-		actionRun1 = unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: actionRunJob1.RunID})
-		assert.True(t, actionRun1.Status.IsCancelled())
-
-		httpContext := NewAPITestContext(t, user2.Name, repo.Name, auth_model.AccessTokenScopeWriteRepository)
-		doAPIDeleteRepository(httpContext)(t)
+		opts1 := getWorkflowCreateFileOptions(user2, baseRepo.DefaultBranch, fmt.Sprintf("create %s", wfTreePath), wfFileContent)
+		createWorkflowFile(t, user2Token, baseRepo.OwnerName, baseRepo.Name, wfTreePath, opts1)
+		// user2 creates a pull request
+		doAPICreateFile(user2APICtx, "user2-fix.txt", &api.CreateFileOptions{
+			FileOptions: api.FileOptions{
+				NewBranchName: "bugfix/aaa",
+				Message:       "create user2-fix.txt",
+				Author: api.Identity{
+					Name:  user4.Name,
+					Email: user4.Email,
+				},
+				Committer: api.Identity{
+					Name:  user4.Name,
+					Email: user4.Email,
+				},
+				Dates: api.CommitDateOptions{
+					Author:    time.Now(),
+					Committer: time.Now(),
+				},
+			},
+			ContentBase64: base64.StdEncoding.EncodeToString([]byte("user2-fix")),
+		})(t)
+		doAPICreatePullRequest(user2APICtx, baseRepo.OwnerName, baseRepo.Name, baseRepo.DefaultBranch, "bugfix/aaa")(t)
+		pr1Task1 := runner.fetchTask(t)
+		_, _, pr1Run1 := getTaskAndJobAndRunByTaskID(t, pr1Task1.Id)
+		assert.Equal(t, "pull-request-test", pr1Run1.ConcurrencyGroup)
+		assert.True(t, pr1Run1.ConcurrencyCancel)
+		assert.True(t, pr1Run1.Status.IsRunning())
+
+		// user4 forks the repo
+		req := NewRequestWithJSON(t, "POST", fmt.Sprintf("/api/v1/repos/%s/%s/forks", baseRepo.OwnerName, baseRepo.Name),
+			&api.CreateForkOption{
+				Name: util.ToPointer("actions-concurrency-fork"),
+			}).AddTokenAuth(user4Token)
+		resp := MakeRequest(t, req, http.StatusAccepted)
+		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)
+		// user4 creates a pull request
+		doAPICreateFile(user4APICtx, "user4-fix.txt", &api.CreateFileOptions{
+			FileOptions: api.FileOptions{
+				NewBranchName: "bugfix/bbb",
+				Message:       "create user4-fix.txt",
+				Author: api.Identity{
+					Name:  user4.Name,
+					Email: user4.Email,
+				},
+				Committer: api.Identity{
+					Name:  user4.Name,
+					Email: user4.Email,
+				},
+				Dates: api.CommitDateOptions{
+					Author:    time.Now(),
+					Committer: time.Now(),
+				},
+			},
+			ContentBase64: base64.StdEncoding.EncodeToString([]byte("user4-fix")),
+		})(t)
+		doAPICreatePullRequest(user4APICtx, baseRepo.OwnerName, baseRepo.Name, baseRepo.DefaultBranch, fmt.Sprintf("%s:bugfix/bbb", user4.Name))(t)
+		// cannot fetch the task because an approval is required
+		runner.fetchNoTask(t)
+		// user2 approves the run
+		pr2Run1 := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{RepoID: baseRepo.ID, TriggerUserID: user4.ID})
+		req = NewRequestWithValues(t, "POST",
+			fmt.Sprintf("/%s/%s/actions/runs/%d/approve", baseRepo.OwnerName, baseRepo.Name, pr2Run1.Index),
+			map[string]string{
+				"_csrf": GetUserCSRFToken(t, user2Session),
+			})
+		user2Session.MakeRequest(t, req, http.StatusOK)
+		// fetch the task and the previous task has been cancelled
+		runner.fetchTask(t)
+		pr2Run1 = unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: pr2Run1.ID})
+		assert.Equal(t, "pull-request-test", pr2Run1.ConcurrencyGroup)
+		assert.True(t, pr2Run1.ConcurrencyCancel)
+		assert.True(t, pr2Run1.Status.IsRunning())
+		pr1Run1 = unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: pr1Run1.ID})
+		assert.True(t, pr1Run1.Status.IsCancelled())
+
+		doAPIDeleteRepository(user4APICtx)(t)
+		doAPIDeleteRepository(user2APICtx)(t)
 	})
 }
+
+func getTaskAndJobAndRunByTaskID(t *testing.T, taskID int64) (*actions_model.ActionTask, *actions_model.ActionRunJob, *actions_model.ActionRun) {
+	actionTask := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionTask{ID: taskID})
+	actionRunJob := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRunJob{ID: actionTask.JobID})
+	actionRun := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRun{ID: actionRunJob.RunID})
+	return actionTask, actionRunJob, actionRun
+}