github-issue-tower-defence-management 1.52.1 → 1.54.0

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

@@ -0,0 +1,376 @@
+import { RevertNotReadyAwaitingQualityCheckUseCase } from './RevertNotReadyAwaitingQualityCheckUseCase';
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+
+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: 'awaiting-workspace-id',
+        name: 'Awaiting Workspace',
+        color: 'GRAY',
+        description: '',
+      },
+      {
+        id: 'awaiting-quality-check-id',
+        name: 'Awaiting Quality Check',
+        color: 'BLUE',
+        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: 'Awaiting Quality Check',
+  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(),
+  author: '',
+  ...overrides,
+});
+
+const createReadyPr = (url = 'https://github.com/user/repo/pull/1') => ({
+  url,
+  isConflicted: false,
+  isPassedAllCiJob: true,
+  isCiStateSuccess: true,
+  isResolvedAllReviewComments: true,
+  isBranchOutOfDate: false,
+  missingRequiredCheckNames: [],
+});
+
+describe('RevertNotReadyAwaitingQualityCheckUseCase', () => {
+  let mockProjectRepository: {
+    findProjectIdByUrl: jest.Mock;
+    getProject: jest.Mock;
+  };
+  let mockIssueRepository: {
+    getAllIssues: jest.Mock;
+    updateStatus: jest.Mock;
+    findRelatedOpenPRs: jest.Mock;
+    getOpenPullRequest: jest.Mock;
+  };
+  let mockIssueCommentRepository: {
+    createComment: jest.Mock;
+  };
+  let mockProject: Project;
+  let useCase: RevertNotReadyAwaitingQualityCheckUseCase;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+
+    mockProject = createMockProject();
+
+    mockProjectRepository = {
+      findProjectIdByUrl: jest.fn().mockResolvedValue('project-1'),
+      getProject: jest.fn().mockResolvedValue(mockProject),
+    };
+
+    mockIssueRepository = {
+      getAllIssues: jest
+        .fn()
+        .mockResolvedValue({ issues: [], cacheUsed: false }),
+      updateStatus: jest.fn().mockResolvedValue(undefined),
+      findRelatedOpenPRs: jest.fn().mockResolvedValue([]),
+      getOpenPullRequest: jest.fn().mockResolvedValue(null),
+    };
+
+    mockIssueCommentRepository = {
+      createComment: jest.fn().mockResolvedValue(undefined),
+    };
+
+    useCase = new RevertNotReadyAwaitingQualityCheckUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+      mockIssueCommentRepository,
+    );
+  });
+
+  it('should do nothing when there are no Awaiting Quality Check issues', async () => {
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [
+        createMockIssue({ status: 'Awaiting Workspace' }),
+        createMockIssue({ status: 'Preparation' }),
+      ],
+      cacheUsed: false,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      allowIssueCacheMinutes: 10,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+  });
+
+  it('should skip Awaiting Quality Check issue with llm-agent label', async () => {
+    const issue = createMockIssue({
+      status: 'Awaiting Quality Check',
+      labels: ['llm-agent'],
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [issue],
+      cacheUsed: false,
+    });
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      allowIssueCacheMinutes: 10,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+  });
+
+  it('should revert issue when no linked PR is found', async () => {
+    const issue = createMockIssue({
+      status: 'Awaiting Quality Check',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [issue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      allowIssueCacheMinutes: 10,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      issue,
+      'awaiting-workspace-id',
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('Auto Status Check: REJECTED'),
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('PULL_REQUEST_NOT_FOUND'),
+    );
+  });
+
+  it('should not revert issue when PR is ready', async () => {
+    const issue = createMockIssue({
+      status: 'Awaiting Quality Check',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [issue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([createReadyPr()]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      allowIssueCacheMinutes: 10,
+    });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    expect(mockIssueCommentRepository.createComment).not.toHaveBeenCalled();
+  });
+
+  it('should revert issue when PR is conflicted', async () => {
+    const issue = createMockIssue({
+      status: 'Awaiting Quality Check',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [issue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      { ...createReadyPr(), isConflicted: true },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      allowIssueCacheMinutes: 10,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      issue,
+      'awaiting-workspace-id',
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('Auto Status Check: REJECTED'),
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('PULL_REQUEST_CONFLICTED'),
+    );
+  });
+
+  it('should revert issue when CI is failing', async () => {
+    const issue = createMockIssue({
+      status: 'Awaiting Quality Check',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [issue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        ...createReadyPr(),
+        isPassedAllCiJob: false,
+        isCiStateSuccess: false,
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      allowIssueCacheMinutes: 10,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      issue,
+      'awaiting-workspace-id',
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('Auto Status Check: REJECTED'),
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('ANY_CI_JOB_FAILED_OR_IN_PROGRESS'),
+    );
+  });
+
+  it('should revert issue when review comments are not resolved', async () => {
+    const issue = createMockIssue({
+      status: 'Awaiting Quality Check',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [issue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      { ...createReadyPr(), isResolvedAllReviewComments: false },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      allowIssueCacheMinutes: 10,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      issue,
+      'awaiting-workspace-id',
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('Auto Status Check: REJECTED'),
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('ANY_REVIEW_COMMENT_NOT_RESOLVED'),
+    );
+  });
+
+  it('should revert issue when multiple linked open PRs are found', async () => {
+    const issue = createMockIssue({
+      status: 'Awaiting Quality Check',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [issue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      createReadyPr('https://github.com/user/repo/pull/1'),
+      createReadyPr('https://github.com/user/repo/pull/2'),
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      allowIssueCacheMinutes: 10,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      issue,
+      'awaiting-workspace-id',
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('Auto Status Check: REJECTED'),
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('MULTIPLE_PULL_REQUESTS_FOUND'),
+    );
+  });
+
+  it('should revert issue when CI is SUCCESS but required check never started', async () => {
+    const issue = createMockIssue({
+      status: 'Awaiting Quality Check',
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [issue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        ...createReadyPr(),
+        isPassedAllCiJob: false,
+        isCiStateSuccess: true,
+        missingRequiredCheckNames: ['E2E Tests'],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      allowIssueCacheMinutes: 10,
+    });
+
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      mockProject,
+      issue,
+      'awaiting-workspace-id',
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('Auto Status Check: REJECTED'),
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      issue,
+      expect.stringContaining('REQUIRED_CI_JOB_NEVER_STARTED'),
+    );
+  });
+});

package/src/domain/usecases/RevertNotReadyAwaitingQualityCheckUseCase.ts

@@ -0,0 +1,88 @@
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { IssueCommentRepository } from './adapter-interfaces/IssueCommentRepository';
+import { IssueRejectionEvaluator } from './IssueRejectionEvaluator';
+import {
+  AWAITING_QUALITY_CHECK_STATUS_NAME,
+  AWAITING_WORKSPACE_STATUS_NAME,
+} from '../entities/WorkflowStatus';
+
+export class RevertNotReadyAwaitingQualityCheckUseCase {
+  private readonly issueRejectionEvaluator: IssueRejectionEvaluator;
+
+  constructor(
+    private readonly projectRepository: Pick<
+      ProjectRepository,
+      'findProjectIdByUrl' | 'getProject'
+    >,
+    private readonly issueRepository: Pick<
+      IssueRepository,
+      | 'getAllIssues'
+      | 'updateStatus'
+      | 'findRelatedOpenPRs'
+      | 'getOpenPullRequest'
+    >,
+    private readonly issueCommentRepository: Pick<
+      IssueCommentRepository,
+      'createComment'
+    >,
+  ) {
+    this.issueRejectionEvaluator = new IssueRejectionEvaluator(issueRepository);
+  }
+
+  run = async (params: {
+    projectUrl: string;
+    allowIssueCacheMinutes: number;
+  }): Promise<void> => {
+    const projectId = await this.projectRepository.findProjectIdByUrl(
+      params.projectUrl,
+    );
+    if (!projectId) {
+      throw new Error(`Project not found. projectUrl: ${params.projectUrl}`);
+    }
+    const project = await this.projectRepository.getProject(projectId);
+    if (!project) {
+      throw new Error(
+        `Project not found. projectId: ${projectId} projectUrl: ${params.projectUrl}`,
+      );
+    }
+
+    const awaitingWorkspaceStatusOption = project.status.statuses.find(
+      (s) => s.name === AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    if (!awaitingWorkspaceStatusOption) {
+      return;
+    }
+
+    const { issues } = await this.issueRepository.getAllIssues(
+      projectId,
+      params.allowIssueCacheMinutes,
+    );
+
+    const awaitingQualityCheckIssues = issues.filter(
+      (issue) => issue.status === AWAITING_QUALITY_CHECK_STATUS_NAME,
+    );
+
+    for (const issue of awaitingQualityCheckIssues) {
+      const hasLlmAgentLabel = issue.labels.some(
+        (l) => l === 'llm-agent' || l.startsWith('llm-agent:'),
+      );
+      if (hasLlmAgentLabel) {
+        continue;
+      }
+
+      const { rejections } = await this.issueRejectionEvaluator.evaluate(issue);
+      if (rejections.length > 0) {
+        await this.issueRepository.updateStatus(
+          project,
+          issue,
+          awaitingWorkspaceStatusOption.id,
+        );
+        await this.issueCommentRepository.createComment(
+          issue,
+          `Auto Status Check: REJECTED\n${rejections.map((r) => `- ${r.detail}`).join('\n')}`,
+        );
+      }
+    }
+  };
+}

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

@@ -11,6 +11,8 @@ import {
   FAILED_PREPARATION_STATUS_NAME,
   ICEBOX_STATUS_NAME,
   IN_TMUX_STATUS_NAME,
+  LEGACY_IN_TMUX_STATUS_NAME,
+  LEGACY_TODO_STATUS_NAME,
   PC_TODO_STATUS_NAME,
   PREPARATION_STATUS_NAME,
   REQUIRED_WORKFLOW_STATUSES,
@@ -44,7 +46,7 @@ const buildCanonicalStatuses = (): FieldOption[] =>
   }));
 
 describe('SetupTowerDefenceProjectUseCase', () => {
-  it('should define exactly the 11 required statuses in the documented order with the documented colors and no descriptions', () => {
+  it('should define exactly the 10 required statuses in the documented order with the documented colors and no descriptions', () => {
     expect(REQUIRED_WORKFLOW_STATUSES).toEqual([
       { name: DEFAULT_STATUS_NAME, color: 'ORANGE' },
       { name: AWAITING_TASK_BREAKDOWN_STATUS_NAME, color: 'ORANGE' },
@@ -53,7 +55,6 @@ describe('SetupTowerDefenceProjectUseCase', () => {
       { name: FAILED_PREPARATION_STATUS_NAME, color: 'RED' },
       { name: AWAITING_QUALITY_CHECK_STATUS_NAME, color: 'GREEN' },
       { name: TODO_STATUS_NAME, color: 'PINK' },
-      { name: PC_TODO_STATUS_NAME, color: 'PINK' },
       { name: IN_TMUX_STATUS_NAME, color: 'RED' },
       { name: DONE_STATUS_NAME, color: 'PURPLE' },
       { name: ICEBOX_STATUS_NAME, color: 'GRAY' },
@@ -187,12 +188,6 @@ describe('SetupTowerDefenceProjectUseCase', () => {
           color: 'PINK',
           description: '',
         },
-        {
-          id: null,
-          name: PC_TODO_STATUS_NAME,
-          color: 'PINK',
-          description: '',
-        },
         {
           id: null,
           name: IN_TMUX_STATUS_NAME,
@@ -249,7 +244,6 @@ describe('SetupTowerDefenceProjectUseCase', () => {
       FAILED_PREPARATION_STATUS_NAME,
       AWAITING_QUALITY_CHECK_STATUS_NAME,
       TODO_STATUS_NAME,
-      PC_TODO_STATUS_NAME,
       IN_TMUX_STATUS_NAME,
       DONE_STATUS_NAME,
       ICEBOX_STATUS_NAME,
@@ -272,4 +266,178 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     const [, payload] = mockProjectRepository.updateStatusList.mock.calls[0];
     expect(payload[2].color).toBe(REQUIRED_WORKFLOW_STATUSES[2].color);
   });
+
+  it('should rename legacy "Todo" to "Todo by human" by reusing the existing option ID', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const statuses: FieldOption[] = REQUIRED_WORKFLOW_STATUSES.map(
+      (required, index) => ({
+        id: `id-${index}`,
+        name:
+          required.name === TODO_STATUS_NAME
+            ? LEGACY_TODO_STATUS_NAME
+            : required.name,
+        color: required.color,
+        description: '',
+      }),
+    );
+    const project = buildProject(statuses);
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    mockProjectRepository.updateStatusList.mockResolvedValue([]);
+
+    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
+    const [, payload] = mockProjectRepository.updateStatusList.mock.calls[0];
+    const todoEntry = payload.find((s) => s.name === TODO_STATUS_NAME);
+    expect(todoEntry).toBeDefined();
+    expect(todoEntry?.id).toBe('id-6');
+    expect(payload.some((s) => s.name === LEGACY_TODO_STATUS_NAME)).toBe(false);
+  });
+
+  it('should rename legacy "In Tmux" to "In Tmux by human" by reusing the existing option ID', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const statuses: FieldOption[] = REQUIRED_WORKFLOW_STATUSES.map(
+      (required, index) => ({
+        id: `id-${index}`,
+        name:
+          required.name === IN_TMUX_STATUS_NAME
+            ? LEGACY_IN_TMUX_STATUS_NAME
+            : required.name,
+        color: required.color,
+        description: '',
+      }),
+    );
+    const project = buildProject(statuses);
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    mockProjectRepository.updateStatusList.mockResolvedValue([]);
+
+    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
+    const [, payload] = mockProjectRepository.updateStatusList.mock.calls[0];
+    const inTmuxEntry = payload.find((s) => s.name === IN_TMUX_STATUS_NAME);
+    expect(inTmuxEntry).toBeDefined();
+    expect(inTmuxEntry?.id).toBe('id-7');
+    expect(payload.some((s) => s.name === LEGACY_IN_TMUX_STATUS_NAME)).toBe(
+      false,
+    );
+  });
+
+  it('should remove "PC Todo" from the status list and not include it in others', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const statuses: FieldOption[] = [
+      ...buildCanonicalStatuses(),
+      {
+        id: 'pc-todo-id',
+        name: PC_TODO_STATUS_NAME,
+        color: 'PINK',
+        description: '',
+      },
+    ];
+    const project = buildProject(statuses);
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    mockProjectRepository.updateStatusList.mockResolvedValue([]);
+
+    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
+    const [, payload] = mockProjectRepository.updateStatusList.mock.calls[0];
+    expect(payload.some((s) => s.name === PC_TODO_STATUS_NAME)).toBe(false);
+  });
+
+  it('should migrate a project with legacy statuses: rename Todo and In Tmux by ID, remove PC Todo', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const statuses: FieldOption[] = [
+      {
+        id: 'id-0',
+        name: DEFAULT_STATUS_NAME,
+        color: 'ORANGE',
+        description: '',
+      },
+      {
+        id: 'id-1',
+        name: AWAITING_TASK_BREAKDOWN_STATUS_NAME,
+        color: 'ORANGE',
+        description: '',
+      },
+      {
+        id: 'id-2',
+        name: AWAITING_WORKSPACE_STATUS_NAME,
+        color: 'BLUE',
+        description: '',
+      },
+      {
+        id: 'id-3',
+        name: PREPARATION_STATUS_NAME,
+        color: 'YELLOW',
+        description: '',
+      },
+      {
+        id: 'id-4',
+        name: FAILED_PREPARATION_STATUS_NAME,
+        color: 'RED',
+        description: '',
+      },
+      {
+        id: 'id-5',
+        name: AWAITING_QUALITY_CHECK_STATUS_NAME,
+        color: 'GREEN',
+        description: '',
+      },
+      {
+        id: 'id-6',
+        name: LEGACY_TODO_STATUS_NAME,
+        color: 'PINK',
+        description: '',
+      },
+      { id: 'id-7', name: PC_TODO_STATUS_NAME, color: 'PINK', description: '' },
+      {
+        id: 'id-8',
+        name: LEGACY_IN_TMUX_STATUS_NAME,
+        color: 'RED',
+        description: '',
+      },
+      { id: 'id-9', name: DONE_STATUS_NAME, color: 'PURPLE', description: '' },
+      { id: 'id-10', name: ICEBOX_STATUS_NAME, color: 'GRAY', description: '' },
+    ];
+    const project = buildProject(statuses);
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    mockProjectRepository.updateStatusList.mockResolvedValue([]);
+
+    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
+    const [, payload] = mockProjectRepository.updateStatusList.mock.calls[0];
+
+    expect(payload.map((s) => s.name)).toEqual([
+      DEFAULT_STATUS_NAME,
+      AWAITING_TASK_BREAKDOWN_STATUS_NAME,
+      AWAITING_WORKSPACE_STATUS_NAME,
+      PREPARATION_STATUS_NAME,
+      FAILED_PREPARATION_STATUS_NAME,
+      AWAITING_QUALITY_CHECK_STATUS_NAME,
+      TODO_STATUS_NAME,
+      IN_TMUX_STATUS_NAME,
+      DONE_STATUS_NAME,
+      ICEBOX_STATUS_NAME,
+    ]);
+
+    expect(payload.find((s) => s.name === TODO_STATUS_NAME)?.id).toBe('id-6');
+    expect(payload.find((s) => s.name === IN_TMUX_STATUS_NAME)?.id).toBe(
+      'id-8',
+    );
+    expect(payload.some((s) => s.name === PC_TODO_STATUS_NAME)).toBe(false);
+    expect(payload.some((s) => s.name === LEGACY_TODO_STATUS_NAME)).toBe(false);
+    expect(payload.some((s) => s.name === LEGACY_IN_TMUX_STATUS_NAME)).toBe(
+      false,
+    );
+  });
 });