github-issue-tower-defence-management 1.38.1 → 1.40.0

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

@@ -12,6 +12,7 @@ import { DateRepository } from './adapter-interfaces/DateRepository';
 import { SpreadsheetRepository } from './adapter-interfaces/SpreadsheetRepository';
 import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
 import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { Issue } from '../entities/Issue';
 import { Project } from '../entities/Project';
 import { ChangeStatusByStoryColorUseCase } from './ChangeStatusByStoryColorUseCase';
 import { SetNoStoryIssueToStoryUseCase } from './SetNoStoryIssueToStoryUseCase';
@@ -309,5 +310,150 @@ describe('HandleScheduledEventUseCase', () => {
         120,
       );
     });
+
+    describe('story issue creation progress logs', () => {
+      const storyInput = {
+        projectName: 'test-project',
+        org: 'test-org',
+        projectUrl: 'https://github.com/test-org/test-project',
+        manager: 'test-manager',
+        workingReport: {
+          repo: 'test-repo',
+          members: ['member1'],
+          spreadsheetUrl: 'https://docs.google.com/spreadsheets/test',
+        },
+        urlOfStoryView: 'https://github.com/test-org/test-project/issues',
+        disabledStatus: 'disabled',
+        defaultStatus: null,
+        disabled: false,
+        allowIssueCacheMinutes: 60,
+      };
+
+      const storyProject: Project = {
+        id: 'proj-1',
+        url: 'https://github.com/orgs/test-org/projects/1',
+        databaseId: 1,
+        name: 'test-project',
+        status: { name: 'Status', fieldId: 'f1', statuses: [] },
+        nextActionDate: null,
+        nextActionHour: null,
+        story: {
+          name: 'Story',
+          fieldId: 'f2',
+          databaseId: 2,
+          stories: [
+            {
+              id: 'story-1',
+              name: 'feature / StoryOne',
+              color: 'BLUE',
+              description: 'story desc',
+            },
+          ],
+          workflowManagementStory: { id: 'wm-1', name: 'workflow' },
+        },
+        remainingEstimationMinutes: null,
+        dependedIssueUrlSeparatedByComma: null,
+        completionDate50PercentConfidence: null,
+      };
+
+      const capturedLogs: string[] = [];
+      let consoleSpy: jest.SpyInstance;
+
+      beforeEach(() => {
+        capturedLogs.length = 0;
+        consoleSpy = jest
+          .spyOn(console, 'log')
+          .mockImplementation((...data: unknown[]) => {
+            const firstData = data[0];
+            if (
+              typeof firstData === 'string' &&
+              firstData.startsWith('[HandleScheduledEvent]')
+            ) {
+              capturedLogs.push(firstData);
+            }
+          });
+        jest.useFakeTimers();
+        mockProjectRepository.getProject.mockResolvedValue(storyProject);
+        mockIssueRepository.getAllIssues.mockResolvedValue({
+          issues: [],
+          cacheUsed: false,
+        });
+        mockIssueRepository.createNewIssue.mockResolvedValue(99);
+        const createdIssue = mock<Issue>();
+        createdIssue.itemId = 'item-99';
+        mockIssueRepository.getIssueByUrl.mockResolvedValue(createdIssue);
+      });
+
+      afterEach(() => {
+        consoleSpy.mockRestore();
+        jest.useRealTimers();
+      });
+
+      it('should emit Creating story issue log before createNewIssue', async () => {
+        const runPromise = useCase.run(storyInput);
+        await jest.runAllTimersAsync();
+        await runPromise;
+
+        expect(capturedLogs[0]).toContain('Creating story issue');
+        expect(capturedLogs[0]).toContain('feature / StoryOne');
+      });
+
+      it('should emit Polling for issue log before each 30s sleep', async () => {
+        const runPromise = useCase.run(storyInput);
+        await jest.runAllTimersAsync();
+        await runPromise;
+
+        expect(capturedLogs[1]).toContain('Polling for issue (attempt 1/3)');
+        expect(capturedLogs[1]).toContain(
+          'https://github.com/test-org/test-repo/issues/99',
+        );
+      });
+
+      it('should emit Issue found log on successful issue lookup', async () => {
+        const runPromise = useCase.run(storyInput);
+        await jest.runAllTimersAsync();
+        await runPromise;
+
+        expect(capturedLogs[2]).toContain('Issue found');
+        expect(capturedLogs[2]).toContain(
+          'https://github.com/test-org/test-repo/issues/99',
+        );
+        expect(capturedLogs[2]).toContain('itemId=item-99');
+      });
+
+      it('should emit Waiting for story update log before 10s sleep', async () => {
+        const runPromise = useCase.run(storyInput);
+        await jest.runAllTimersAsync();
+        await runPromise;
+
+        expect(capturedLogs[3]).toContain('Waiting for story update');
+        expect(capturedLogs[3]).toContain(
+          'https://github.com/test-org/test-repo/issues/99',
+        );
+      });
+
+      it('should emit Story issue created log with elapsed time after iteration completes', async () => {
+        const runPromise = useCase.run(storyInput);
+        await jest.runAllTimersAsync();
+        await runPromise;
+
+        expect(capturedLogs[4]).toContain('Story issue created');
+        expect(capturedLogs[4]).toContain('feature / StoryOne');
+        expect(capturedLogs[4]).toMatch(/elapsed=\d+ms/);
+      });
+
+      it('should emit logs in expected order', async () => {
+        const runPromise = useCase.run(storyInput);
+        await jest.runAllTimersAsync();
+        await runPromise;
+
+        expect(capturedLogs).toHaveLength(5);
+        expect(capturedLogs[0]).toContain('Creating story issue');
+        expect(capturedLogs[1]).toContain('Polling for issue (attempt 1/3)');
+        expect(capturedLogs[2]).toContain('Issue found');
+        expect(capturedLogs[3]).toContain('Waiting for story update');
+        expect(capturedLogs[4]).toContain('Story issue created');
+      });
+    });
   });
 });

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -131,6 +131,10 @@ export class HandleScheduledEventUseCase {
       ) {
         continue;
       }
