github-issue-tower-defence-management 1.103.1 → 1.104.1

package/src/domain/usecases/RevertNotReadyReviewQueueIssueUseCase.ts

@@ -9,17 +9,15 @@ import {
   DEFAULT_STATUS_NAME,
 } from '../entities/WorkflowStatus';
 
-const DEPENDENCY_UPDATE_BOT_AUTHORS = ['dependabot[bot]', 'renovate[bot]'];
-
 const isAuthorAuthorizedForAutoStatusCheck = (
   author: string,
-  allowedIssueAuthors: string[] | null,
+  allowedIssueAuthors: string[] | null | undefined,
 ): boolean => {
-  if (DEPENDENCY_UPDATE_BOT_AUTHORS.includes(author)) {
-    return true;
+  if (allowedIssueAuthors === null || allowedIssueAuthors === undefined) {
+    return false;
   }
-  if (allowedIssueAuthors === null) {
-    return true;
+  if (allowedIssueAuthors.length === 0) {
+    return false;
   }
   return allowedIssueAuthors.includes(author);
 };

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

@@ -32,6 +32,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   isClosed: false,
   createdAt: new Date(),
   author: '',
+  closingIssueReferenceUrls: [],
   ...overrides,
 });
 

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

@@ -28,6 +28,7 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
     isPr: false,
     isClosed: false,
     state: 'OPEN',
+    closingIssueReferenceUrls: [],
   };
   const closedTaskIssue: Issue = {
     ...mock<Issue>(),
@@ -35,50 +36,28 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
     isPr: false,
     isClosed: true,
     state: 'CLOSED',
+    closingIssueReferenceUrls: [],
   };
-  const prItem: Issue = {
+
+  const openPrClosingIssue1: Issue = {
     ...mock<Issue>(),
-    url: 'https://github.com/owner/repo/pull/10',
+    url: 'https://github.com/owner/repo/pull/100',
     isPr: true,
     isClosed: false,
     state: 'OPEN',
+    closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/1'],
   };
 
   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 [];
-      },
-    );
-
+  it('should call setDependedIssueUrl for each open PR whose closing keyword targets an open task issue', async () => {
     await useCase.run({
       project: projectWithField,
-      issues: [openTaskIssue],
+      issues: [openTaskIssue, openPrClosingIssue1],
     });
 
-    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
-      openTaskIssue.url,
-    );
     expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledTimes(1);
     expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
       'https://github.com/owner/repo/pull/100',
@@ -87,41 +66,108 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
     );
   });
 
+  it('should never call the per-issue timeline lookup', async () => {
+    await useCase.run({
+      project: projectWithField,
+      issues: [openTaskIssue, openPrClosingIssue1],
+    });
+
+    expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+  });
+
   it('should skip closed task issues so that PRs linked only to a closed task are not touched', async () => {
-    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+    const openPrClosingClosedIssue: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/101',
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/2'],
+    };
 
     await useCase.run({
       project: projectWithField,
-      issues: [closedTaskIssue],
+      issues: [closedTaskIssue, openPrClosingClosedIssue],
     });
 
-    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([]);
+  it('should ignore closed PRs even when they declare a closing keyword for an open task issue', async () => {
+    const closedPrClosingIssue1: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/102',
+      isPr: true,
+      isClosed: true,
+      state: 'CLOSED',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/1'],
+    };
 
     await useCase.run({
       project: projectWithField,
-      issues: [prItem],
+      issues: [openTaskIssue, closedPrClosingIssue1],
     });
 
-    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([]);
+  it('should ignore bare mentions because they are absent from the closing-keyword set', async () => {
+    const openPrMentioningButNotClosing: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/103',
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: [],
+    };
 
     await useCase.run({
       project: projectWithField,
-      issues: [openTaskIssue],
+      issues: [openTaskIssue, openPrMentioningButNotClosing],
     });
 
-    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
-      openTaskIssue.url,
+    expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
+  });
+
+  it('should map a cross-repo closing target by full issue URL', async () => {
+    const crossRepoOpenTaskIssue: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/other-repo/issues/9',
+      isPr: false,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: [],
+    };
+    const openPrClosingCrossRepoIssue: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/104',
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: [
+        'https://github.com/owner/other-repo/issues/9',
+      ],
+    };
+
+    await useCase.run({
+      project: projectWithField,
+      issues: [crossRepoOpenTaskIssue, openPrClosingCrossRepoIssue],
+    });
+
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledTimes(1);
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+      'https://github.com/owner/repo/pull/104',
+      projectWithField,
+      crossRepoOpenTaskIssue.url,
     );
