github-issue-tower-defence-management 2.19.1 → 2.19.2

package/src/domain/usecases/CONTRIBUTING_FOR_TEST.md

@@ -1,259 +0,0 @@
-# Test Guidelines
-
-## Basic rules
-
-- Follow ./CONTRIBUTING.md
-- use '2000-01-01T00:00:00Z' as datetime to make easy to check by human
-
-## 1. Basic Structure
-
-### Test Organization
-
-```typescript
-describe('UseCaseName', () => {
-  describe('run', () => {
-    it('should do something', () => {
-      // test content
-    });
-  });
-});
-```
-
-### Test Setup
-
-- Set timeout if usecase requires async operations
-- Define reusable mock objects at the top of the test file
-- Use `beforeEach` for common setup and mock clearing
-
-## 2. Mock Objects
-
-### Creating Basic Mocks
-
-```typescript
-// Repository mocks
-const mockRepository = mock<RepositoryInterface>();
-
-// Entity mocks
-const mockEntity = mock<EntityType>();
-mockEntity.property = value;
-```
-
-### Complex Object Construction
-
-```typescript
-// WRONG - Direct object creation
-const wrongObject = {
-  status: {
-    name: 'test',
-    statuses: [],
-  },
-};
-
-// WRONG - Partial mock with type assertion
-const wrongMock = {
-  ...mock<Type>(),
-  statuses: [] as Status[],
-};
-
-// CORRECT - Full mock construction
-const mockStatus = mock<Project['status']>();
-mockStatus.name = 'Status';
-mockStatus.fieldId = 'field1';
-mockStatus.statuses = [];
-
-const mockProject = mock<Project>();
-mockProject.status = mockStatus;
-```
-
-### Nested Object Construction
-
-```typescript
-// WRONG - Mixed direct creation and mocks
-const wrongNested = {
-  ...mock<Parent>(),
-  child: {
-    property: 'value',
-  },
-};
-
-// CORRECT - Fully mocked structure
-const mockChild = mock<ChildType>();
-mockChild.property = 'value';
-
-const mockParent = mock<ParentType>();
-mockParent.child = mockChild;
-```
-
-### Array Properties
-
-```typescript
-// WRONG - Direct empty array
-const wrongArray = [];
-const alsoWrong = [] as Type[];
-
-// CORRECT - Properly typed mock array
-const mockItem = mock<ItemType>();
-mockItem.property = 'value';
-const correctArray = [mockItem];
-
-// CORRECT - Empty array with mock type
-const mockStatus = mock<Project['status']>();
-mockStatus.statuses = [];
-```
-
-## 3. Test Cases
-
-### Structure
-
-```typescript
-const testCases: {
-  name: string;
-  input: {
-    // Fully typed input properties
-  };
-  expectedCalls: {
-    // Fully typed expected results
-  };
-}[] = [
-  {
-    name: 'descriptive test name',
-    input: {
-      project: mockProject,
-      // other inputs...
-    },
-    expectedCalls: {
-      methodName: [[param1, param2]],
-    },
-  },
-];
-```
-
-### Execution
-
-```typescript
-testCases.forEach(({ name, input, expectedCalls }) => {
-  it(name, async () => {
-    // Clear mocks before each test case
-    jest.clearAllMocks();
-
-    // Execute test
-    await useCase.run(input);
-
-    // Verify all expected calls
-    expect(mockRepository.method.mock.calls).toEqual(expectedCalls.methodName);
-  });
-});
-```
-
-## 4. Strict Rules
-
-### Forbidden Practices
-
-- Type assertions (`as`)
-- Using `any` type
-- Non-null assertions (`!`)
-- Comments within test cases
-- Non-English text
-- Direct object creation without mocks
-- Partial mock objects
-- Type casting
-- Mixing direct creation with mocks
-
-### Required Practices
-
-- Full mock creation for all objects
-- Explicit type definitions
-- Separate mock creation for nested objects
-- Clear mock setup before each test
-- Verification of all mock calls
-- Error case testing
-- Complete type coverage
-
-## 5. Error Testing
-
-### Structure
-
-```typescript
-it('should throw specific error', async () => {
-  const mockErrorCase = mock<InputType>();
-  // Setup error condition...
-
-  await expect(useCase.run(mockErrorCase)).rejects.toThrow(
-    'Expected error message',
-  );
-});
-```
-
-## 6. Mock Implementation
-
-### Dynamic Returns
-
-```typescript
-// Counter implementation
-let counter = 1;
-mockRepository.method.mockImplementation(() => counter++);
-
-// Conditional returns
-mockRepository.method.mockImplementation((input) => {
-  if (condition) {
-    return valueA;
-  }
-  return valueB;
-});
-```
-
-## 7. Verification
-
-### Call Verification
-
-```typescript
-expect(mockRepository.method.mock.calls).toEqual([
-  [param1, param2],
-  [param3, param4],
-]);
-
-expect(mockRepository.method).toHaveBeenCalledWith(
-  expect.objectContaining({
-    property: value,
-  }),
-);
-```
-
-### State Verification
-
-```typescript
-expect(result).toEqual(
-  expect.objectContaining({
-    property: expectedValue,
-  }),
-);
-```
-
-## 8. Test Data Management
-
-### Base Objects
-
-```typescript
-const baseMockProject = mock<Project>();
-const baseMockIssue = mock<Issue>();
-
-// Extend base objects
-const testProject = {
-  ...baseMockProject,
-  status: mockStatus,
-};
-```
-
-### Common Setup
-
-```typescript
-beforeEach(() => {
-  jest.clearAllMocks();
-
-  // Reset base mocks
-  baseMockProject.property = defaultValue;
-
-  // Setup common mock implementations
-  mockRepository.method.mockResolvedValue(defaultValue);
-});
-```

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

