github-issue-tower-defence-management 1.69.13 → 1.71.0

package/src/adapter/entry-points/cli/index.ts

@@ -19,6 +19,7 @@ import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparati
 import { writeRotationOrderFile } from '../handlers/rotationOrderFileWriter';
 import { ProxyClaudeTokenUsageRepository } from '../../repositories/ProxyClaudeTokenUsageRepository';
 import { NotifyFinishedIssuePreparationUseCase } from '../../../domain/usecases/NotifyFinishedIssuePreparationUseCase';
+import { CheckIssueReviewReadinessUseCase } from '../../../domain/usecases/CheckIssueReviewReadinessUseCase';
 import { LocalStorageRepository } from '../../repositories/LocalStorageRepository';
 import { GraphqlProjectRepository } from '../../repositories/GraphqlProjectRepository';
 import { ApiV3IssueRepository } from '../../repositories/issue/ApiV3IssueRepository';
@@ -53,6 +54,12 @@ type NotifyFinishedOptions = {
   configFilePath: string;
 };
 
+type CheckIssueReviewReadinessOptions = {
+  issueUrl: string;
+  projectUrl?: string;
+  configFilePath: string;
+};
+
 const buildGithubRepositoryParams = (
   localStorageRepository: LocalStorageRepository,
   token: string,
@@ -444,6 +451,100 @@ program
     });
   });
 
