Replace integration test with unit test for resolver guard

Per @wxiaoguang's feedback on #37461: the run-level concurrency guard
in checkJobsOfCurrentRunAttempt is function-level logic and is better
covered by a unit test. The unit test sets up a Running holder
attempt and a Blocked sibling attempt in the same concurrency group
directly in the DB, calls checkJobsOfCurrentRunAttempt, and asserts
the blocked job stays Blocked. ~0.3s vs ~3.7s for the integration
version, and no API/git-hook overhead.

Co-Authored-By: Claude (Opus 4.7) <noreply@anthropic.com>

Author: silverwind

services/actions/job_emitter_test.go

@@ -228,3 +228,68 @@ func Test_checkRunConcurrency_NoDuplicateConcurrencyGroupCheck(t *testing.T) {
 		assert.Equal(t, jobBBlocked.ID, jobs[0].ID)
 	}
 }
+
+// Test_checkJobsOfCurrentRunAttempt_RunLevelConcurrencyKeepsJobsBlocked verifies that
+// the resolver does not transition a job out of Blocked while another run still holds
+// the workflow-level concurrency group. Regression for #37446.
+func Test_checkJobsOfCurrentRunAttempt_RunLevelConcurrencyKeepsJobsBlocked(t *testing.T) {
+	assert.NoError(t, unittest.PrepareTestDatabase())
+	ctx := t.Context()
+
+	const group = "test-run-level-concurrency-keeps-blocked"
+
+	// Holder run: Running attempt in the concurrency group.
+	holderRun := &actions_model.ActionRun{
+		RepoID: 4, OwnerID: 1, TriggerUserID: 1,
+		WorkflowID: "test.yml", Index: 9911, Ref: "refs/heads/main",
+		Status: actions_model.StatusRunning,
+	}
+	assert.NoError(t, db.Insert(ctx, holderRun))
+	holderAttempt := &actions_model.ActionRunAttempt{
+		RepoID: 4, RunID: holderRun.ID, Attempt: 1,
+		Status: actions_model.StatusRunning, ConcurrencyGroup: group,
+	}
+	assert.NoError(t, db.Insert(ctx, holderAttempt))
+	_, err := db.Exec(ctx, "UPDATE `action_run` SET latest_attempt_id = ? WHERE id = ?", holderAttempt.ID, holderRun.ID)
+	assert.NoError(t, err)
+
+	// Blocked run: Blocked attempt in the same group, with one Blocked job that has
+	// no needs and no job-level concurrency. Without the run-level guard in
+	// checkJobsOfCurrentRunAttempt, the resolver would transition this job to Waiting.
+	blockedRun := &actions_model.ActionRun{
+		RepoID: 4, OwnerID: 1, TriggerUserID: 1,
+		WorkflowID: "test.yml", Index: 9912, Ref: "refs/heads/main",
+		Status: actions_model.StatusBlocked,
+	}
+	assert.NoError(t, db.Insert(ctx, blockedRun))
+	blockedAttempt := &actions_model.ActionRunAttempt{
+		RepoID: 4, RunID: blockedRun.ID, Attempt: 1,
+		Status: actions_model.StatusBlocked, ConcurrencyGroup: group,
+	}
+	assert.NoError(t, db.Insert(ctx, blockedAttempt))
+	_, err = db.Exec(ctx, "UPDATE `action_run` SET latest_attempt_id = ? WHERE id = ?", blockedAttempt.ID, blockedRun.ID)
+	assert.NoError(t, err)
+	blockedRun.LatestAttemptID = blockedAttempt.ID
+	blockedJob := &actions_model.ActionRunJob{
+		RunID: blockedRun.ID, RunAttemptID: blockedAttempt.ID, AttemptJobID: 1,
+		RepoID: 4, OwnerID: 1, JobID: "job1", Name: "job1",
+		Status: actions_model.StatusBlocked,
+		WorkflowPayload: []byte(`
+name: test
+on: push
+jobs:
+  job1:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo
+`),
+	}
+	assert.NoError(t, db.Insert(ctx, blockedJob))
+
+	_, updated, _, err := checkJobsOfCurrentRunAttempt(ctx, blockedRun)
+	assert.NoError(t, err)
+	assert.Empty(t, updated)
+
+	refreshed := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionRunJob{ID: blockedJob.ID})
+	assert.Equal(t, actions_model.StatusBlocked, refreshed.Status)
+}

