github-issue-tower-defence-management 1.31.0 → 1.33.0

package/src/adapter/repositories/NodeLocalCommandRunner.test.ts

@@ -0,0 +1,80 @@
+const mockExecAsync = jest.fn();
+
+jest.mock('child_process', () => ({
+  exec: jest.fn(),
+}));
+
+jest.mock('util', () => ({
+  promisify: jest.fn(() => mockExecAsync),
+}));
+
+import { NodeLocalCommandRunner } from './NodeLocalCommandRunner';
+
+describe('NodeLocalCommandRunner', () => {
+  let runner: NodeLocalCommandRunner;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    runner = new NodeLocalCommandRunner();
+  });
+
+  describe('runCommand', () => {
+    it('should execute command successfully', async () => {
+      mockExecAsync.mockResolvedValue({
+        stdout: 'command output',
+        stderr: '',
+      });
+
+      const result = await runner.runCommand('echo "test"');
+
+      expect(result).toEqual({
+        stdout: 'command output',
+        stderr: '',
+        exitCode: 0,
+      });
+      expect(mockExecAsync).toHaveBeenCalledWith('echo "test"');
+    });
+
+    it('should handle command errors with exit code', async () => {
+      const error = Object.assign(new Error('Command failed'), {
+        code: 2,
+        stdout: 'partial output',
+        stderr: 'error message',
+      });
+      mockExecAsync.mockRejectedValue(error);
+
+      const result = await runner.runCommand('invalid-command');
+
+      expect(result).toEqual({
+        stdout: 'partial output',
+        stderr: 'error message',
+        exitCode: 2,
+      });
+    });
+
+    it('should default to exit code 1 when code is not a number', async () => {
+      const error = Object.assign(new Error('Command failed'), {
+        code: 'ENOENT',
+        stdout: '',
+        stderr: 'command not found',
+      });
+      mockExecAsync.mockRejectedValue(error);
+
+      const result = await runner.runCommand('nonexistent');
+
+      expect(result).toEqual({
+        stdout: '',
+        stderr: 'command not found',
+        exitCode: 1,
+      });
+    });
+
+    it('should throw error if error format is unexpected', async () => {
+      mockExecAsync.mockRejectedValue(new Error('Unexpected error'));
+
+      await expect(runner.runCommand('command')).rejects.toThrow(
+        'Unexpected error',
+      );
+    });
+  });
+});

package/src/adapter/repositories/NodeLocalCommandRunner.ts

@@ -0,0 +1,37 @@
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export class NodeLocalCommandRunner implements LocalCommandRunner {
+  async runCommand(command: string): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+  }> {
+    try {
+      const { stdout, stderr } = await execAsync(command);
+      return {
+        stdout,
+        stderr,
+        exitCode: 0,
+      };
+    } catch (error) {
+      if (
+        error &&
+        typeof error === 'object' &&
+        'stdout' in error &&
+        'stderr' in error &&
+        'code' in error
+      ) {
+        return {
+          stdout: String(error.stdout),
+          stderr: String(error.stderr),
+          exitCode: typeof error.code === 'number' ? error.code : 1,
+        };
+      }
+      throw error;
+    }
+  }
+}

package/src/adapter/repositories/StubClaudeRepository.test.ts

@@ -0,0 +1,19 @@
+import { StubClaudeRepository } from './StubClaudeRepository';
+
+describe('StubClaudeRepository', () => {
+  let repository: StubClaudeRepository;
+
+  beforeEach(() => {
+    repository = new StubClaudeRepository();
+  });
+
+  it('should return empty usage array', async () => {
+    const result = await repository.getUsage();
+    expect(result).toEqual([]);
+  });
+
+  it('should return true for isClaudeAvailable', async () => {
+    const result = await repository.isClaudeAvailable(90);
+    expect(result).toBe(true);
+  });
+});

package/src/adapter/repositories/StubClaudeRepository.ts

@@ -0,0 +1,12 @@
+import { ClaudeRepository } from '../../domain/usecases/adapter-interfaces/ClaudeRepository';
+import { ClaudeWindowUsage } from '../../domain/entities/ClaudeWindowUsage';
+
+export class StubClaudeRepository implements ClaudeRepository {
+  async getUsage(): Promise<ClaudeWindowUsage[]> {
+    return [];
+  }
+
+  async isClaudeAvailable(_threshold: number): Promise<boolean> {
+    return true;
+  }
+}

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

@@ -18,6 +18,8 @@ import { SetNoStoryIssueToStoryUseCase } from './SetNoStoryIssueToStoryUseCase';
 import { CreateNewStoryByLabelUseCase } from './CreateNewStoryByLabelUseCase';
 import { AssignNoAssigneeIssueToManagerUseCase } from './AssignNoAssigneeIssueToManagerUseCase';
 import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCase';