+program
+  .command('checkIssueReviewReadiness')
+  .description(
+    'Check whether an issue is in a review-ready state without mutating any field or posting any comment',
+  )
+  .requiredOption(
+    '--configFilePath <path>',
+    'Path to config file for tower defence management',
+  )
+  .requiredOption('--issueUrl <url>', 'GitHub issue URL')
+  .option('--projectUrl <url>', 'GitHub project URL')
+  .action(async (options: CheckIssueReviewReadinessOptions) => {
+    const token = process.env.GH_TOKEN;
+    if (!token) {
+      console.error('GH_TOKEN environment variable is required');
+      process.exit(1);
+    }
+
+    const configFileValues = loadConfigFile(options.configFilePath);
+
+    const cliOverrides: ConfigFile = {
+      projectUrl: options.projectUrl,
+    };
+
+    const tempProjectUrl =
+      cliOverrides.projectUrl ?? configFileValues.projectUrl;
+
+    let readmeOverrides: ConfigFile = {};
+    if (tempProjectUrl) {
+      const readme = await fetchProjectReadme(tempProjectUrl, token);
+      if (readme) {
+        readmeOverrides = parseProjectReadmeConfig(readme, tempProjectUrl);
+      }
+    }
+
+    const config = mergeConfigs(
+      configFileValues,
+      cliOverrides,
+      readmeOverrides,
+    );
+
+    const projectUrl = config.projectUrl;
+
+    if (!projectUrl) {
+      console.error(
+        'projectUrl is required. Provide via --projectUrl, config file, or project README.',
+      );
+      process.exit(1);
+    }
+
+    const projectName = config.projectName ?? 'default';
+    const localStorageRepository = new LocalStorageRepository();
+    const cachePath = `./tmp/cache/${projectName}`;
+    const localStorageCacheRepository = new LocalStorageCacheRepository(
+      localStorageRepository,
+      cachePath,
+    );
+    const githubRepositoryParams = buildGithubRepositoryParams(
+      localStorageRepository,
+      token,
+    );
+    const projectRepository = new GraphqlProjectRepository(
+      ...githubRepositoryParams,
+    );
+    const apiV3IssueRepository = new ApiV3IssueRepository(
+      ...githubRepositoryParams,
+    );
+    const restIssueRepository = new RestIssueRepository(
+      ...githubRepositoryParams,
+    );
+    const graphqlProjectItemRepository = new GraphqlProjectItemRepository(
+      ...githubRepositoryParams,
+    );
+    const issueRepository = new ApiV3CheerioRestIssueRepository(
+      apiV3IssueRepository,
+      restIssueRepository,
+      graphqlProjectItemRepository,
+      localStorageCacheRepository,
+      ...githubRepositoryParams,
+    );
+
+    const useCase = new CheckIssueReviewReadinessUseCase(
+      projectRepository,
+      issueRepository,
+    );
+
+    const result = await useCase.run({
+      projectUrl,
+      issueUrl: options.issueUrl,
+    });
+
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+  });
+
 /* istanbul ignore next */
 if (process.argv && require.main === module) {
   program.parse(process.argv);

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.test.ts

@@ -60,6 +60,14 @@ jest.mock('../../../domain/usecases/AnalyzeStoriesUseCase', () => ({
 jest.mock('../../../domain/usecases/ClearDependedIssueURLUseCase', () => ({
   ClearDependedIssueURLUseCase: jest.fn().mockImplementation(() => ({})),
 }));
+jest.mock(
+  '../../../domain/usecases/SetDependedIssueUrlForOpenTaskPRsUseCase',
+  () => ({
+    SetDependedIssueUrlForOpenTaskPRsUseCase: jest
+      .fn()
+      .mockImplementation(() => ({})),
+  }),
+);
 jest.mock('../../../domain/usecases/CreateEstimationIssueUseCase', () => ({
   CreateEstimationIssueUseCase: jest.fn().mockImplementation(() => ({})),
 }));

package/src/adapter/entry-points/handlers/HandleScheduledEventUseCaseHandler.ts

@@ -26,6 +26,7 @@ import { Project } from '../../../domain/entities/Project';
 import { BaseGitHubRepository } from '../../repositories/BaseGitHubRepository';
 import { AnalyzeStoriesUseCase } from '../../../domain/usecases/AnalyzeStoriesUseCase';
 import { ClearDependedIssueURLUseCase } from '../../../domain/usecases/ClearDependedIssueURLUseCase';
+import { SetDependedIssueUrlForOpenTaskPRsUseCase } from '../../../domain/usecases/SetDependedIssueUrlForOpenTaskPRsUseCase';
 import { CreateEstimationIssueUseCase } from '../../../domain/usecases/CreateEstimationIssueUseCase';
 import { ConvertCheckboxToIssueInStoryIssueUseCase } from '../../../domain/usecases/ConvertCheckboxToIssueInStoryIssueUseCase';
 import { ChangeStatusByStoryColorUseCase } from '../../../domain/usecases/ChangeStatusByStoryColorUseCase';
@@ -239,6 +240,8 @@ export class HandleScheduledEventUseCaseHandler {
     const clearDependedIssueURLUseCase = new ClearDependedIssueURLUseCase(
       issueRepository,
     );
+    const setDependedIssueUrlForOpenTaskPRsUseCase =
+      new SetDependedIssueUrlForOpenTaskPRsUseCase(issueRepository);
     const createEstimationIssueUseCase = new CreateEstimationIssueUseCase(
       issueRepository,
       systemDateRepository,
@@ -303,6 +306,7 @@ export class HandleScheduledEventUseCaseHandler {
       analyzeProblemByIssueUseCase,
       analyzeStoriesUseCase,
       clearDependedIssueURLUseCase,
+      setDependedIssueUrlForOpenTaskPRsUseCase,
       createEstimationIssueUseCase,
       convertCheckboxToIssueInStoryIssueUseCase,
       changeStatusByStoryColorUseCase,

package/src/domain/usecases/CheckIssueReviewReadinessUseCase.test.ts

@@ -0,0 +1,196 @@
+import { CheckIssueReviewReadinessUseCase } from './CheckIssueReviewReadinessUseCase';
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+import { RelatedPullRequest } from './adapter-interfaces/IssueRepository';
+
+const createMockProject = (overrides: Partial<Project> = {}): Project => ({
+  id: 'project-1',
+  url: 'https://github.com/users/user/projects/1',
+  databaseId: 1,
+  name: 'Test Project',
+  status: {
+    name: 'Status',
+    fieldId: 'field-1',
+    statuses: [
+      {
+        id: 'preparation-id',
+        name: 'Preparation',
+        color: 'YELLOW',
+        description: '',
+      },
+    ],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: null,
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+  ...overrides,
+});
+
+const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
+  nameWithOwner: 'user/repo',
+  number: 1,
+  title: 'Test Issue',
+  state: 'OPEN',
+  status: 'Preparation',
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/user/repo/issues/1',
+  assignees: [],
+  labels: [],
+  org: 'user',
+  repo: 'repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2000-01-01T00:00:00Z'),
+  author: 'test-user',
+  ...overrides,
+});
+
+const createReadyPr = (
+  overrides: Partial<RelatedPullRequest> = {},
+): RelatedPullRequest => ({
+  url: 'https://github.com/user/repo/pull/1',
+  branchName: 'feature-branch',
+  createdAt: new Date('2000-01-01T00:00:00Z'),
+  isDraft: false,
+  isConflicted: false,
+  isPassedAllCiJob: true,
+  isCiStateSuccess: true,
+  isResolvedAllReviewComments: true,
+  isBranchOutOfDate: false,
+  missingRequiredCheckNames: [],
+  ...overrides,
+});
+
+describe('CheckIssueReviewReadinessUseCase', () => {
+  let mockProjectRepository: { getByUrl: jest.Mock };
+  let mockIssueRepository: {
+    get: jest.Mock;
+    findRelatedOpenPRs: jest.Mock;
+    getOpenPullRequest: jest.Mock;
+  };
+  let useCase: CheckIssueReviewReadinessUseCase;
+  let mockProject: Project;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+
+    mockProject = createMockProject();
+
+    mockProjectRepository = {
+      getByUrl: jest.fn(),
+    };
+
+    mockIssueRepository = {
+      get: jest.fn(),
+      findRelatedOpenPRs: jest.fn(),
+      getOpenPullRequest: jest.fn(),
+    };
+
+    useCase = new CheckIssueReviewReadinessUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
+  });
+
+  describe('run', () => {
+    it('should return reviewReady=true with empty rejections when the linked PR is ready', async () => {
+      const issue = createMockIssue();
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr(),
+      ]);
+
+      const result = await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+      });
+
+      expect(result.reviewReady).toBe(true);
+      expect(result.rejections).toEqual([]);
+    });
+
+    it('should return reviewReady=false with rejections when the linked PR has failing CI', async () => {
+      const issue = createMockIssue();
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        createReadyPr({
+          isPassedAllCiJob: false,
+          isCiStateSuccess: false,
+        }),
+      ]);
+
+      const result = await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+      });
+
+      expect(result.reviewReady).toBe(false);
+      expect(result.rejections).toHaveLength(1);
+      expect(result.rejections[0].type).toBe(
+        'ANY_CI_JOB_FAILED_OR_IN_PROGRESS',
+      );
+      expect(result.rejections[0].detail).toContain(
+        'https://github.com/user/repo/pull/1',
+      );
+    });
+
+    it('should return reviewReady=false with PULL_REQUEST_NOT_FOUND when no related PR exists', async () => {
+      const issue = createMockIssue();
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      const result = await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+      });
+
+      expect(result.reviewReady).toBe(false);
+      expect(result.rejections).toEqual([
+        { type: 'PULL_REQUEST_NOT_FOUND', detail: 'PULL_REQUEST_NOT_FOUND' },
+      ]);
+    });
+
+    it('should throw IssueNotFoundError when the issue does not exist', async () => {
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(null);
+
+      await expect(
+        useCase.run({
+          projectUrl: 'https://github.com/users/user/projects/1',
+          issueUrl: 'https://github.com/user/repo/issues/999',
+        }),
+      ).rejects.toThrow(
+        'Issue not found: https://github.com/user/repo/issues/999',
+      );
+    });
+
+    it('should not call findRelatedOpenPRs nor mutate state when issue has a category label other than e2e', async () => {
+      const issue = createMockIssue({ labels: ['category:frontend'] });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+
+      const result = await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+      });
+
+      expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+      expect(result.reviewReady).toBe(true);
+      expect(result.rejections).toEqual([]);
+    });
+  });
+});