tests/integration/actions_concurrency_test.go

@@ -17,7 +17,6 @@ import (
 	repo_model "code.gitea.io/gitea/models/repo"
 	"code.gitea.io/gitea/models/unittest"
 	user_model "code.gitea.io/gitea/models/user"
-	"code.gitea.io/gitea/modules/queue"
 	"code.gitea.io/gitea/modules/setting"
 	api "code.gitea.io/gitea/modules/structs"
 	"code.gitea.io/gitea/modules/timeutil"
@@ -1220,70 +1219,6 @@ jobs:
 	})
 }
 
-// TestScheduleConcurrencyBlockedRunStaysBlocked verifies that a run blocked solely by
-// run-level concurrency is not unblocked by the job-status resolver while another run
-// still holds the same concurrency group.
-func TestScheduleConcurrencyBlockedRunStaysBlocked(t *testing.T) {
-	onGiteaRun(t, func(t *testing.T, u *url.URL) {
-		user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
-		session := loginUser(t, user2.Name)
-		token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeWriteRepository, auth_model.AccessTokenScopeWriteUser)
-
-		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)
-		defer doAPIDeleteRepository(httpContext)(t)
-
-		runner := newMockRunner()
-		runner.registerAsRepoRunner(t, user2.Name, repo.Name, "mock-runner", []string{"ubuntu-latest"}, false)
-
-		wfTreePath := ".gitea/workflows/schedule-concurrency.yml"
-		wfFileContent := `name: schedule-concurrency
-on:
-  push:
-  schedule:
-    - cron:  '@every 1m'
-concurrency:
-  group: schedule-concurrency
-  cancel-in-progress: ${{ gitea.event_name == 'push' }}
-jobs:
-  job:
-    runs-on: ubuntu-latest
-    steps:
-      - run: echo 'schedule workflow'
-`
-		opts := getWorkflowCreateFileOptions(user2, repo.DefaultBranch, "create "+wfTreePath, wfFileContent)
-		createWorkflowFile(t, token, user2.Name, repo.Name, wfTreePath, opts)
-
-		// Push run picks up and holds the "schedule-concurrency" group while it runs.
-		_ = runner.fetchTask(t)
-
-		fireSchedule := func() {
-			t.Helper()
-			spec := unittest.AssertExistsAndLoadBean(t, &actions_model.ActionScheduleSpec{RepoID: repo.ID})
-			spec.Next = timeutil.TimeStampNow()
-			require.NoError(t, actions_model.UpdateScheduleSpec(t.Context(), spec, "next"))
-			require.NoError(t, actions_service.StartScheduleTasks(t.Context()))
-		}
-
-		// Two schedule triggers: the first creates a Blocked run; the second creates another
-		// Blocked run and cancels the first (cancel-in-progress is false for schedule, so
-		// only Waiting/Blocked are cancelled). The cancellation queues EmitJobsIfReadyByRun
-		// and drives the resolver against the surviving Blocked run.
-		fireSchedule()
-		fireSchedule()
-		require.NoError(t, queue.GetManager().FlushAll(t.Context(), 15*time.Second))
-
-		blockedRuns, err := db.Find[actions_model.ActionRun](t.Context(), actions_model.FindRunOptions{
-			RepoID:       repo.ID,
-			TriggerEvent: webhook_module.HookEventSchedule,
-			Status:       []actions_model.Status{actions_model.StatusBlocked},
-		})
-		require.NoError(t, err)
-		require.Len(t, blockedRuns, 1)
-	})
-}
-
 func TestWorkflowAndJobConcurrency(t *testing.T) {
 	onGiteaRun(t, func(t *testing.T, u *url.URL) {
 		user2 := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})