+      const storyStartTime = Date.now();
+      console.log(
+        `[HandleScheduledEvent] Creating story issue: story="${storyObject.story.name}"`,
+      );
       const issueNumber = await this.issueRepository.createNewIssue(
         input.org,
         input.workingReport.repo,
@@ -142,13 +146,17 @@ export class HandleScheduledEventUseCase {
       const issueUrl = `https://github.com/${input.org}/${input.workingReport.repo}/issues/${issueNumber}`;
       let issue: Issue | null = null;
       for (let i = 0; i < 3; i++) {
+        console.log(
+          `[HandleScheduledEvent] Polling for issue (attempt ${i + 1}/3): url=${issueUrl}`,
+        );
         await new Promise((resolve) => setTimeout(resolve, 30 * 1000));
         issue = await this.issueRepository.getIssueByUrl(issueUrl);
-        if (!issue) {
-          continue;
-        } else if (!issue.itemId) {
+        if (!issue || !issue.itemId) {
           continue;
         }
+        console.log(
+          `[HandleScheduledEvent] Issue found: url=${issueUrl} itemId=${issue.itemId}`,
+        );
         break;
       }
       if (!issue) {
@@ -161,6 +169,9 @@ export class HandleScheduledEventUseCase {
         issue,
         storyObject.story.id,
       );
+      console.log(
+        `[HandleScheduledEvent] Waiting for story update: url=${issueUrl}`,
+      );
       await new Promise((resolve) => setTimeout(resolve, 10 * 1000));
       const newIssue = await this.issueRepository.getIssueByUrl(issueUrl);
       if (!newIssue) {
@@ -169,6 +180,9 @@ export class HandleScheduledEventUseCase {
       storyObject.storyIssue = newIssue;
       issues.push(newIssue);
       storyObject.issues.push(newIssue);
+      console.log(
+        `[HandleScheduledEvent] Story issue created: story="${storyObject.story.name}" elapsed=${Date.now() - storyStartTime}ms`,
+      );
     }
 
     const targetDateTimes: Date[] =