github-issue-tower-defence-management 1.1.0 → 1.3.0

package/src/domain/usecases/ClearDependedIssueURLUseCase.ts

@@ -0,0 +1,107 @@
+import { Issue } from '../entities/Issue';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Project } from '../entities/Project';
+
+export class ClearDependedIssueURLUseCase {
+  constructor(
+    readonly issueRepository: Pick<
+      IssueRepository,
+      'clearProjectField' | 'createComment' | 'updateProjectTextField'
+    >,
+  ) {}
+
+  run = async (input: {
+    project: Project;
+    issues: Issue[];
+    cacheUsed: boolean;
+  }): Promise<void> => {
+    const dependedIssueUrlSeparatedByComma =
+      input.project.dependedIssueUrlSeparatedByComma;
+    if (!dependedIssueUrlSeparatedByComma || input.cacheUsed) {
+      return;
+    }
+    for (const issue of input.issues) {
+      if (issue.dependedIssueUrls.length <= 0 || issue.isClosed) {
+        continue;
+      }
+      const circularDependedIssueUrls = issue.dependedIssueUrls.filter(
+        (dependedIssueUrl) => {
+          // get all depended issues circularly
+          const circularDependedIssues = new Set<string>();
+          const stack = [dependedIssueUrl];
+          while (stack.length > 0) {
+            const url = stack.pop();
+            if (!url) {
+              throw new Error('url is undefined');
+            }
+            if (circularDependedIssues.has(url)) {
+              continue;
+            }
+            circularDependedIssues.add(url);
+            const dependedIssue = input.issues.find(
+              (issue) => issue.url === url,
+            );
+            if (!dependedIssue) {
+              continue;
+            }
+            stack.push(...dependedIssue.dependedIssueUrls);
+          }
+          return circularDependedIssues.has(issue.url);
+        },
+      );
+      if (circularDependedIssueUrls.length > 0) {
+        await this.issueRepository.clearProjectField(
+          input.project,
+          dependedIssueUrlSeparatedByComma.fieldId,
+          issue,
+        );
+        await this.issueRepository.createComment(
+          issue,
+          `Circular dependency removed:
+${circularDependedIssueUrls.map((url) => `- ${url}`).join('\n')}`,
+        );
+        continue;
+      }
+      const remainingDependedIssueUrls = issue.dependedIssueUrls.filter(
+        (dependedIssueUrl) =>
+          input.issues.some((issue) => {
+            const r = issue.url === dependedIssueUrl && !issue.isClosed;
+            return r;
+          }),
+      );
+      const closedDependedIssueUrls = issue.dependedIssueUrls.filter(
+        (dependedIssueUrl) =>
+          remainingDependedIssueUrls.indexOf(dependedIssueUrl) === -1,
+      );
+      if (
+        remainingDependedIssueUrls.length === issue.dependedIssueUrls.length
+      ) {
+        continue;
+      }
+      if (remainingDependedIssueUrls.length === 0) {
+        await this.issueRepository.clearProjectField(
+          input.project,
+          dependedIssueUrlSeparatedByComma.fieldId,
+          issue,
+        );
+        await this.issueRepository.createComment(
+          issue,
+          `Closed all depended issues:
+${closedDependedIssueUrls.map((url) => `- ${url}`).join('\n')}`,
+        );
+      } else {
+        await this.issueRepository.updateProjectTextField(
+          input.project,
+          dependedIssueUrlSeparatedByComma.fieldId,
+          issue,
+          remainingDependedIssueUrls.join(','),
+        );
+        await this.issueRepository.createComment(
+          issue,
+          `Closed depended issues:
+${closedDependedIssueUrls.map((url) => `- ${url}`).join('\n')}`,
+        );
+      }
+    }
+  };
+}

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);
+      });
+    });
+  });
+});