github-issue-tower-defence-management 1.65.0 → 1.67.0

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

@@ -1,16 +1,18 @@
 import { mock } from 'jest-mock-extended';
 import { SetupTowerDefenceProjectUseCase } from './SetupTowerDefenceProjectUseCase';
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
 import { FieldOption, Project } from '../entities/Project';
+import { Issue } from '../entities/Issue';
 import {
   AWAITING_QUALITY_CHECK_STATUS_NAME,
-  AWAITING_TASK_BREAKDOWN_STATUS_NAME,
   AWAITING_WORKSPACE_STATUS_NAME,
   DEFAULT_STATUS_NAME,
   DONE_STATUS_NAME,
   FAILED_PREPARATION_STATUS_NAME,
   ICEBOX_STATUS_NAME,
   IN_TMUX_STATUS_NAME,
+  LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
   LEGACY_IN_TMUX_STATUS_NAME,
   LEGACY_TODO_STATUS_NAME,
   PC_TODO_STATUS_NAME,
@@ -45,11 +47,37 @@ const buildCanonicalStatuses = (): FieldOption[] =>
     description: '',
   }));
 
+const buildIssue = (overrides: Partial<Issue>): Issue => ({
+  nameWithOwner: 'test-org/test-repo',
+  number: 1,
+  title: 'Test issue',
+  state: 'OPEN',
+  status: null,
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/test-org/test-repo/issues/1',
+  assignees: [],
+  labels: [],
+  org: 'test-org',
+  repo: 'test-repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2024-01-01'),
+  author: 'user',
+  ...overrides,
+});
+
 describe('SetupTowerDefenceProjectUseCase', () => {
-  it('should define exactly the 10 required statuses in the documented order with the documented colors and no descriptions', () => {
+  it('should define exactly the 9 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' },
       { name: AWAITING_WORKSPACE_STATUS_NAME, color: 'BLUE' },
       { name: PREPARATION_STATUS_NAME, color: 'YELLOW' },
       { name: FAILED_PREPARATION_STATUS_NAME, color: 'RED' },
@@ -67,10 +95,19 @@ describe('SetupTowerDefenceProjectUseCase', () => {
   it('should skip update when project already has required statuses in canonical order with no descriptions', async () => {
     const mockProjectRepository =
       mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
     const project = buildProject(buildCanonicalStatuses());
     mockProjectRepository.getByUrl.mockResolvedValue(project);
-
-    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
     await useCase.run({ projectUrl: project.url });
 
     expect(mockProjectRepository.updateStatusList).not.toHaveBeenCalled();
@@ -79,6 +116,8 @@ describe('SetupTowerDefenceProjectUseCase', () => {
   it('should skip update when project already has required statuses plus extras after them', async () => {
     const mockProjectRepository =
       mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
     const statuses = [
       ...buildCanonicalStatuses(),
       {
@@ -90,8 +129,15 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     ];
     const project = buildProject(statuses);
     mockProjectRepository.getByUrl.mockResolvedValue(project);
-
-    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
     await useCase.run({ projectUrl: project.url });
 
     expect(mockProjectRepository.updateStatusList).not.toHaveBeenCalled();
@@ -100,13 +146,22 @@ describe('SetupTowerDefenceProjectUseCase', () => {
   it('should rewrite required statuses with empty descriptions when an existing status carries a description', async () => {
     const mockProjectRepository =
       mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
     const statuses = buildCanonicalStatuses();
     statuses[0] = { ...statuses[0], description: 'stale description' };
     const project = buildProject(statuses);
     mockProjectRepository.getByUrl.mockResolvedValue(project);
     mockProjectRepository.updateStatusList.mockResolvedValue([]);
-
-    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
     await useCase.run({ projectUrl: project.url });
 
     expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
@@ -121,6 +176,8 @@ describe('SetupTowerDefenceProjectUseCase', () => {
   it('should add missing required statuses while preserving existing custom statuses', async () => {
     const mockProjectRepository =
       mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
     const statuses: FieldOption[] = [
       {
         id: 'unread-id',
@@ -138,8 +195,15 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     const project = buildProject(statuses);
     mockProjectRepository.getByUrl.mockResolvedValue(project);
     mockProjectRepository.updateStatusList.mockResolvedValue([]);
-
-    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
     await useCase.run({ projectUrl: project.url });
 
     expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
@@ -152,12 +216,6 @@ describe('SetupTowerDefenceProjectUseCase', () => {
           color: 'ORANGE',
           description: '',
         },
-        {
-          id: null,
-          name: AWAITING_TASK_BREAKDOWN_STATUS_NAME,
-          color: 'ORANGE',
-          description: '',
-        },
         {
           id: null,
           name: AWAITING_WORKSPACE_STATUS_NAME,
@@ -219,6 +277,8 @@ describe('SetupTowerDefenceProjectUseCase', () => {
   it('should reorder existing required statuses into canonical order when out of order', async () => {
     const mockProjectRepository =
       mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
     const reversedStatuses: FieldOption[] = REQUIRED_WORKFLOW_STATUSES.slice()
       .reverse()
       .map((required, index) => ({
@@ -230,15 +290,21 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     const project = buildProject(reversedStatuses);
     mockProjectRepository.getByUrl.mockResolvedValue(project);
     mockProjectRepository.updateStatusList.mockResolvedValue([]);
-
-    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
     await useCase.run({ projectUrl: project.url });
 
     expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
     const [, payload] = mockProjectRepository.updateStatusList.mock.calls[0];
     expect(payload.map((status) => status.name)).toEqual([
       DEFAULT_STATUS_NAME,
-      AWAITING_TASK_BREAKDOWN_STATUS_NAME,
       AWAITING_WORKSPACE_STATUS_NAME,
       PREPARATION_STATUS_NAME,
       FAILED_PREPARATION_STATUS_NAME,
@@ -253,23 +319,34 @@ describe('SetupTowerDefenceProjectUseCase', () => {
   it('should fix color when an existing required status has wrong color', async () => {
     const mockProjectRepository =
       mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
     const statuses = buildCanonicalStatuses();
-    statuses[2] = { ...statuses[2], color: 'RED' };
+    statuses[1] = { ...statuses[1], color: 'RED' };
     const project = buildProject(statuses);
     mockProjectRepository.getByUrl.mockResolvedValue(project);
     mockProjectRepository.updateStatusList.mockResolvedValue([]);
-
-    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
     await useCase.run({ projectUrl: project.url });
 
     expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
     const [, payload] = mockProjectRepository.updateStatusList.mock.calls[0];
-    expect(payload[2].color).toBe(REQUIRED_WORKFLOW_STATUSES[2].color);
+    expect(payload[1].color).toBe(REQUIRED_WORKFLOW_STATUSES[1].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 mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
     const statuses: FieldOption[] = REQUIRED_WORKFLOW_STATUSES.map(
       (required, index) => ({
         id: `id-${index}`,
@@ -284,21 +361,30 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     const project = buildProject(statuses);
     mockProjectRepository.getByUrl.mockResolvedValue(project);
     mockProjectRepository.updateStatusList.mockResolvedValue([]);
-
-    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
     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(todoEntry?.id).toBe('id-5');
     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 mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
     const statuses: FieldOption[] = REQUIRED_WORKFLOW_STATUSES.map(
       (required, index) => ({
         id: `id-${index}`,
@@ -313,15 +399,22 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     const project = buildProject(statuses);
     mockProjectRepository.getByUrl.mockResolvedValue(project);
     mockProjectRepository.updateStatusList.mockResolvedValue([]);
-
-    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
     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(inTmuxEntry?.id).toBe('id-6');
     expect(payload.some((s) => s.name === LEGACY_IN_TMUX_STATUS_NAME)).toBe(
       false,
     );
@@ -330,6 +423,8 @@ describe('SetupTowerDefenceProjectUseCase', () => {
   it('should remove "PC Todo" from the status list and not include it in others', async () => {
     const mockProjectRepository =
       mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
     const statuses: FieldOption[] = [
       ...buildCanonicalStatuses(),
       {
@@ -342,8 +437,15 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     const project = buildProject(statuses);
     mockProjectRepository.getByUrl.mockResolvedValue(project);
     mockProjectRepository.updateStatusList.mockResolvedValue([]);
-
-    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
     await useCase.run({ projectUrl: project.url });
 
     expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
@@ -354,6 +456,8 @@ describe('SetupTowerDefenceProjectUseCase', () => {
   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 mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
     const statuses: FieldOption[] = [
       {
         id: 'id-0',
@@ -363,7 +467,287 @@ describe('SetupTowerDefenceProjectUseCase', () => {
       },
       {
         id: 'id-1',
-        name: AWAITING_TASK_BREAKDOWN_STATUS_NAME,
+        name: AWAITING_WORKSPACE_STATUS_NAME,
+        color: 'BLUE',
+        description: '',
+      },
+      {
+        id: 'id-2',
+        name: PREPARATION_STATUS_NAME,
+        color: 'YELLOW',
+        description: '',
+      },
+      {
+        id: 'id-3',
+        name: FAILED_PREPARATION_STATUS_NAME,
+        color: 'RED',
+        description: '',
+      },
+      {
+        id: 'id-4',
+        name: AWAITING_QUALITY_CHECK_STATUS_NAME,
+        color: 'GREEN',
+        description: '',
+      },
+      {
+        id: 'id-5',
+        name: LEGACY_TODO_STATUS_NAME,
+        color: 'PINK',
+        description: '',
+      },
+      { id: 'id-6', name: PC_TODO_STATUS_NAME, color: 'PINK', description: '' },
+      {
+        id: 'id-7',
+        name: LEGACY_IN_TMUX_STATUS_NAME,
+        color: 'RED',
+        description: '',
+      },
+      { id: 'id-8', name: DONE_STATUS_NAME, color: 'PURPLE', description: '' },
+      { id: 'id-9', name: ICEBOX_STATUS_NAME, color: 'GRAY', description: '' },
+    ];
+    const project = buildProject(statuses);
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    mockProjectRepository.updateStatusList.mockResolvedValue([]);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
+    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_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-5');
+    expect(payload.find((s) => s.name === IN_TMUX_STATUS_NAME)?.id).toBe(
+      'id-7',
+    );
+    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,
+    );
+  });
+
+  it('should migrate issues from "Awaiting Task Breakdown" to "Todo by human" when that status exists', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
+    const todoStatusId = 'todo-status-id';
+    const statuses: FieldOption[] = [
+      {
+        id: 'id-0',
+        name: DEFAULT_STATUS_NAME,
+        color: 'ORANGE',
+        description: '',
+      },
+      {
+        id: 'atb-id',
+        name: LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
+        color: 'ORANGE',
+        description: '',
+      },
+      {
+        id: 'id-1',
+        name: AWAITING_WORKSPACE_STATUS_NAME,
+        color: 'BLUE',
+        description: '',
+      },
+      {
+        id: 'id-2',
+        name: PREPARATION_STATUS_NAME,
+        color: 'YELLOW',
+        description: '',
+      },
+      {
+        id: 'id-3',
+        name: FAILED_PREPARATION_STATUS_NAME,
+        color: 'RED',
+        description: '',
+      },
+      {
+        id: 'id-4',
+        name: AWAITING_QUALITY_CHECK_STATUS_NAME,
+        color: 'GREEN',
+        description: '',
+      },
+      {
+        id: todoStatusId,
+        name: TODO_STATUS_NAME,
+        color: 'PINK',
+        description: '',
+      },
+      {
+        id: 'id-6',
+        name: IN_TMUX_STATUS_NAME,
+        color: 'RED',
+        description: '',
+      },
+      { id: 'id-7', name: DONE_STATUS_NAME, color: 'PURPLE', description: '' },
+      { id: 'id-8', name: ICEBOX_STATUS_NAME, color: 'GRAY', description: '' },
+    ];
+    const project = buildProject(statuses);
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    mockProjectRepository.updateStatusList.mockResolvedValue([]);
+
+    const atbIssue1 = buildIssue({
+      number: 10,
+      url: 'https://github.com/test-org/test-repo/issues/10',
+      itemId: 'item-10',
+      status: LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
+    });
+    const atbIssue2 = buildIssue({
+      number: 11,
+      url: 'https://github.com/test-org/test-repo/issues/11',
+      itemId: 'item-11',
+      status: LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
+    });
+    const otherIssue = buildIssue({
+      number: 12,
+      url: 'https://github.com/test-org/test-repo/issues/12',
+      itemId: 'item-12',
+      status: AWAITING_WORKSPACE_STATUS_NAME,
+    });
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [atbIssue1, atbIssue2, otherIssue],
+      cacheUsed: false,
+    });
+    mockIssueRepository.updateStatus.mockResolvedValue(undefined);
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockIssueRepository.getAllIssues).toHaveBeenCalledWith(
+      project.id,
+      0,
+    );
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledTimes(2);
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      atbIssue1,
+      todoStatusId,
+    );
+    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
+      project,
+      atbIssue2,
+      todoStatusId,
+    );
+
+    expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
+    const [, payload] = mockProjectRepository.updateStatusList.mock.calls[0];
+    expect(
+      payload.some(
+        (s) => s.name === LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
+      ),
+    ).toBe(false);
+    expect(payload.map((s) => s.name)).toEqual([
+      DEFAULT_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,
+    ]);
+  });
+
+  it('should skip issue migration when "Awaiting Task Breakdown" status does not exist', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
+    const project = buildProject(buildCanonicalStatuses());
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
+    expect(mockProjectRepository.updateStatusList).not.toHaveBeenCalled();
+  });
+
+  it('should remove "Awaiting Task Breakdown" from the status list after migrating all affected issues', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
+    const statuses: FieldOption[] = [
+      ...buildCanonicalStatuses(),
+      {
+        id: 'atb-id',
+        name: LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
+        color: 'ORANGE',
+        description: '',
+      },
+    ];
+    const project = buildProject(statuses);
+    mockProjectRepository.getByUrl.mockResolvedValue(project);
+    mockProjectRepository.updateStatusList.mockResolvedValue([]);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+    mockIssueRepository.updateStatus.mockResolvedValue(undefined);
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
+    await useCase.run({ projectUrl: project.url });
+
+    expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
+    const [, payload] = mockProjectRepository.updateStatusList.mock.calls[0];
+    expect(
+      payload.some(
+        (s) => s.name === LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
+      ),
+    ).toBe(false);
+  });
+
+  it('should migrate a project with all legacy statuses including Awaiting Task Breakdown', async () => {
+    const mockProjectRepository =
+      mock<Pick<ProjectRepository, 'getByUrl' | 'updateStatusList'>>();
+    const mockIssueRepository =
+      mock<Pick<IssueRepository, 'getAllIssues' | 'updateStatus'>>();
+    const statuses: FieldOption[] = [
+      {
+        id: 'id-0',
+        name: DEFAULT_STATUS_NAME,
+        color: 'ORANGE',
+        description: '',
+      },
+      {
+        id: 'id-1',
+        name: LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
         color: 'ORANGE',
         description: '',
       },
@@ -410,8 +794,16 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     const project = buildProject(statuses);
     mockProjectRepository.getByUrl.mockResolvedValue(project);
     mockProjectRepository.updateStatusList.mockResolvedValue([]);
-
-    const useCase = new SetupTowerDefenceProjectUseCase(mockProjectRepository);
+    mockIssueRepository.getAllIssues.mockResolvedValue({
+      issues: [],
+      cacheUsed: false,
+    });
+    mockIssueRepository.updateStatus.mockResolvedValue(undefined);
+
+    const useCase = new SetupTowerDefenceProjectUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
     await useCase.run({ projectUrl: project.url });
 
     expect(mockProjectRepository.updateStatusList).toHaveBeenCalledTimes(1);
@@ -419,7 +811,6 @@ describe('SetupTowerDefenceProjectUseCase', () => {
 
     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,
@@ -439,5 +830,10 @@ describe('SetupTowerDefenceProjectUseCase', () => {
     expect(payload.some((s) => s.name === LEGACY_IN_TMUX_STATUS_NAME)).toBe(
       false,
     );
+    expect(
+      payload.some(
+        (s) => s.name === LEGACY_AWAITING_TASK_BREAKDOWN_STATUS_NAME,
+      ),
+    ).toBe(false);
   });
 });