github-issue-tower-defence-management 1.185.0 → 1.186.0

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

@@ -0,0 +1,165 @@
+import { mock } from 'jest-mock-extended';
+import { IssueNoStatusUpdateUseCase } from './IssueNoStatusUpdateUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Issue } from '../entities/Issue';
+import { FieldOption, Project } from '../entities/Project';
+
+describe('IssueNoStatusUpdateUseCase', () => {
+  const mockIssueRepository = mock<IssueRepository>();
+
+  const awaitingWorkspaceStatus = mock<FieldOption>();
+  awaitingWorkspaceStatus.id = 'status-awaiting';
+  awaitingWorkspaceStatus.name = 'Awaiting Workspace';
+
+  const inProgressStatus = mock<FieldOption>();
+  inProgressStatus.id = 'status-in-progress';
+  inProgressStatus.name = 'In Progress';
+
+  const basicProject: Project = {
+    ...mock<Project>(),
+    status: {
+      name: 'Status',
+      fieldId: 'statusFieldId',
+      statuses: [awaitingWorkspaceStatus, inProgressStatus],
+    },
+  };
+
+  const projectWithoutAwaitingWorkspace: Project = {
+    ...mock<Project>(),
+    status: {
+      name: 'Status',
+      fieldId: 'statusFieldId',
+      statuses: [inProgressStatus],
+    },
+  };
+
+  const openNullStatusIssue: Issue = {
+    ...mock<Issue>(),
+    isClosed: false,
+    status: null,
+  };
+
+  const openInProgressIssue: Issue = {
+    ...mock<Issue>(),
+    isClosed: false,
+    status: 'In Progress',
+  };
+
+  const closedNullStatusIssue: Issue = {
+    ...mock<Issue>(),
+    isClosed: true,
+    status: null,
+  };
+
+  let useCase: IssueNoStatusUpdateUseCase;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    useCase = new IssueNoStatusUpdateUseCase(mockIssueRepository);
+  });
+
+  describe('run', () => {
+    const testCases: {
+      name: string;
+      project: Project;
+      issues: Issue[];
+      expectedUpdateStatusCalls: [Project, Issue, string][];
+    }[] = [
+      {
+        name: 'should call updateStatus for open issues with null status',
+        project: basicProject,
+        issues: [openNullStatusIssue],
+        expectedUpdateStatusCalls: [
+          [basicProject, openNullStatusIssue, 'status-awaiting'],
+        ],
+      },
+      {
+        name: 'should skip issues with an existing status',
+        project: basicProject,
+        issues: [openInProgressIssue],
+        expectedUpdateStatusCalls: [],
+      },
+      {
+        name: 'should skip closed issues with null status',
+        project: basicProject,
+        issues: [closedNullStatusIssue],
+        expectedUpdateStatusCalls: [],
+      },
+      {
+        name: 'should not call updateStatus when Awaiting Workspace status does not exist in project',
+        project: projectWithoutAwaitingWorkspace,
+        issues: [openNullStatusIssue],
+        expectedUpdateStatusCalls: [],
+      },
+      {
+        name: 'should handle empty issues array',
+        project: basicProject,
+        issues: [],
+        expectedUpdateStatusCalls: [],
+      },
+      {
+        name: 'should call updateStatus only for open null-status issues among mixed issues',
+        project: basicProject,
+        issues: [
+          openNullStatusIssue,
+          openInProgressIssue,
+          closedNullStatusIssue,
+        ],
+        expectedUpdateStatusCalls: [
+          [basicProject, openNullStatusIssue, 'status-awaiting'],
+        ],
+      },
+    ];
+
+    testCases.forEach(
+      ({ name, project, issues, expectedUpdateStatusCalls }) => {
+        it(name, async () => {
+          await useCase.run({ project, issues });
+
+          expect(mockIssueRepository.updateStatus.mock.calls).toEqual(
+            expectedUpdateStatusCalls,
+          );
+        });
+      },
+    );
+
+    it('should skip archived items and continue updating remaining issues', async () => {
+      const archivedIssue: Issue = {
+        ...mock<Issue>(),
+        isClosed: false,
+        status: null,
+      };
+      const normalIssue: Issue = {
+        ...mock<Issue>(),
+        isClosed: false,
+        status: null,
+      };
+
+      mockIssueRepository.updateStatus
+        .mockRejectedValueOnce(
+          new Error('The item is archived and cannot be updated'),
+        )
+        .mockResolvedValueOnce(undefined);
+
+      await useCase.run({
+        project: basicProject,
+        issues: [archivedIssue, normalIssue],
+      });
+
+      expect(mockIssueRepository.updateStatus.mock.calls).toEqual([
+        [basicProject, archivedIssue, 'status-awaiting'],
+        [basicProject, normalIssue, 'status-awaiting'],
+      ]);
+    });
+
+    it('should re-throw non-archived errors from updateStatus', async () => {
+      mockIssueRepository.updateStatus.mockRejectedValueOnce(
+        new Error('GraphQL rate limit exceeded'),
+      );
+
+      await expect(
+        useCase.run({ project: basicProject, issues: [openNullStatusIssue] }),
+      ).rejects.toThrow('GraphQL rate limit exceeded');
+    });
+  });
+});