@@ -1,437 +0,0 @@
-import { mock } from 'jest-mock-extended';
-import { ChangeStatusByStoryColorUseCase } from './ChangeStatusByStoryColorUseCase';
-import { DateRepository } from './adapter-interfaces/DateRepository';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { Issue } from '../entities/Issue';
-import { FieldOption, Project, StoryOption } from '../entities/Project';
-import { StoryObject, StoryObjectMap } from '../entities/StoryObjectMap';
-
-describe('ChangeStatusByStoryColorUseCase', () => {
-  const mockDateRepository = mock<DateRepository>();
-  const mockIssueRepository = mock<IssueRepository>();
-
-  const manager = 'manager-user';
-  const nonManagerAssignee = 'human-owner';
-
-  const mockStatus = mock<FieldOption>();
-  mockStatus.id = 'status1';
-  mockStatus.name = 'ToDo';
-
-  const mockReviewStatus = mock<FieldOption>();
-  mockReviewStatus.id = 'status2';
-  mockReviewStatus.name = 'InReview';
-
-  const mockIceboxStatus = mock<FieldOption>();
-  mockIceboxStatus.id = 'status3';
-  mockIceboxStatus.name = 'Icebox';
-
-  const basicProject = {
-    ...mock<Project>(),
-    story: {
-      name: 'Story Field',
-      fieldId: 'storyFieldId',
-      databaseId: 1,
-      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' },
-    },
-    status: {
-      name: 'Status Field',
-      fieldId: 'statusFieldId',
-      statuses: [mockStatus, mockReviewStatus, mockIceboxStatus],
-    },
-  };
-
-  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 basicIssue1 = {
-    ...mock<Issue>(),
-    title: 'Issue 1',
-    number: 789,
-    status: 'Unread',
-    assignees: [],
-  };
-  const basicIssue2 = {
-    ...mock<Issue>(),
-    title: 'Issue 2',
-    number: 101,
-    status: 'In Progres',
-    assignees: [],
-  };
-
-  const basicStoryObject1: StoryObject = {
-    story: {
-      ...mock<StoryOption>(),
-      id: 'story1',
-      name: 'Story 1',
-      color: 'RED',
-    },
-    storyIssue: basicStoryIssue1,
-    issues: [basicIssue1],
-  };
-  const basicStoryObject2: StoryObject = {
-    story: {
-      ...mock<StoryOption>(),
-      id: 'story2',
-      name: 'Story 2',
-      color: 'BLUE',
-    },
-    storyIssue: basicStoryIssue2,
-    issues: [basicIssue2],
-  };
-
-  const basicStoryObjectMap: StoryObjectMap = new Map([
-    ['Story 1', basicStoryObject1],
-    ['Story 2', basicStoryObject2],
-  ]);
-
-  const useCase = new ChangeStatusByStoryColorUseCase(
-    mockDateRepository,
-    mockIssueRepository,
-  );
-
-  const testCases: {
-    name: string;
-    input: Parameters<ChangeStatusByStoryColorUseCase['run']>[0];
-    expectedCalls: {
-      createComment: [unknown, string][];
-      updateStatus: [unknown, unknown, string][];
-    };
-  }[] = [
-    {
-      name: `should no update when status is correct`,
-      input: {
-        project: basicProject,
-        cacheUsed: false,
-        org: 'testOrg',
-        repo: 'testRepo',
-        storyObjectMap: basicStoryObjectMap,
-        manager,
-      },
-      expectedCalls: {
-        createComment: [],
-        updateStatus: [],
-      },
-    },
-    {
-      name: `should no update when cacheUsed`,
-      input: {
-        project: basicProject,
-        cacheUsed: true,
-        org: 'testOrg',
-        repo: 'testRepo',
-        storyObjectMap: basicStoryObjectMap,
-        manager,
-      },
-      expectedCalls: {
-        createComment: [],
-        updateStatus: [],
-      },
-    },
-    {
-      name: `should update status with comment when story color is gray.`,
-      input: {
-        project: basicProject,
-        cacheUsed: false,
-        org: 'testOrg',
-        repo: 'testRepo',
-        storyObjectMap: new Map([
-          [
-            'Story 1',
-            {
-              ...basicStoryObject1,
-              story: {
-                ...basicStoryObject1.story,
-                color: 'GRAY',
-              },
-            },
-          ],
-          ['Story 2', basicStoryObject2],
-        ]),
-        manager,
-      },
-      expectedCalls: {
-        createComment: [
-          [
-            expect.anything(),
-            'This issue status is changed because the story is disabled.',
-          ],
-        ],
-        updateStatus: [[expect.anything(), expect.anything(), 'status3']],
-      },
-    },
-    {
-      name: `should update status with comment when story color is not gray`,
-      input: {
-        project: basicProject,
-        cacheUsed: false,
-        org: 'testOrg',
-        repo: 'testRepo',
-        storyObjectMap: new Map([
-          [
-            'Story 1',
-            {
-              ...basicStoryObject1,
-              issues: [
-                {
-                  ...basicStoryObject1.issues[0],
-                  status: 'Icebox',
-                },
-              ],
-            },
-          ],
-          ['Story 2', basicStoryObject2],
-        ]),
-        manager,
-      },
-      expectedCalls: {
-        createComment: [
-          [
-            expect.anything(),
-            'This issue status is changed because the story is enabled.',
-          ],
-        ],
-        updateStatus: [[expect.anything(), expect.anything(), 'status1']],
-      },
-    },
-  ];
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockDateRepository.now.mockResolvedValue(new Date('2000-01-01T00:00:00Z'));
-  });
-
-  describe('run', () => {
-    testCases.forEach(({ name, input, expectedCalls }) => {
-      it(name, async () => {
-        await useCase.run(input);
-
-        expect(mockIssueRepository.createComment.mock.calls).toEqual(
-          expectedCalls.createComment,
-        );
-        expect(mockIssueRepository.updateStatus.mock.calls).toEqual(
-          expectedCalls.updateStatus,
-        );
-      });
-    });
-
-    it('should throw error when project has no statuses', async () => {
-      const mockStatusWithNoStatuses = mock<Project['status']>();
-      mockStatusWithNoStatuses.name = 'Status';
-      mockStatusWithNoStatuses.fieldId = 'status_field';
-      mockStatusWithNoStatuses.statuses = [];
-
-      const projectWithNoStatus = {
-        ...basicProject,
-        status: mockStatusWithNoStatuses,
-      };
-
-      await expect(
-        useCase.run({
-          project: projectWithNoStatus,
-          cacheUsed: false,
-          org: 'testOrg',
-          repo: 'testRepo',
-          storyObjectMap: basicStoryObjectMap,
-          manager,
-        }),
-      ).rejects.toThrow('First status is not found');
-    });
-  });
-
-  describe('first status assignment for an issue with no status', () => {
-    const activeStory = {
-      ...mock<StoryOption>(),
-      id: 'story1',
-      name: 'Story 1',
-      color: 'RED' as const,
-    };
-
-    const buildStoryObjectMap = (issue: Issue): StoryObjectMap =>
-      new Map([
-        [
-          'Story 1',
-          {
-            ...basicStoryObject1,
-            story: activeStory,
-            issues: [issue],
-          },
-        ],
-      ]);
-
-    const runInput = (issue: Issue) => ({
-      project: basicProject,
-      cacheUsed: false,
-      org: 'testOrg',
-      repo: 'testRepo',
-      storyObjectMap: buildStoryObjectMap(issue),
-      manager,
-    });
-
-    it('should set the first status on an issue with no status whose only assignee is the manager', async () => {
-      const managerAssignedIssueWithoutStatus: Issue = {
-        ...basicIssue1,
-        status: null,
-        assignees: [manager],
-      };
-
-      await useCase.run(runInput(managerAssignedIssueWithoutStatus));
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        basicProject,
-        managerAssignedIssueWithoutStatus,
-        'status1',
-      );
-      expect(mockIssueRepository.createComment).toHaveBeenCalledWith(
-        managerAssignedIssueWithoutStatus,
-        'This issue status is changed because the story is enabled.',
-      );
-    });
-
-    it('should not set the first status on an issue with no status that is assigned to someone other than the manager', async () => {
-      const consoleWarnSpy = jest
-        .spyOn(console, 'warn')
-        .mockImplementation(() => undefined);
-      const humanAssignedIssueWithoutStatus: Issue = {
-        ...basicIssue1,
-        url: 'https://github.com/org/repo/issues/789',
-        status: null,
-        assignees: [nonManagerAssignee],
-      };
-
-      await useCase.run(runInput(humanAssignedIssueWithoutStatus));
-
-      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-      expect(mockIssueRepository.createComment).not.toHaveBeenCalled();
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        `ChangeStatusByStoryColorUseCase: skipping the first status write because the issue has no status and is assigned to someone other than the manager. issueUrl: https://github.com/org/repo/issues/789 assignees: ${nonManagerAssignee}`,
-      );
-      consoleWarnSpy.mockRestore();
-    });
-
-    it('should not set the first status on an issue with no status assigned to both the manager and another person', async () => {
-      const consoleWarnSpy = jest
-        .spyOn(console, 'warn')
-        .mockImplementation(() => undefined);
-      const coAssignedIssueWithoutStatus: Issue = {
-        ...basicIssue1,
-        status: null,
-        assignees: [manager, nonManagerAssignee],
-      };
-
-      await useCase.run(runInput(coAssignedIssueWithoutStatus));
-
-      expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-      expect(mockIssueRepository.createComment).not.toHaveBeenCalled();
-      consoleWarnSpy.mockRestore();
-    });
-
-    it('should set the first status on an issue with no status that has no assignee', async () => {
-      const unassignedIssueWithoutStatus: Issue = {
-        ...basicIssue1,
-        status: null,
-        assignees: [],
-      };
-
-      await useCase.run(runInput(unassignedIssueWithoutStatus));
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        basicProject,
-        unassignedIssueWithoutStatus,
-        'status1',
-      );
-      expect(mockIssueRepository.createComment).toHaveBeenCalledWith(
-        unassignedIssueWithoutStatus,
-        'This issue status is changed because the story is enabled.',
-      );
-    });
-  });
-
-  describe('icebox exit when the story is enabled', () => {
-    const activeStory = {
-      ...mock<StoryOption>(),
-      id: 'story1',
-      name: 'Story 1',
-      color: 'RED' as const,
-    };
-
-    const buildStoryObjectMap = (issue: Issue): StoryObjectMap =>
-      new Map([
-        [
-          'Story 1',
-          {
-            ...basicStoryObject1,
-            story: activeStory,
-            issues: [issue],
-          },
-        ],
-      ]);
-
-    const runInput = (issue: Issue) => ({
-      project: basicProject,
-      cacheUsed: false,
-      org: 'testOrg',
-      repo: 'testRepo',
-      storyObjectMap: buildStoryObjectMap(issue),
-      manager,
-    });
-
-    it('should move an Icebox issue that is assigned to someone other than the manager to the first status', async () => {
-      const assignedIceboxIssue: Issue = {
-        ...basicIssue1,
-        status: 'Icebox',
-        assignees: [nonManagerAssignee],
-      };
-
-      await useCase.run(runInput(assignedIceboxIssue));
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        basicProject,
-        assignedIceboxIssue,
-        'status1',
-      );
-      expect(mockIssueRepository.createComment).toHaveBeenCalledWith(
-        assignedIceboxIssue,
-        'This issue status is changed because the story is enabled.',
-      );
-    });
-
-    it('should move an Icebox issue that has no assignee to the first status', async () => {
-      const unassignedIceboxIssue: Issue = {
-        ...basicIssue1,
-        status: 'Icebox',
-        assignees: [],
-      };
-
-      await useCase.run(runInput(unassignedIceboxIssue));
-
-      expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-        basicProject,
-        unassignedIceboxIssue,
-        'status1',
-      );
-      expect(mockIssueRepository.createComment).toHaveBeenCalledWith(
-        unassignedIceboxIssue,
-        'This issue status is changed because the story is enabled.',
-      );
-    });
-  });
-});