+import { StartPreparationUseCase } from './StartPreparationUseCase';
+import { NotifyFinishedIssuePreparationUseCase } from './NotifyFinishedIssuePreparationUseCase';
 
 describe('HandleScheduledEventUseCase', () => {
   describe('createTargetDateTimes', () => {
@@ -99,6 +101,9 @@ describe('HandleScheduledEventUseCase', () => {
       mock<AssignNoAssigneeIssueToManagerUseCase>();
     const mockUpdateIssueStatusByLabelUseCase =
       mock<UpdateIssueStatusByLabelUseCase>();
+    const mockStartPreparationUseCase = mock<StartPreparationUseCase>();
+    const mockNotifyFinishedIssuePreparationUseCase =
+      mock<NotifyFinishedIssuePreparationUseCase>();
     const mockDateRepository = mock<DateRepository>();
     const mockSpreadsheetRepository = mock<SpreadsheetRepository>();
     const mockProjectRepository = mock<ProjectRepository>();
@@ -118,6 +123,8 @@ describe('HandleScheduledEventUseCase', () => {
       mockCreateNewStoryByLabelUseCase,
       mockAssignNoAssigneeIssueToManagerUseCase,
       mockUpdateIssueStatusByLabelUseCase,
+      mockStartPreparationUseCase,
+      mockNotifyFinishedIssuePreparationUseCase,
       mockDateRepository,
       mockSpreadsheetRepository,
       mockProjectRepository,
@@ -141,6 +148,30 @@ describe('HandleScheduledEventUseCase', () => {
       ]);
     });
 
+    it('should call AnalyzeProblemByIssueUseCase with correct parameters', async () => {
+      const input = {
+        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 mockProject = mock<Project>();
+      mockProjectRepository.getProject.mockResolvedValue(mockProject);
+      await useCase.run(input);
+      expect(mockAnalyzeProblemByIssueUseCase.run).toHaveBeenCalled();
+    });
+
     it('should call UpdateIssueStatusByLabelUseCase with correct parameters', async () => {
       const input = {
         projectName: 'test-project',

package/src/domain/usecases/HandleScheduledEventUseCase.ts

@@ -19,6 +19,8 @@ import { SetNoStoryIssueToStoryUseCase } from './SetNoStoryIssueToStoryUseCase';
 import { CreateNewStoryByLabelUseCase } from './CreateNewStoryByLabelUseCase';
 import { AssignNoAssigneeIssueToManagerUseCase } from './AssignNoAssigneeIssueToManagerUseCase';
 import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCase';
+import { StartPreparationUseCase } from './StartPreparationUseCase';
+import { NotifyFinishedIssuePreparationUseCase } from './NotifyFinishedIssuePreparationUseCase';
 
 export class ProjectNotFoundError extends Error {
   constructor(message: string) {
@@ -42,6 +44,8 @@ export class HandleScheduledEventUseCase {
     readonly createNewStoryByLabelUseCase: CreateNewStoryByLabelUseCase,
     readonly assignNoAssigneeIssueToManagerUseCase: AssignNoAssigneeIssueToManagerUseCase,
     readonly updateIssueStatusByLabelUseCase: UpdateIssueStatusByLabelUseCase,
+    readonly startPreparationUseCase: StartPreparationUseCase,
+    readonly notifyFinishedIssuePreparationUseCase: NotifyFinishedIssuePreparationUseCase,
     readonly dateRepository: DateRepository,
     readonly spreadsheetRepository: SpreadsheetRepository,
     readonly projectRepository: ProjectRepository,
@@ -63,6 +67,20 @@ export class HandleScheduledEventUseCase {
     defaultStatus: string | null;
     disabled: boolean;
     allowIssueCacheMinutes: number;
+    startPreparation?: {
+      awaitingWorkspaceStatus: string;
+      preparationStatus: string;
+      defaultAgentName: string;
+      logFilePath?: string;
+      maximumPreparingIssuesCount: number | null;
+    } | null;
+    notifyFinishedPreparation?: {
+      preparationStatus: string;
+      awaitingWorkspaceStatus: string;
+      awaitingQualityCheckStatus: string;
+      thresholdForAutoReject: number;
+      workflowBlockerResolvedWebhookUrl: string | null;
+    } | null;
   }): Promise<{
     project: Project;
     issues: Issue[];
@@ -292,6 +310,39 @@ ${JSON.stringify(e)}
       issues,
       defaultStatus: input.defaultStatus,
     });
+    if (input.startPreparation) {
+      await this.startPreparationUseCase.run({
+        projectUrl: input.projectUrl,
+        awaitingWorkspaceStatus: input.startPreparation.awaitingWorkspaceStatus,
+        preparationStatus: input.startPreparation.preparationStatus,
+        defaultAgentName: input.startPreparation.defaultAgentName,
+        logFilePath: input.startPreparation.logFilePath,
+        maximumPreparingIssuesCount:
+          input.startPreparation.maximumPreparingIssuesCount,
+        allowIssueCacheMinutes: input.allowIssueCacheMinutes,
+      });
+    }
+    if (input.notifyFinishedPreparation) {
+      const notifyFinishedPreparation = input.notifyFinishedPreparation;
+      const preparationIssues = issues.filter(
+        (issue) => issue.status === notifyFinishedPreparation.preparationStatus,
+      );
+      for (const issue of preparationIssues) {
+        await this.notifyFinishedIssuePreparationUseCase.run({
+          projectUrl: input.projectUrl,
+          issueUrl: issue.url,
+          preparationStatus: input.notifyFinishedPreparation.preparationStatus,
+          awaitingWorkspaceStatus:
+            input.notifyFinishedPreparation.awaitingWorkspaceStatus,
+          awaitingQualityCheckStatus:
+            input.notifyFinishedPreparation.awaitingQualityCheckStatus,
+          thresholdForAutoReject:
+            input.notifyFinishedPreparation.thresholdForAutoReject,
+          workflowBlockerResolvedWebhookUrl:
+            input.notifyFinishedPreparation.workflowBlockerResolvedWebhookUrl,
+        });
+      }
+    }
   };
   static createTargetDateTimes = (from: Date, to: Date): Date[] => {
     const targetDateTimes: Date[] = [];