github-issue-tower-defence-management 1.2.0 → 1.4.0

package/src/domain/usecases/ChangeStatusLongInReviewIssueUseCase.ts

@@ -0,0 +1,57 @@
+import { Issue } from '../entities/Issue';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Project } from '../entities/Project';
+import { DateRepository } from './adapter-interfaces/DateRepository';
+
+export class ChangeStatusLongInReviewIssueUseCase {
+  constructor(
+    readonly dateRepository: Pick<DateRepository, 'now'>,
+    readonly issueRepository: Pick<
+      IssueRepository,
+      'updateStatus' | 'createComment'
+    >,
+  ) {}
+
+  run = async (input: {
+    project: Project;
+    issues: Issue[];
+    cacheUsed: boolean;
+    org: string;
+    repo: string;
+  }): Promise<void> => {
+    const firstStatus = input.project.status.statuses[0];
+    if (!firstStatus) {
+      throw new Error('First status is not found');
+    }
+    for (const issue of input.issues) {
+      if (
+        issue.isPr ||
+        issue.isClosed ||
+        !issue.status?.toLowerCase().includes('review')
+      ) {
+        continue;
+      }
+      if (issue.workingTimeline.length > 0) {
+        const latestWorkingTime =
+          issue.workingTimeline[issue.workingTimeline.length - 1];
+        const now = await this.dateRepository.now();
+        const diff = now.getTime() - latestWorkingTime.endedAt.getTime();
+        const diffHours = diff / (1000 * 60 * 60);
+        if (diffHours < 48) {
+          continue;
+        }
+      }
+      await this.issueRepository.createComment(
+        issue,
+        `${issue.assignees.map((assignee) => `@${assignee}`).join(' ')}
+This issue has been in review for more than 48 hours.
+Please check the situation of PR again :pray:`,
+      );
+      await this.issueRepository.updateStatus(
+        input.project,
+        issue,
+        firstStatus.id,
+      );
+    }
+  };
+}

package/src/domain/usecases/ClearNextActionHourUseCase.ts