+  });
+
+  it('should not call setDependedIssueUrl when no open PR closes an open task issue', async () => {
+    await useCase.run({
+      project: projectWithField,
+      issues: [openTaskIssue],
+    });
+
     expect(mockIssueRepository.setDependedIssueUrl).not.toHaveBeenCalled();
   });
 
@@ -130,75 +176,72 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
 
     await useCase.run({
       project: projectWithoutField,
-      issues: [openTaskIssue],
+      issues: [openTaskIssue, openPrClosingIssue1],
     });
 
-    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 () => {
+  it('should set dependencies for multiple open task issues from their respective open PRs', async () => {
     const secondOpenTaskIssue: Issue = {
       ...mock<Issue>(),
       url: 'https://github.com/owner/repo/issues/3',
       isPr: false,
       isClosed: false,
       state: 'OPEN',
+      closingIssueReferenceUrls: [],
+    };
+    const openPrClosingIssue3: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/200',
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/3'],
     };
-
-    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],
+      issues: [
+        openTaskIssue,
+        closedTaskIssue,
+        openPrClosingIssue1,
+        secondOpenTaskIssue,
+        openPrClosingIssue3,
+      ],
     });
 
-    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledTimes(2);
-    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledTimes(2);
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+      'https://github.com/owner/repo/pull/100',
+      projectWithField,
       openTaskIssue.url,
     );
-    expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+    expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
+      'https://github.com/owner/repo/pull/200',
+      projectWithField,
       secondOpenTaskIssue.url,
     );
+  });
+
+  it('should set dependencies for every open PR that closes the same open task issue', async () => {
+    const secondOpenPrClosingIssue1: Issue = {
+      ...mock<Issue>(),
+      url: 'https://github.com/owner/repo/pull/105',
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/1'],
+    };
+
+    await useCase.run({
+      project: projectWithField,
+      issues: [openTaskIssue, openPrClosingIssue1, secondOpenPrClosingIssue1],
+    });
+
     expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledTimes(2);
     expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
       'https://github.com/owner/repo/pull/100',
@@ -206,9 +249,9 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
       openTaskIssue.url,
     );
     expect(mockIssueRepository.setDependedIssueUrl).toHaveBeenCalledWith(
-      'https://github.com/owner/repo/pull/200',
+      'https://github.com/owner/repo/pull/105',
       projectWithField,
-      secondOpenTaskIssue.url,
+      openTaskIssue.url,
     );
   });
 
@@ -216,33 +259,23 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
     const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
     const failingPrUrl = 'https://github.com/owner/repo/pull/100';
     const succeedingPrUrl = 'https://github.com/owner/repo/pull/200';
+    const failingPr: Issue = {
+      ...mock<Issue>(),
+      url: failingPrUrl,
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/1'],
+    };
+    const succeedingPr: Issue = {
+      ...mock<Issue>(),
+      url: succeedingPrUrl,
+      isPr: true,
+      isClosed: false,
+      state: 'OPEN',
+      closingIssueReferenceUrls: ['https://github.com/owner/repo/issues/1'],
+    };
 