package/src/domain/usecases/IssueNoStatusUpdateUseCase.ts

@@ -0,0 +1,44 @@
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+import { AWAITING_WORKSPACE_STATUS_NAME } from '../entities/WorkflowStatus';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+
+const isArchivedProjectItemError = (error: unknown): boolean => {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.toLowerCase().includes('archived');
+};
+
+export class IssueNoStatusUpdateUseCase {
+  constructor(
+    readonly issueRepository: Pick<IssueRepository, 'updateStatus'>,
+  ) {}
+
+  run = async (input: { project: Project; issues: Issue[] }): Promise<void> => {
+    const awaitingWorkspaceStatus = input.project.status.statuses.find(
+      (s) => s.name === AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    if (!awaitingWorkspaceStatus) {
+      return;
+    }
+    for (const issue of input.issues) {
+      if (issue.isClosed || issue.status !== null) {
+        continue;
+      }
+      try {
+        await this.issueRepository.updateStatus(
+          input.project,
+          issue,
+          awaitingWorkspaceStatus.id,
+        );
+      } catch (error) {
+        if (isArchivedProjectItemError(error)) {
+          console.warn(
+            `IssueNoStatusUpdateUseCase: project item is archived and cannot be updated, skipping. issueUrl: ${issue.url}`,
+          );
+          continue;
+        }
+        throw error;
+      }
+    }
+  };
+}

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

@@ -858,6 +858,126 @@ describe('IssueRejectionEvaluator', () => {
       });
     });
 