@@ -14,9 +14,10 @@ export class ClearNextActionHourUseCase {
     cacheUsed: boolean;
   }): Promise<void> => {
     const nextActionHour = input.project.nextActionHour;
-    if (!nextActionHour || input.cacheUsed) {
+    if (!nextActionHour) {
       return;
     }
+    const nextActionDate = input.project.nextActionDate;
     const targetDates = input.targetDates
       .filter((targetDate) => targetDate.getMinutes() === 45)
       .reverse();
@@ -26,7 +27,7 @@ export class ClearNextActionHourUseCase {
     const targetDate = new Date(
       targetDates[targetDates.length - 1].getTime() + 5 * 60 * 1000,
     );
-    const targetHour = targetDate.getHours();
+    const targetHour = targetDate.getHours() + 1;
     const isTargetIssue = (issue: Issue): boolean => {
       return (
         issue.nextActionHour !== null &&
@@ -46,6 +47,15 @@ export class ClearNextActionHourUseCase {
         issue,
       );
       await new Promise((resolve) => setTimeout(resolve, 5000));
+      if (!nextActionDate) {
+        continue;
+      }
+      await this.issueRepository.clearProjectField(
+        input.project,
+        nextActionDate.fieldId,
+        issue,
+      );
+      await new Promise((resolve) => setTimeout(resolve, 5000));
     }
   };
 }

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

@@ -0,0 +1,490 @@
+import { mock } from 'jest-mock-extended';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ConvertCheckboxToIssueInStoryIssueUseCase } from './ConvertCheckboxToIssueInStoryIssueUseCase';
+import { Project, StoryOption } from '../entities/Project';
+import { Issue } from '../entities/Issue';
+import { StoryObject, StoryObjectMap } from './HandleScheduledEventUseCase';
+
+describe('ConvertCheckboxToIssueInStoryIssueUseCase', () => {
+  jest.setTimeout(5 * 60 * 1000);
+  const mockIssueRepository = mock<IssueRepository>();
+
+  describe('run', () => {
+    const basicProject = {
+      ...mock<Project>(),
+      story: {
+        name: 'Story Field',
+        fieldId: 'storyFieldId',
+        stories: [
+          { ...mock<StoryOption>(), id: 'story1', name: 'Story 1' },
+          { ...mock<StoryOption>(), id: 'story2', name: 'Story 2' },
+          { ...mock<StoryOption>(), id: 'regular3', name: 'regular / Story 3' },
+        ],
+        workflowManagementStory: { id: 'workflow1', name: 'Workflow Story' },
+      },
+    };
+
+    const basicStoryIssue1 = {
+      ...mock<Issue>(),
+      title: 'Story 1',
+      number: 123,
+      body: `- [ ] Task 1
+- [ ] Task 2`,
+      url: 'https://github.com/org/repo/issues/123',
+    };
+
+    const basicStoryIssue2 = {
+      ...mock<Issue>(),
+      title: 'Story 2',
+      number: 456,
+      body: `- [ ] Task 3
+- [ ] Task 4`,
+      url: 'https://github.com/org/repo/issues/456',
+    };
+
+    const basicStoryObject1: StoryObject = {
+      story: { ...mock<StoryOption>(), id: 'story1', name: 'Story 1' },
+      storyIssue: basicStoryIssue1,
+      issues: [],
+    };
+    const basicStoryObject2: StoryObject = {
+      story: { ...mock<StoryOption>(), id: 'story2', name: 'Story 2' },
+      storyIssue: basicStoryIssue2,
+      issues: [],
+    };
+
+    const basicStoryObjectMap: StoryObjectMap = new Map([
+      ['Story 1', basicStoryObject1],
+      ['Story 2', basicStoryObject2],
+    ]);
+
+    const regularStoryProject = {
+      ...basicProject,
+      story: {
+        name: 'Story Field',
+        fieldId: 'storyFieldId',
+        stories: [
+          { ...mock<StoryOption>(), id: 'regular1', name: 'regular / Story 1' },
+        ],
+        workflowManagementStory: { id: 'workflow1', name: 'Workflow Story' },
+      },
+    };
+
+    const regularStoryObjectMap = new Map([
+      [
+        'regular / Story 1',
+        {
+          story: {
+            ...mock<StoryOption>(),
+            id: 'regular1',
+            name: 'regular / Story 1',
+          },
+          storyIssue: basicStoryIssue1,
+          issues: [],
+        },
+      ],
+    ]);
+
+    const testCases: {
+      name: string;
+      input: {
+        project: Project;
+        issues: Issue[];
+        cacheUsed: boolean;
+        org: string;
+        repo: string;
+        urlOfStoryView: string;
+        disabledStatus: string;
+        storyObjectMap: StoryObjectMap;
+      };
+      expectedThrowError?: Error;
+      expectedCreateNewIssueCalls: [
+        string,
+        string,
+        string,
+        string,
+        string[],
+        string[],
+      ][];
+      expectedUpdateIssueCalls: [Issue][];
+      expectedUpdateStoryCalls: [Project, Issue, string][];
+      expectedGetIssueByUrlCalls: [string][];
+    }[] = [
+      {
+        name: 'should not process when story is not set',
+        input: {
+          project: { ...basicProject, story: null },
+          issues: [basicStoryIssue1],
+          cacheUsed: false,
+          org: 'testOrg',
+          repo: 'testRepo',
+          urlOfStoryView: 'https://example.com',
+          disabledStatus: 'Closed',
+          storyObjectMap: basicStoryObjectMap,
+        },
+        expectedCreateNewIssueCalls: [],
+        expectedUpdateIssueCalls: [],
+        expectedUpdateStoryCalls: [],
+        expectedGetIssueByUrlCalls: [],
+      },
+      {
+        name: 'should not process when cache is used',
+        input: {
+          project: basicProject,
+          issues: [basicStoryIssue1],
+          cacheUsed: true,
+          org: 'testOrg',
+          repo: 'testRepo',
+          urlOfStoryView: 'https://example.com',
+          disabledStatus: 'Closed',
+          storyObjectMap: basicStoryObjectMap,
+        },
+        expectedCreateNewIssueCalls: [],
+        expectedUpdateIssueCalls: [],
+        expectedUpdateStoryCalls: [],
+        expectedGetIssueByUrlCalls: [],
+      },
+      {
+        name: 'should skip regular stories',
+        input: {
+          project: regularStoryProject,
+          issues: [basicStoryIssue1],
+          cacheUsed: false,
+          org: 'testOrg',
+          repo: 'testRepo',
+          urlOfStoryView: 'https://example.com',
+          disabledStatus: 'Closed',
+          storyObjectMap: regularStoryObjectMap,
+        },
+        expectedCreateNewIssueCalls: [],
+        expectedUpdateIssueCalls: [],
+        expectedUpdateStoryCalls: [],
+        expectedGetIssueByUrlCalls: [],
+      },
+      {
+        name: 'should throw error when story issue not found',
+        input: {
+          project: basicProject,
+          issues: [],
+          cacheUsed: false,
+          org: 'testOrg',
+          repo: 'testRepo',
+          urlOfStoryView: 'https://example.com',
+          disabledStatus: 'Closed',
+          storyObjectMap: basicStoryObjectMap,
+        },
+        expectedThrowError: new Error('Story issue not found: Story 1'),
+        expectedCreateNewIssueCalls: [],
+        expectedUpdateIssueCalls: [],
+        expectedUpdateStoryCalls: [],
+        expectedGetIssueByUrlCalls: [],
+      },
+
+      {
+        name: 'should skip closed story issues or disabled status',
+        input: {
+          project: basicProject,
+          issues: [
+            {
+              ...basicStoryIssue1,
+              state: 'CLOSED',
+              isClosed: true,
+            },
+            {
+              ...basicStoryIssue2,
+              status: 'Disabled',
+            },
+          ],
+          cacheUsed: false,
+          org: 'testOrg',
+          repo: 'testRepo',
+          urlOfStoryView: 'https://example.com',
+          disabledStatus: 'Disabled',
+          storyObjectMap: basicStoryObjectMap,
+        },
+        expectedCreateNewIssueCalls: [],
+        expectedUpdateIssueCalls: [],
+        expectedUpdateStoryCalls: [],
+        expectedGetIssueByUrlCalls: [],
+      },
+      {
+        name: 'should create new issues for checkboxes and update story issue',
+        input: {
+          project: basicProject,
+          issues: [basicStoryIssue1, basicStoryIssue2],
+          cacheUsed: false,
+          org: 'testOrg',
+          repo: 'testRepo',
+          urlOfStoryView: 'https://example.com',
+          disabledStatus: 'Closed',
+          storyObjectMap: basicStoryObjectMap,
+        },
+        expectedCreateNewIssueCalls: [
+          ['testOrg', 'testRepo', 'Task 1', '', [], []],
+          ['testOrg', 'testRepo', 'Task 2', '', [], []],
+          ['testOrg', 'testRepo', 'Task 3', '', [], []],
+          ['testOrg', 'testRepo', 'Task 4', '', [], []],
+        ],
+        expectedUpdateIssueCalls: [
+          [
+            {
+              ...basicStoryIssue1,
+              body: `- [ ] https://github.com/testOrg/testRepo/issues/1
+- [ ] Task 2`,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue1,
+              body: `- [ ] https://github.com/testOrg/testRepo/issues/1
+- [ ] https://github.com/testOrg/testRepo/issues/2`,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue2,
+              body: `- [ ] https://github.com/testOrg/testRepo/issues/3
+- [ ] Task 4`,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue2,
+              body: `- [ ] https://github.com/testOrg/testRepo/issues/3
+- [ ] https://github.com/testOrg/testRepo/issues/4`,
+            },
+          ],
+        ],
+        expectedUpdateStoryCalls: [
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/testOrg/testRepo/issues/1',
+            },
+            'story1',
+          ],
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/testOrg/testRepo/issues/2',
+            },
+            'story1',
+          ],
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/testOrg/testRepo/issues/3',
+            },
+            'story2',
+          ],
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/testOrg/testRepo/issues/4',
+            },
+            'story2',
+          ],
+        ],
+        expectedGetIssueByUrlCalls: [
+          ['https://github.com/testOrg/testRepo/issues/1'],
+          ['https://github.com/testOrg/testRepo/issues/2'],
+          ['https://github.com/testOrg/testRepo/issues/3'],
+          ['https://github.com/testOrg/testRepo/issues/4'],
+        ],
+      },
+      {
+        name: 'should create new issues with replaced STORYNAME for checkboxes and update story issue',
+        input: {
+          project: basicProject,
+          issues: [
+            {
+              ...basicStoryIssue1,
+              body: `- [ ] Task 1
+- [ ] Task 2 for \`STORYNAME\``,
+            },
+            basicStoryIssue2,
+          ],
+          cacheUsed: false,
+          org: 'testOrg',
+          repo: 'testRepo',
+          urlOfStoryView: 'https://example.com',
+          disabledStatus: 'Closed',
+          storyObjectMap: basicStoryObjectMap,
+        },
+        expectedCreateNewIssueCalls: [
+          ['testOrg', 'testRepo', 'Task 1', '', [], []],
+          ['testOrg', 'testRepo', 'Task 2 for `Story 1 #123`', '', [], []],
+          ['testOrg', 'testRepo', 'Task 3', '', [], []],
+          ['testOrg', 'testRepo', 'Task 4', '', [], []],
+        ],
+        expectedUpdateIssueCalls: [
+          [
+            {
+              ...basicStoryIssue1,
+              body: `- [ ] https://github.com/testOrg/testRepo/issues/1
+- [ ] Task 2 for \`STORYNAME\``,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue1,
+              body: `- [ ] https://github.com/testOrg/testRepo/issues/1
+- [ ] https://github.com/testOrg/testRepo/issues/2`,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue2,
+              body: `- [ ] https://github.com/testOrg/testRepo/issues/3
+- [ ] Task 4`,
+            },
+          ],
+          [
+            {
+              ...basicStoryIssue2,
+              body: `- [ ] https://github.com/testOrg/testRepo/issues/3
+- [ ] https://github.com/testOrg/testRepo/issues/4`,
+            },
+          ],
+        ],
+        expectedUpdateStoryCalls: [
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/testOrg/testRepo/issues/1',
+            },
+            'story1',
+          ],
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/testOrg/testRepo/issues/2',
+            },
+            'story1',
+          ],
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/testOrg/testRepo/issues/3',
+            },
+            'story2',
+          ],
+          [
+            basicProject,
+            {
+              ...mock<Issue>(),
+              url: 'https://github.com/testOrg/testRepo/issues/4',
+            },
+            'story2',
+          ],
+        ],
+        expectedGetIssueByUrlCalls: [
+          ['https://github.com/testOrg/testRepo/issues/1'],
+          ['https://github.com/testOrg/testRepo/issues/2'],
+          ['https://github.com/testOrg/testRepo/issues/3'],
+          ['https://github.com/testOrg/testRepo/issues/4'],
+        ],
+      },
+    ];
+
+    testCases.forEach(
+      ({
+        name,
+        input,
+        expectedThrowError,
+        expectedCreateNewIssueCalls,
+        expectedUpdateIssueCalls,
+        expectedUpdateStoryCalls,
+        expectedGetIssueByUrlCalls,
+      }) => {
+        it(name, async () => {
+          jest.clearAllMocks();
+
+          let issueCounter = 1;
+          mockIssueRepository.createNewIssue.mockImplementation(
+            async () => issueCounter++,
+          );
+          mockIssueRepository.getIssueByUrl.mockImplementation(async (url) => ({
+            ...mock<Issue>(),
+            url,
+          }));
+
+          const useCase = new ConvertCheckboxToIssueInStoryIssueUseCase(
+            mockIssueRepository,
+          );
+          try {
+            await useCase.run(input);
+          } catch (e) {
+            if (expectedThrowError === undefined) {
+              throw e;
+            }
+            if (e === null || typeof e !== 'object' || !('message' in e)) {
+              expect(e).toEqual(expectedThrowError);
+            }
+          }
+
+          expect(mockIssueRepository.createNewIssue.mock.calls).toEqual(
+            expectedCreateNewIssueCalls,
+          );
+          expect(mockIssueRepository.updateIssue.mock.calls).toEqual(
+            expectedUpdateIssueCalls,
+          );
+          expect(mockIssueRepository.updateStory.mock.calls).toEqual(
+            expectedUpdateStoryCalls,
+          );
+          expect(mockIssueRepository.getIssueByUrl.mock.calls).toEqual(
+            expectedGetIssueByUrlCalls,
+          );
+        });
+      },
+    );
+  });
+
+  describe('findCheckboxTextsNotCreatedIssue', () => {
+    const testCases: {
+      name: string;
+      input: string;
+      expected: string[];
+    }[] = [
+      {
+        name: 'should find checkbox texts not created as issues',
+        input: `- [ ] Task 1
+- [ ] Task 2
+- [x] Task 3
+- [ ] #5
+- [ ] #6 
+- [ ] https://github.com/org/repo/issues/1
+- [ ] https://github.com/org/repo/issues/7 `,
+        expected: ['Task 1', 'Task 2'],
+      },
+      {
+        name: 'should return empty array when no checkboxes found',
+        input: 'No checkboxes here',
+        expected: [],
+      },
+      {
+        name: 'should return empty array when all checkboxes are issues',
+        input: `- [ ] https://github.com/org/repo/issues/1
+- [ ] https://github.com/org/repo/issues/2`,
+        expected: [],
+      },
+    ];
+
+    testCases.forEach(({ name, input, expected }) => {
+      it(name, () => {
+        const useCase = new ConvertCheckboxToIssueInStoryIssueUseCase(
+          mockIssueRepository,
+        );
+        const result = useCase.findCheckboxTextsNotCreatedIssue(input);
+        expect(result).toEqual(expected);
+      });
+    });
+  });
+});