-    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
-      {
-        url: failingPrUrl,
-        branchName: null,
-        createdAt: new Date(0),
-        isDraft: false,
-        isConflicted: false,
-        isPassedAllCiJob: true,
-        isCiStateSuccess: true,
-        isResolvedAllReviewComments: true,
-        isBranchOutOfDate: false,
-        missingRequiredCheckNames: [],
-      },
-      {
-        url: succeedingPrUrl,
-        branchName: null,
-        createdAt: new Date(0),
-        isDraft: false,
-        isConflicted: false,
-        isPassedAllCiJob: true,
-        isCiStateSuccess: true,
-        isResolvedAllReviewComments: true,
-        isBranchOutOfDate: false,
-        missingRequiredCheckNames: [],
-      },
-    ]);
     mockIssueRepository.setDependedIssueUrl.mockImplementation(
       async (prUrl) => {
         if (prUrl === failingPrUrl) {
@@ -254,7 +287,7 @@ describe('SetDependedIssueUrlForOpenTaskPRsUseCase', () => {
     await expect(
       useCase.run({
         project: projectWithField,
-        issues: [openTaskIssue],
+        issues: [openTaskIssue, failingPr, succeedingPr],
       }),
     ).resolves.toBeUndefined();
 

package/src/domain/usecases/SetDependedIssueUrlForOpenTaskPRsUseCase.ts

@@ -4,10 +4,7 @@ import { IssueRepository } from './adapter-interfaces/IssueRepository';
 
 export class SetDependedIssueUrlForOpenTaskPRsUseCase {
   constructor(
-    readonly issueRepository: Pick<
-      IssueRepository,
-      'findRelatedOpenPRs' | 'setDependedIssueUrl'
-    >,
+    readonly issueRepository: Pick<IssueRepository, 'setDependedIssueUrl'>,
   ) {}
 
   run = async (input: { project: Project; issues: Issue[] }): Promise<void> => {
@@ -17,26 +14,54 @@ export class SetDependedIssueUrlForOpenTaskPRsUseCase {
       );
       return;
     }
+    const openPrUrlsByClosedIssueUrl = this.buildOpenPrUrlsByClosedIssueUrl(
+      input.issues,
+    );
     for (const issue of input.issues) {
       if (issue.isPr || issue.isClosed) {
         continue;
       }
-      const relatedOpenPRs = await this.issueRepository.findRelatedOpenPRs(
-        issue.url,
-      );
-      for (const pr of relatedOpenPRs) {
+      const relatedOpenPrUrls = openPrUrlsByClosedIssueUrl.get(issue.url);
+      if (!relatedOpenPrUrls) {
+        continue;
+      }
+      for (const prUrl of relatedOpenPrUrls) {
         try {
           await this.issueRepository.setDependedIssueUrl(
-            pr.url,
+            prUrl,
             input.project,
             issue.url,
           );
         } catch (error) {
           console.warn(
-            `Failed to set depended issue URL for PR ${pr.url}, skipping and continuing with remaining PRs: ${error instanceof Error ? error.message : String(error)}`,
+            `Failed to set depended issue URL for PR ${prUrl}, skipping and continuing with remaining PRs: ${error instanceof Error ? error.message : String(error)}`,
           );
         }
       }
     }
   };
+
+  private buildOpenPrUrlsByClosedIssueUrl = (
+    issues: Issue[],
+  ): Map<string, string[]> => {
+    const openPrUrlsByClosedIssueUrl = new Map<string, Set<string>>();
+    for (const issue of issues) {
+      if (!issue.isPr || issue.isClosed) {
+        continue;
+      }
+      for (const closedIssueUrl of issue.closingIssueReferenceUrls) {
+        const existing = openPrUrlsByClosedIssueUrl.get(closedIssueUrl);
+        if (existing) {
+          existing.add(issue.url);
+        } else {
+          openPrUrlsByClosedIssueUrl.set(closedIssueUrl, new Set([issue.url]));
+        }
+      }
+    }
+    const result = new Map<string, string[]>();
+    for (const [closedIssueUrl, prUrls] of openPrUrlsByClosedIssueUrl) {
+      result.set(closedIssueUrl, Array.from(prUrls));
+    }
+    return result;
+  };
 }

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

@@ -72,6 +72,7 @@ const buildIssue = (overrides: Partial<Issue>): Issue => ({
   isClosed: false,
   createdAt: new Date('2024-01-01'),
   author: 'user',
+  closingIssueReferenceUrls: [],
   ...overrides,
 });