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

package/src/adapter/repositories/GraphqlProjectRepository.fetchProjectId.test.ts

@@ -1,254 +0,0 @@
-const mockPost = jest.fn();
-
-jest.mock('ky', () => ({
-  default: {
-    post: mockPost,
-    get: jest.fn(),
-    put: jest.fn(),
-    patch: jest.fn(),
-    delete: jest.fn(),
-    extend: jest.fn(),
-    create: jest.fn(),
-    stop: jest.fn(),
-  },
-  __esModule: true,
-}));
-
-import { GraphqlProjectRepository } from './GraphqlProjectRepository';
-import { LocalStorageRepository } from './LocalStorageRepository';
-
-const mockJsonResponse = <T>(data: T) => ({
-  json: jest.fn().mockResolvedValue(data),
-});
-
-describe('GraphqlProjectRepository.fetchProjectId', () => {
-  const localStorageRepository = new LocalStorageRepository();
-  let repository: GraphqlProjectRepository;
-
-  beforeEach(() => {
-    jest.useFakeTimers();
-    mockPost.mockReset();
-    repository = new GraphqlProjectRepository(
-      localStorageRepository,
-      'dummy-token',
-    );
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  describe('user-owned project', () => {
-    it('should resolve project ID from user owner when organization returns null', async () => {
-      mockPost.mockReturnValueOnce(
-        mockJsonResponse({
-          data: {
-            organization: null,
-            user: {
-              projectV2: {
-                id: 'PVT_user123',
-                databaseId: 999,
-              },
-            },
-          },
-        }),
-      );
-
-      const result = await repository.fetchProjectId('some-user', 1);
-
-      expect(result).toBe('PVT_user123');
-    });
-
-    it('should resolve project ID from organization owner when user returns null', async () => {
-      mockPost.mockReturnValueOnce(
-        mockJsonResponse({
-          data: {
-            organization: {
-              projectV2: {
-                id: 'PVT_org456',
-                databaseId: 111,
-              },
-            },
-            user: null,
-          },
-        }),
-      );
-
-      const result = await repository.fetchProjectId('some-org', 2);
-
-      expect(result).toBe('PVT_org456');
-    });
-  });
-
-  describe('memoization', () => {
-    it('should return cached project ID on subsequent calls without re-fetching', async () => {
-      mockPost.mockReturnValueOnce(
-        mockJsonResponse({
-          data: {
-            organization: null,
-            user: {
-              projectV2: {
-                id: 'PVT_cached',
-                databaseId: 777,
-              },
-            },
-          },
-        }),
-      );
-
-      const first = await repository.fetchProjectId('owner', 10);
-      const second = await repository.fetchProjectId('owner', 10);
-
-      expect(first).toBe('PVT_cached');
-      expect(second).toBe('PVT_cached');
-      expect(mockPost).toHaveBeenCalledTimes(1);
-    });
-
-    it('should use separate cache entries for different owner+projectNumber combinations', async () => {
-      mockPost
-        .mockReturnValueOnce(
-          mockJsonResponse({
-            data: {
-              organization: null,
-              user: { projectV2: { id: 'PVT_A', databaseId: 1 } },
-            },
-          }),
-        )
-        .mockReturnValueOnce(
-          mockJsonResponse({
-            data: {
-              organization: null,
-              user: { projectV2: { id: 'PVT_B', databaseId: 2 } },
-            },
-          }),
-        );
-
-      const resultA = await repository.fetchProjectId('ownerA', 1);
-      const resultB = await repository.fetchProjectId('ownerB', 1);
-
-      expect(resultA).toBe('PVT_A');
-      expect(resultB).toBe('PVT_B');
-      expect(mockPost).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('errors-only response hardening', () => {
-    it('should throw a clear error when response has no data field', async () => {
-      mockPost.mockReturnValueOnce(
-        mockJsonResponse({
-          errors: [{ message: 'Could not resolve to a User' }],
-        }),
-      );
-
-      await expect(repository.fetchProjectId('bad-owner', 1)).rejects.toThrow(
-        'Could not resolve to a User',
-      );
-    });
-
-    it('should throw a clear error when data is null', async () => {
-      mockPost.mockReturnValueOnce(
-        mockJsonResponse({
-          data: null,
-          errors: [{ message: 'secondary rate limit' }],
-        }),
-      );
-
-      await expect(
-        repository.fetchProjectId('rate-limited', 1),
-      ).rejects.toThrow('secondary rate limit');
-    });
-
-    it('should throw a clear error when data has no project in either org or user', async () => {
-      mockPost.mockReturnValueOnce(
-        mockJsonResponse({
-          data: {
-            organization: null,
-            user: null,
-          },
-        }),
-      );
-
-      await expect(
-        repository.fetchProjectId('no-project-owner', 99),
-      ).rejects.toThrow('project not found');
-    });
-
-    it('should throw a clear error when network call fails', async () => {
-      mockPost.mockReturnValueOnce({
-        json: jest.fn().mockRejectedValue(new Error('network failure')),
-      });
-
-      await expect(repository.fetchProjectId('owner', 1)).rejects.toThrow(
-        'network failure',
-      );
-    });
-  });
-
-  describe('backoff after failure', () => {
-    it('should not re-call GraphQL within 1 hour after a failure', async () => {
-      mockPost.mockReturnValueOnce(
-        mockJsonResponse({
-          errors: [{ message: 'auth failure' }],
-        }),
-      );
-
-      await expect(repository.fetchProjectId('owner', 5)).rejects.toThrow();
-
-      await expect(repository.fetchProjectId('owner', 5)).rejects.toThrow(
-        'backoff',
-      );
-
-      expect(mockPost).toHaveBeenCalledTimes(1);
-    });
-
-    it('should retry after 1 hour backoff has elapsed', async () => {
-      mockPost
-        .mockReturnValueOnce(
-          mockJsonResponse({
-            errors: [{ message: 'temporary error' }],
-          }),
-        )
-        .mockReturnValueOnce(
-          mockJsonResponse({
-            data: {
-              organization: null,
-              user: { projectV2: { id: 'PVT_recovered', databaseId: 42 } },
-            },
-          }),
-        );
-
-      await expect(repository.fetchProjectId('owner', 7)).rejects.toThrow();
-
-      jest.advanceTimersByTime(60 * 60 * 1000 + 1);
-
-      const result = await repository.fetchProjectId('owner', 7);
-
-      expect(result).toBe('PVT_recovered');
-      expect(mockPost).toHaveBeenCalledTimes(2);
-    });
-
-    it('should apply backoff independently per owner+projectNumber', async () => {
-      mockPost
-        .mockReturnValueOnce(
-          mockJsonResponse({
-            errors: [{ message: 'error for owner A' }],
-          }),
-        )
-        .mockReturnValueOnce(
-          mockJsonResponse({
-            data: {
-              organization: null,
-              user: { projectV2: { id: 'PVT_B', databaseId: 2 } },
-            },
-          }),
-        );
-
-      await expect(repository.fetchProjectId('ownerA', 1)).rejects.toThrow();
-
-      const resultB = await repository.fetchProjectId('ownerB', 1);
-
-      expect(resultB).toBe('PVT_B');
-      expect(mockPost).toHaveBeenCalledTimes(2);
-    });
-  });
-});

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

@@ -1,209 +0,0 @@
-import { GraphqlProjectRepository } from './GraphqlProjectRepository';
-import { LocalStorageRepository } from './LocalStorageRepository';
-import { FieldOption, Project } from '../../domain/entities/Project';
-
-const token = process.env.GH_TOKEN;
-const describeWhenCredentials = token ? describe : describe.skip;
-
-describeWhenCredentials('GraphqlProjectRepository', () => {
-  const localStorageRepository = new LocalStorageRepository();
-  let repository: GraphqlProjectRepository;
-  const login = 'HiromiShikata';
-  const projectUrl = `https://github.com/users/HiromiShikata/projects/49`;
-  const projectNumber = 49;
-  const projectId = 'PVT_kwHOAGJHa84AFhgF';
-
-  beforeEach(() => {
-    repository = new GraphqlProjectRepository(localStorageRepository, token);
-  });
-
-  describe('fetchProjectId', () => {
-    it('should fetch project ID using GraphQL API', async () => {
-      const response = await repository.fetchProjectId(login, projectNumber);
-
-      expect(response).toEqual(projectId);
-    });
-  });
-
-  describe('findProjectIdByUrl', () => {
-    it('should extract project ID from URL and fetch it', async () => {
-      const response = await repository.findProjectIdByUrl(projectUrl);
-      expect(response).toEqual(projectId);
-    });
-  });
-
-  describe('updateStoryList', () => {
-    const storyFieldId = 'PVTSSF_lAHOAGJHa84AFhgFzg1oBms';
-    const existingStories: FieldOption[] = [
-      { id: 'af410dae', name: 'story1', color: 'GRAY', description: '' },
-      {
-        id: '696ccdef',
-        name: 'Workflow Management',
-        color: 'GRAY',
-        description: '',
-      },
-      { id: '4fa21881', name: 'test', color: 'GRAY', description: '' },
-    ];
-    const testProject: Project = {
-      id: projectId,
-      url: projectUrl,
-      databaseId: 1447941,
-      name: 'V2 project on owner for testing',
-      completionDate50PercentConfidence: null,
-      dependedIssueUrlSeparatedByComma: null,
-      nextActionDate: {
-        fieldId: 'PVTF_lAHOAGJHa84AFhgFzgVlnK4',
-        name: 'NextActionDate',
-      },
-      nextActionHour: null,
-      remainingEstimationMinutes: null,
-      status: {
-        fieldId: 'PVTSSF_lAHOAGJHa84AFhgFzgDLt0c',
-        name: 'Status',
-        statuses: [],
-      },
-      story: {
-        fieldId: storyFieldId,
-        databaseId: 224921195,
-        name: 'Story',
-        stories: existingStories,
-        workflowManagementStory: {
-          id: '696ccdef',
-          name: 'Workflow Management',
-        },
-      },
-      agent: null,
-    };
-
-    it('should add a new option while preserving all existing options', async () => {
-      const uniqueSuffix = Date.now().toString(36);
-      const newOption: Omit<FieldOption, 'id'> & { id: null } = {
-        id: null,
-        name: `test-story-graphql-${uniqueSuffix}`,
-        color: 'BLUE',
-        description: 'created by graphql unit test',
-      };
-      const inputList: Parameters<typeof repository.updateStoryList>['1'] = [
-        ...existingStories,
-        newOption,
-      ];
-
-      const result = await repository.updateStoryList(testProject, inputList);
-
-      expect(result).toHaveLength(existingStories.length + 1);
-      existingStories.forEach((existing) => {
-        const found = result.find((r) => r.id === existing.id);
-        expect(found).toEqual(existing);
-      });
-      const added = result.find((r) => r.name === newOption.name);
-      expect(added).toBeDefined();
-      expect(added?.color).toEqual(newOption.color);
-      expect(added?.description).toEqual(newOption.description);
-      expect(added?.id).toBeDefined();
-
-      await repository.updateStoryList(testProject, existingStories);
-    });
-  });
-
-  describe('getProject', () => {
-    it('should retrieve project details', async () => {
-      const project = await repository.getProject(projectId);
-      expect(project).toEqual({
-        id: 'PVT_kwHOAGJHa84AFhgF',
-        url: 'https://github.com/users/HiromiShikata/projects/49',
-        databaseId: 1447941,
-        name: 'V2 project on owner for testing',
-        nextActionDate: {
-          fieldId: 'PVTF_lAHOAGJHa84AFhgFzgVlnK4',
-          name: 'NextActionDate',
-        },
-        nextActionHour: null,
-        remainingEstimationMinutes: null,
-        story: {
-          fieldId: 'PVTSSF_lAHOAGJHa84AFhgFzg1oBms',
-          databaseId: 224921195,
-          name: 'Story',
-          stories: [
-            {
-              color: 'GRAY',
-              description: '',
-              id: 'af410dae',
-              name: 'story1',
-            },
-            {
-              color: 'GRAY',
-              description: '',
-              id: '696ccdef',
-              name: 'Workflow Management',
-            },
-            {
-              color: 'GRAY',
-              description: '',
-              id: '4fa21881',
-              name: 'test',
-            },
-          ],
-          workflowManagementStory: {
-            color: 'GRAY',
-            description: '',
-            id: '696ccdef',
-            name: 'Workflow Management',
-          },
-        },
-        completionDate50PercentConfidence: null,
-        dependedIssueUrlSeparatedByComma: null,
-        agent: null,
-
-        status: {
-          fieldId: 'PVTSSF_lAHOAGJHa84AFhgFzgDLt0c',
-          name: 'Status',
-          statuses: [
-            {
-              color: 'GRAY',
-              description: '',
-              id: '42fe08b2',
-              name: 'Todo',
-            },
-            {
-              color: 'GRAY',
-              description: '',
-              id: 'd8072cc4',
-              name: 'Awaiting workspace',
-            },
-            {
-              color: 'GRAY',
-              description: '',
-              id: 'fe181007',
-              name: 'Preparation',
-            },
-            {
-              color: 'GRAY',
-              description: '',
-              id: 'aa14ce66',
-              name: 'Awaiting quality check',
-            },
-            {
-              color: 'GRAY',
-              description: '',
-              id: 'bebc3184',
-              name: 'In Progress',
-            },
-            {
-              color: 'GRAY',
-              description: '',
-              id: '88c0a10e',
-              name: 'Done',
-            },
-          ],
-        },
-      });
-    });
-
-    it('should return the same project from the REST read as from the GraphQL cold start read', async () => {
-      const fromGraphql = await repository.getProject(projectId);
-      const fromRest = await repository.getProject(projectId);
-
-      expect(fromRest).toEqual(fromGraphql);
-    }, 60000);
-  });
-});