package/src/domain/usecases/ConvertCheckboxToIssueInStoryIssueUseCase.ts

@@ -0,0 +1,98 @@
+import { Issue } from '../entities/Issue';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Project } from '../entities/Project';
+import { StoryObjectMap } from './HandleScheduledEventUseCase';
+
+export class ConvertCheckboxToIssueInStoryIssueUseCase {
+  constructor(
+    readonly issueRepository: Pick<
+      IssueRepository,
+      'createNewIssue' | 'updateIssue' | 'updateStory' | 'getIssueByUrl'
+    >,
+  ) {}
+
+  run = async (input: {
+    project: Project;
+    issues: Issue[];
+    cacheUsed: boolean;
+    org: string;
+    repo: string;
+    urlOfStoryView: string;
+    disabledStatus: string;
+    storyObjectMap: StoryObjectMap;
+  }): Promise<void> => {
+    const story = input.project.story;
+    if (!story || input.cacheUsed) {
+      return;
+    }
+
+    for (const storyOption of input.project.story?.stories || []) {
+      const storyIssue = input.issues.find((issue) =>
+        storyOption.name.startsWith(issue.title),
+      );
+      const storyObject = input.storyObjectMap.get(storyOption.name);
+      if (storyOption.name.startsWith('regular / ')) {
+        continue;
+      } else if (!storyIssue || !storyObject) {
+        throw new Error(`Story issue not found: ${storyOption.name}`);
+      } else if (
+        storyIssue.isClosed ||
+        storyIssue.status === input.disabledStatus
+      ) {
+        continue;
+      } else if (!storyIssue.body.includes('- [ ] ')) {
+        continue;
+      }
+      const checkboxTextsNotCreatedIssue =
+        this.findCheckboxTextsNotCreatedIssue(storyIssue.body);
+      let newBody = storyIssue.body;
+      for (const checkboxText of checkboxTextsNotCreatedIssue) {
+        const issueTitle = checkboxText.replace(
+          'STORYNAME',
+          `${storyOption.name} #${storyIssue.number}`,
+        );
+        const newIssueNumber = await this.issueRepository.createNewIssue(
+          input.org,
+          input.repo,
+          issueTitle,
+          '',
+          [],
+          [],
+        );
+        const newIssueUrl = `https://github.com/${input.org}/${input.repo}/issues/${newIssueNumber}`;
+        newBody = newBody.replace(
+          `- [ ] ${checkboxText}`,
+          `- [ ] ${newIssueUrl}`,
+        );
+        await this.issueRepository.updateIssue({
+          ...storyIssue,
+          body: newBody,
+        });
+        await new Promise((resolve) => setTimeout(resolve, 30 * 1000));
+        const newIssue = await this.issueRepository.getIssueByUrl(newIssueUrl);
+        if (!newIssue) {
+          throw new Error(`Issue not found: ${newIssueUrl}`);
+        }
+        await this.issueRepository.updateStory(
+          { ...input.project, story: story },
+          newIssue,
+          storyOption.id,
+        );
+      }
+    }
+  };
+  findCheckboxTextsNotCreatedIssue = (storyIssueBody: string): string[] => {
+    const regexToFindCheckboxes = /^- \[ ] (.*)$/gm;
+    const match = storyIssueBody.match(regexToFindCheckboxes);
+    if (!match) return [];
+    const checkboxes: string[] = [];
+    for (let i = 0; i < match.length; i++) {
+      checkboxes.push(match[i].replace('- [ ] ', '').trim());
+    }
+    return checkboxes.filter(
+      (checkbox) =>
+        !checkbox.match(/^https:\/\/github.com\/.*\/issues\/\d+$/) &&
+        !checkbox.match(/^#\d+$/),
+    );
+  };
+}