package/src/domain/usecases/CheckIssueReviewReadinessUseCase.ts

@@ -0,0 +1,45 @@
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import {
+  IssueRejectionEvaluator,
+  PrRejectedReasonType,
+} from './IssueRejectionEvaluator';
+import { IssueNotFoundError } from './NotifyFinishedIssuePreparationUseCase';
+
+export type IssueReviewReadinessResult = {
+  reviewReady: boolean;
+  rejections: { type: PrRejectedReasonType; detail: string }[];
+};
+
+export class CheckIssueReviewReadinessUseCase {
+  private readonly issueRejectionEvaluator: IssueRejectionEvaluator;
+
+  constructor(
+    private readonly projectRepository: Pick<ProjectRepository, 'getByUrl'>,
+    private readonly issueRepository: Pick<
+      IssueRepository,
+      'get' | 'findRelatedOpenPRs' | 'getOpenPullRequest'
+    >,
+  ) {
+    this.issueRejectionEvaluator = new IssueRejectionEvaluator(issueRepository);
+  }
+
+  run = async (params: {
+    projectUrl: string;
+    issueUrl: string;
+  }): Promise<IssueReviewReadinessResult> => {
+    const project = await this.projectRepository.getByUrl(params.projectUrl);
+    const issue = await this.issueRepository.get(params.issueUrl, project);
+
+    if (!issue) {
+      throw new IssueNotFoundError(params.issueUrl);
+    }
+
+    const { rejections } = await this.issueRejectionEvaluator.evaluate(issue);
+
+    return {
+      reviewReady: rejections.length === 0,
+      rejections,
+    };
+  };
+}