+    describe('detectConflictEvenIfEvaluationSkipped option', () => {
+      it('should call findRelatedOpenPRs and return PULL_REQUEST_CONFLICTED when relatedOpenPrUrls is null and PR is conflicted', async () => {
+        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+          createReadyPr('https://github.com/user/repo/pull/1', {
+            isConflicted: true,
+          }),
+        ]);
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+            agent: 'chore',
+          },
+          [],
+          {
+            detectConflictEvenIfEvaluationSkipped: true,
+            relatedOpenPrUrls: null,
+          },
+        );
+
+        expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+          'https://github.com/user/repo/issues/1',
+        );
+        expect(result.rejections).toHaveLength(1);
+        expect(result.rejections[0].type).toBe('PULL_REQUEST_CONFLICTED');
+        expect(result.approvedPrUrl).toBeNull();
+      });
+
+      it('should call findRelatedOpenPRs and return no rejections when relatedOpenPrUrls is null and no PR is conflicted', async () => {
+        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+          createReadyPr('https://github.com/user/repo/pull/1'),
+        ]);
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+            agent: 'chore',
+          },
+          [],
+          {
+            detectConflictEvenIfEvaluationSkipped: true,
+            relatedOpenPrUrls: null,
+          },
+        );
+
+        expect(mockIssueRepository.findRelatedOpenPRs).toHaveBeenCalledWith(
+          'https://github.com/user/repo/issues/1',
+        );
+        expect(result.rejections).toHaveLength(0);
+        expect(result.approvedPrUrl).toBeNull();
+      });
+
+      it('should use resolveOpenPrsFromUrls path and not call findRelatedOpenPRs when relatedOpenPrUrls is provided', async () => {
+        mockIssueRepository.getOpenPullRequest.mockResolvedValue(
+          createReadyPr('https://github.com/user/repo/pull/5', {
+            isConflicted: true,
+          }),
+        );
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+            agent: 'chore',
+          },
+          [],
+          {
+            detectConflictEvenIfEvaluationSkipped: true,
+            relatedOpenPrUrls: ['https://github.com/user/repo/pull/5'],
+          },
+        );
+
+        expect(mockIssueRepository.findRelatedOpenPRs).not.toHaveBeenCalled();
+        expect(mockIssueRepository.getOpenPullRequest).toHaveBeenCalledWith(
+          'https://github.com/user/repo/pull/5',
+        );
+        expect(result.rejections).toHaveLength(1);
+        expect(result.rejections[0].type).toBe('PULL_REQUEST_CONFLICTED');
+      });
+
+      it('should emit only PULL_REQUEST_CONFLICTED and not PULL_REQUEST_IS_DRAFT or other types when evaluation is skipped', async () => {
+        mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+          createReadyPr('https://github.com/user/repo/pull/1', {
+            isConflicted: true,
+            isDraft: true,
+            isPassedAllCiJob: false,
+            isCiStateSuccess: false,
+          }),
+        ]);
+
+        const result = await evaluator.evaluate(
+          {
+            url: 'https://github.com/user/repo/issues/1',
+            labels: [],
+            isPr: false,
+            agent: 'chore',
+          },
+          [],
+          {
+            detectConflictEvenIfEvaluationSkipped: true,
+            relatedOpenPrUrls: null,
+          },
+        );
+
+        expect(result.rejections).toHaveLength(1);
+        expect(result.rejections[0].type).toBe('PULL_REQUEST_CONFLICTED');
+        expect(result.rejections.map((r) => r.type)).not.toContain(
+          'PULL_REQUEST_IS_DRAFT',
+        );
+        expect(result.rejections.map((r) => r.type)).not.toContain(
+          'ANY_CI_JOB_FAILED_OR_IN_PROGRESS',
+        );
+      });
+    });
+
     describe('change-target-must: label behavior', () => {
       const prUrl = 'https://github.com/user/repo/pull/1';
 

package/src/domain/usecases/IssueRejectionEvaluator.ts

@@ -37,6 +37,7 @@ export type EvaluateOptions = {
   // The agent name treated as the developer agent for PR/CI/conflict checks.
   // When null or undefined, defaults to 'developer'.
   developerAgentName?: string | null;
+  detectConflictEvenIfEvaluationSkipped?: boolean;
 };
 
 export class IssueRejectionEvaluator {
@@ -186,6 +187,26 @@ export class IssueRejectionEvaluator {
           approvedPrUrl = pr.url;
         }
       }
+    } else if (options.detectConflictEvenIfEvaluationSkipped) {
+      let prsToCheck: RelatedPullRequest[];
+      if (options.relatedOpenPrUrls != null) {
+        const resolved = await this.resolveOpenPrsFromUrls(
+          options.relatedOpenPrUrls,
+          options.resolvedOpenPrByUrl ?? null,
+        );
+        prsToCheck = resolved.prs;
+      } else {
+        prsToCheck = await this.issueRepository.findRelatedOpenPRs(issue.url);
+      }
+      for (const pr of prsToCheck) {
+        if (pr.isConflicted) {
+          rejections.push({
+            type: 'PULL_REQUEST_CONFLICTED',
+            detail: `PULL_REQUEST_CONFLICTED: ${pr.url}`,
+          });
+          break;
+        }
+      }
     }
 
     return { rejections, approvedPrUrl };

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

@@ -76,6 +76,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   author: '',
   closingIssueReferenceUrls: [],
   agent: null,
+  stateReason: null,
   ...overrides,
 });
 

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

@@ -238,6 +238,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     author: 'HiromiShikata',
     closingIssueReferenceUrls: [],
     agent: null,