package/src/domain/usecases/HandleScheduledEventUseCase.test.ts

@@ -6,6 +6,7 @@ import { ClearPastNextActionDateHourUseCase } from './ClearPastNextActionDateHou
 import { AnalyzeProblemByIssueUseCase } from './AnalyzeProblemByIssueUseCase';
 import { AnalyzeStoriesUseCase } from './AnalyzeStoriesUseCase';
 import { ClearDependedIssueURLUseCase } from './ClearDependedIssueURLUseCase';
+import { SetDependedIssueUrlForOpenTaskPRsUseCase } from './SetDependedIssueUrlForOpenTaskPRsUseCase';
 import { CreateEstimationIssueUseCase } from './CreateEstimationIssueUseCase';
 import { ConvertCheckboxToIssueInStoryIssueUseCase } from './ConvertCheckboxToIssueInStoryIssueUseCase';
 import { DateRepository } from './adapter-interfaces/DateRepository';
@@ -94,6 +95,8 @@ describe('HandleScheduledEventUseCase', () => {
     const mockAnalyzeStoriesUseCase = mock<AnalyzeStoriesUseCase>();
     const mockClearDependedIssueURLUseCase =
       mock<ClearDependedIssueURLUseCase>();
+    const mockSetDependedIssueUrlForOpenTaskPRsUseCase =
+      mock<SetDependedIssueUrlForOpenTaskPRsUseCase>();
     const mockCreateEstimationIssueUseCase =
       mock<CreateEstimationIssueUseCase>();
     const mockConvertCheckboxToIssueInStoryIssueUseCase =
@@ -127,6 +130,7 @@ describe('HandleScheduledEventUseCase', () => {
       mockAnalyzeProblemByIssueUseCase,
       mockAnalyzeStoriesUseCase,
       mockClearDependedIssueURLUseCase,
+      mockSetDependedIssueUrlForOpenTaskPRsUseCase,
       mockCreateEstimationIssueUseCase,
       mockConvertCheckboxToIssueInStoryIssueUseCase,
       mockChangeStatusByStoryColorUseCase,

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -12,6 +12,7 @@ import { ClearPastNextActionDateHourUseCase } from './ClearPastNextActionDateHou
 import { AnalyzeProblemByIssueUseCase } from './AnalyzeProblemByIssueUseCase';
 import { AnalyzeStoriesUseCase } from './AnalyzeStoriesUseCase';
 import { ClearDependedIssueURLUseCase } from './ClearDependedIssueURLUseCase';
+import { SetDependedIssueUrlForOpenTaskPRsUseCase } from './SetDependedIssueUrlForOpenTaskPRsUseCase';
 import { CreateEstimationIssueUseCase } from './CreateEstimationIssueUseCase';
 import { ConvertCheckboxToIssueInStoryIssueUseCase } from './ConvertCheckboxToIssueInStoryIssueUseCase';
 import { ChangeStatusByStoryColorUseCase } from './ChangeStatusByStoryColorUseCase';
@@ -46,6 +47,7 @@ export class HandleScheduledEventUseCase {
     readonly analyzeProblemByIssueUseCase: AnalyzeProblemByIssueUseCase,
     readonly analyzeStoriesUseCase: AnalyzeStoriesUseCase,
     readonly clearDependedIssueURLUseCase: ClearDependedIssueURLUseCase,
+    readonly setDependedIssueUrlForOpenTaskPRsUseCase: SetDependedIssueUrlForOpenTaskPRsUseCase,
     readonly createEstimationIssueUseCase: CreateEstimationIssueUseCase,
     readonly convertCheckboxToIssueInStoryIssueUseCase: ConvertCheckboxToIssueInStoryIssueUseCase,
     readonly changeStatusByStoryColorUseCase: ChangeStatusByStoryColorUseCase,
@@ -377,6 +379,10 @@ ${JSON.stringify(e)}
       issues,
       cacheUsed,
     });
+    await this.setDependedIssueUrlForOpenTaskPRsUseCase.run({
+      project,
+      issues,
+    });
     await this.createEstimationIssueUseCase.run({
       targetDates: targetDateTimes,
       project,

package/src/domain/usecases/SetDependedIssueUrlForOpenTaskPRsUseCase.test.ts

@@ -0,0 +1,214 @@
+import { mock } from 'jest-mock-extended';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { SetDependedIssueUrlForOpenTaskPRsUseCase } from './SetDependedIssueUrlForOpenTaskPRsUseCase';
+import { Project } from '../entities/Project';
+import { Issue } from '../entities/Issue';
+
+describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
+  const mockIssueRepository = mock<IssueRepository>();
+  const useCase = new SetDependedIssueUrlForOpenTaskPRsUseCase(
+    mockIssueRepository,
+  );
+
+  const projectWithField: Project = {
+    ...mock<Project>(),
+    dependedIssueUrlSeparatedByComma: {
+      name: 'Depended Issue URL separated by comma',
+      fieldId: 'depended-field-id',
+    },
+  };
+  const projectWithoutField: Project = {
+    ...mock<Project>(),
+    dependedIssueUrlSeparatedByComma: null,
+  };
+
+  const openTaskIssue: Issue = {
+    ...mock<Issue>(),
+    url: 'https://github.com/owner/repo/issues/1',
+    isPr: false,
+    isClosed: false,
+    state: 'OPEN',
+  };
+  const closedTaskIssue: Issue = {
+    ...mock<Issue>(),
+    url: 'https://github.com/owner/repo/issues/2',
+    isPr: false,
+    isClosed: true,
+    state: 'CLOSED',
+  };
+  const prItem: Issue = {
+    ...mock<Issue>(),
+    url: 'https://github.com/owner/repo/pull/10',
+    isPr: true,
+    isClosed: false,
+    state: 'OPEN',
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call setDependedIssueUrl for each related open PR linked to an open task issue', async () => {
+    mockIssueRepository.findRelatedOpenPRs.mockImplementation(
+      async (issueUrl) => {
+        if (issueUrl === openTaskIssue.url) {
+          return [
+            {
+              url: 'https://github.com/owner/repo/pull/100',
+              branchName: null,
+              createdAt: new Date(0),
+              isDraft: false,
+              isConflicted: false,
+              isPassedAllCiJob: true,
+              isCiStateSuccess: true,
+              isResolvedAllReviewComments: true,
+              isBranchOutOfDate: false,
+              missingRequiredCheckNames: [],
+            },
+          ];
+        }
+        return [];
+      },
+    );
+
+    await useCase.run({
+      project: projectWithField,
+      issues: [openTaskIssue],
+    });
+
+    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+      openTaskIssue.url,
+    );
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledTimes(1);
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+      'https://github.com/owner/repo/pull/100',
+      projectWithField,
+      openTaskIssue.url,
+    );
+  });
+
+  it('should skip closed task issues so that PRs linked only to a closed task are not touched', async () => {
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+    await useCase.run({
+      project: projectWithField,
+      issues: [closedTaskIssue],
+    });
+
+    expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+    expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
+  });
+
+  it('should skip PR project items themselves and only iterate task issues', async () => {
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+    await useCase.run({
+      project: projectWithField,
+      issues: [prItem],
+    });
+
+    expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+    expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
+  });
+
+  it('should not call setDependedIssueUrl when no related open PRs are found for an open task issue', async () => {
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+    await useCase.run({
+      project: projectWithField,
+      issues: [openTaskIssue],
+    });
+
+    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+      openTaskIssue.url,
+    );
+    expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
+  });
+
+  it('should do nothing when the project does not have the depended-issue-url field configured', async () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await useCase.run({
+      project: projectWithoutField,
+      issues: [openTaskIssue],
+    });
+
+    expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+    expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
+    expect(warnSpy).toHaveBeenCalled();
+
+    warnSpy.mockRestore();
+  });
+
+  it('should iterate over each open task issue and request its related open PRs independently', async () => {
+    const secondOpenTaskIssue: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/issues/3',
+      isPr: false,
+      isClosed: false,
+      state: 'OPEN',
+    };
+
+    mockIssueRepository.findRelatedOpenPRs.mockImplementation(
+      async (issueUrl) => {
+        if (issueUrl === openTaskIssue.url) {
+          return [
+            {
+              url: 'https://github.com/owner/repo/pull/100',
+              branchName: null,
+              createdAt: new Date(0),
+              isDraft: false,
+              isConflicted: false,
+              isPassedAllCiJob: true,
+              isCiStateSuccess: true,
+              isResolvedAllReviewComments: true,
+              isBranchOutOfDate: false,
+              missingRequiredCheckNames: [],
+            },
+          ];
+        }
+        if (issueUrl === secondOpenTaskIssue.url) {
+          return [
+            {
+              url: 'https://github.com/owner/repo/pull/200',
+              branchName: null,
+              createdAt: new Date(0),
+              isDraft: false,
+              isConflicted: false,
+              isPassedAllCiJob: true,
+              isCiStateSuccess: true,
+              isResolvedAllReviewComments: true,
+              isBranchOutOfDate: false,
+              missingRequiredCheckNames: [],
+            },
+          ];
+        }
+        return [];
+      },
+    );
+
+    await useCase.run({
+      project: projectWithField,
+      issues: [openTaskIssue, closedTaskIssue, prItem, secondOpenTaskIssue],
+    });
+
+    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledTimes(2);
+    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+      openTaskIssue.url,
+    );
+    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+      secondOpenTaskIssue.url,
+    );
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledTimes(2);
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+      'https://github.com/owner/repo/pull/100',
+      projectWithField,
+      openTaskIssue.url,
+    );
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+      'https://github.com/owner/repo/pull/200',
+      projectWithField,
+      secondOpenTaskIssue.url,
+    );
+  });
+});