+    stateReason: null,
     ...overrides,
   });
 

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

@@ -35,6 +35,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   author: '',
   closingIssueReferenceUrls: [],
   agent: null,
+  stateReason: null,
   ...overrides,
 });
 
@@ -67,6 +68,7 @@ const createMergedPr = (
   author: '',
   closingIssueReferenceUrls: [closingIssueUrl],
   agent: null,
+  stateReason: null,
   ...overrides,
 });
 
@@ -384,4 +386,36 @@ describe('QualityCheckAdvanceUseCase', () => {
       'done-id',
     );
   });
+
+  it('does not advance an issue with stateReason REOPENED even when it has a merged PR', async () => {
+    const issue = createMockIssue({ stateReason: 'REOPENED' });
+    const mergedPr = createMergedPr(issue.url);
+    const project = createMockProject();
+
+    await useCase.run({
+      project,
+      issues: [issue, mergedPr],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('advances an issue whose stateReason is COMPLETED even though it was previously REOPENED', async () => {
+    const issue = createMockIssue({ stateReason: 'COMPLETED' });
+    const mergedPr = createMergedPr(issue.url);
+    const project = createMockProject();
+
+    await useCase.run({
+      project,
+      issues: [issue, mergedPr],
+      evaluatedAt: FIXED_NOW,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      issue,
+      'done-id',
+    );
+  });
 });

package/src/domain/usecases/QualityCheckAdvanceUseCase.ts

@@ -45,6 +45,7 @@ export class QualityCheckAdvanceUseCase {
       (issue) =>
         issue.status === qualityCheckStatusName &&
         !issue.isClosed &&
+        issue.stateReason !== 'REOPENED' &&
         issue.dependedIssueUrls.length === 0 &&
         !issueReactivationTriggerIsPending(issue, evaluatedAt) &&
         issueUrlsWithMergedPr.has(issue.url),

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

@@ -0,0 +1,188 @@
+import { ReopenedDoneIssueRevertUseCase } from './ReopenedDoneIssueRevertUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+import {
+  AWAITING_WORKSPACE_STATUS_NAME,
+  DONE_STATUS_NAME,
+} from '../entities/WorkflowStatus';
+
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+
+const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
+  nameWithOwner: 'user/repo',
+  number: 1,
+  title: 'Test Issue',
+  state: 'OPEN',
+  status: DONE_STATUS_NAME,
+  story: 'Default Story',
+  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(),
+  author: '',
+  closingIssueReferenceUrls: [],
+  agent: null,
+  stateReason: 'REOPENED',
+  ...overrides,
+});
+
+const createMockProject = (): Project => ({
+  id: 'project-1',
+  url: 'https://github.com/orgs/user/projects/1',
+  databaseId: 1,
+  name: 'Test Project',
+  status: {
+    name: 'Status',
+    fieldId: 'status-field-id',
+    statuses: [
+      {
+        id: 'awaiting-workspace-id',
+        name: AWAITING_WORKSPACE_STATUS_NAME,
+        color: 'BLUE',
+        description: '',
+      },
+      {
+        id: 'preparation-id',
+        name: 'Preparation',
+        color: 'YELLOW',
+        description: '',
+      },
+      {
+        id: 'done-id',
+        name: DONE_STATUS_NAME,
+        color: 'PURPLE',
+        description: '',
+      },
+    ],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: null,
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+  agent: null,
+});
+
+describe('ReopenedDoneIssueRevertUseCase', () => {
+  let useCase: ReopenedDoneIssueRevertUseCase;
+  let mockIssueRepository: Mocked<Pick<IssueRepository, 'updateStatus'>>;
+
+  beforeEach(() => {
+    mockIssueRepository = {
+      updateStatus: jest.fn(),
+    };
+    useCase = new ReopenedDoneIssueRevertUseCase(mockIssueRepository);
+  });
+
+  it('resets a Done issue with stateReason REOPENED to Awaiting Workspace', async () => {
+    const issue = createMockIssue();
+    const project = createMockProject();
+
+    await useCase.run({ project, issues: [issue] });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      issue,
+      'awaiting-workspace-id',
+    );
+  });
+
+  it('does not reset a Done issue with stateReason COMPLETED', async () => {
+    const issue = createMockIssue({ stateReason: 'COMPLETED' });
+    const project = createMockProject();
+
+    await useCase.run({ project, issues: [issue] });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('does not reset a Done issue with stateReason null', async () => {
+    const issue = createMockIssue({ stateReason: null });
+    const project = createMockProject();
+
+    await useCase.run({ project, issues: [issue] });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('does not reset a PR item even when Done and stateReason is REOPENED', async () => {
+    const prIssue = createMockIssue({
+      isPr: true,
+      url: 'https://github.com/user/repo/pull/10',
+    });
+    const project = createMockProject();
+
+    await useCase.run({ project, issues: [prIssue] });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('does not reset an issue that is not in Done status', async () => {
+    const issue = createMockIssue({ status: 'Awaiting Workspace' });
+    const project = createMockProject();
+
+    await useCase.run({ project, issues: [issue] });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+  });
+
+  it('logs an error and returns 0 when Awaiting Workspace status option is missing', async () => {
+    const issue = createMockIssue();
+    const project = createMockProject();
+    project.status.statuses = project.status.statuses.filter(
+      (s) => s.name !== AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    const consoleSpy = jest
+      .spyOn(console, 'error')
+      .mockImplementation(() => {});
+
+    const result = await useCase.run({ project, issues: [issue] });
+
+    expect(result).toBe(0);
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    consoleSpy.mockRestore();
+  });
+
+  it('collects updateStatus failures and re-throws as AggregateError after processing all items', async () => {
+    const issue1 = createMockIssue({
+      number: 1,
+      url: 'https://github.com/user/repo/issues/1',
+      itemId: 'item-1',
+    });
+    const issue2 = createMockIssue({
+      number: 2,
+      url: 'https://github.com/user/repo/issues/2',
+      itemId: 'item-2',
+    });
+    const project = createMockProject();
+    const updateError = new Error('updateStatus failed for issue1');
+    mockIssueRepository.updateStatus
+      .mockRejectedValueOnce(updateError)
+      .mockResolvedValueOnce(undefined);
+
+    await expect(
+      useCase.run({ project, issues: [issue1, issue2] }),
+    ).rejects.toBeInstanceOf(AggregateError);
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledTimes(2);
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      issue2,
+      'awaiting-workspace-id',
+    );
+  });
+});

package/src/domain/usecases/ReopenedDoneIssueRevertUseCase.ts

@@ -0,0 +1,57 @@
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import {
+  AWAITING_WORKSPACE_STATUS_NAME,
+  DONE_STATUS_NAME,
+} from '../entities/WorkflowStatus';
+
+export class ReopenedDoneIssueRevertUseCase {
+  constructor(
+    private readonly issueRepository: Pick<IssueRepository, 'updateStatus'>,
+  ) {}
+
+  run = async (params: {
+    project: Project;
+    issues: Issue[];
+  }): Promise<number> => {
+    const awaitingWorkspaceStatusOption = params.project.status.statuses.find(
+      (s) => s.name === AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    if (!awaitingWorkspaceStatusOption) {
+      console.error(
+        `Awaiting Workspace status option '${AWAITING_WORKSPACE_STATUS_NAME}' not found in project.`,
+      );
+      return 0;
+    }
+
+    const itemsToRevert = params.issues.filter(
+      (issue) =>
+        issue.status === DONE_STATUS_NAME &&
+        issue.stateReason === 'REOPENED' &&
+        !issue.isPr,
+    );
+
+    let revertedCount = 0;
+    const errors: unknown[] = [];
+    for (const issue of itemsToRevert) {
+      try {
+        await this.issueRepository.updateStatus(
+          params.project,
+          issue,
+          awaitingWorkspaceStatusOption.id,
+        );
+        revertedCount++;
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) {
+      throw new AggregateError(
+        errors,
+        `Failed to revert ${errors.length} issue(s) from ${DONE_STATUS_NAME} to ${AWAITING_WORKSPACE_STATUS_NAME}`,
+      );
+    }
+    return revertedCount;
+  };
+}