github-issue-tower-defence-management 1.1.0

package/src/adapter/repositories/LocalStorageCacheRepository.ts

@@ -0,0 +1,53 @@
+import { LocalStorageRepository } from './LocalStorageRepository';
+
+export class LocalStorageCacheRepository {
+  constructor(
+    readonly localStorageRepository: LocalStorageRepository,
+    readonly cachePath = './tmp/cache',
+  ) {}
+
+  getLatest = async (
+    key: string,
+  ): Promise<{
+    value: object;
+    timestamp: Date;
+  } | null> => {
+    const dirPath = `${this.cachePath}/${key}`;
+    const latestFile = this.localStorageRepository
+      .listFiles(dirPath)
+      .sort((a, b) => a.localeCompare(b))
+      .reverse()[0];
+    if (!latestFile) {
+      return null;
+    }
+    const valueStr = this.localStorageRepository.read(
+      `${dirPath}/${latestFile}`,
+    );
+    if (!valueStr) {
+      return null;
+    }
+    let value: unknown;
+    try {
+      value = JSON.parse(valueStr);
+    } catch (e) {
+      return null;
+    }
+    if (typeof value !== 'object' || value === null) {
+      return null;
+    }
+    const timestampStr = latestFile.split('.')[0];
+    return {
+      value,
+      timestamp: new Date(timestampStr),
+    };
+  };
+  set = async <T>(key: string, value: T): Promise<void> => {
+    const dirPath = `${this.cachePath}/${key}`;
+    this.localStorageRepository.mkdir(dirPath);
+    const timestamp = new Date().toISOString();
+    this.localStorageRepository.write(
+      `${dirPath}/${timestamp}.json`,
+      JSON.stringify(value),
+    );
+  };
+}

package/src/adapter/repositories/LocalStorageRepository.integration.test.ts

@@ -0,0 +1,142 @@
+import fs from 'fs';
+import { LocalStorageRepository } from './LocalStorageRepository';
+
+type WriteParams = Parameters<LocalStorageRepository['write']>;
+type ReadParams = Parameters<LocalStorageRepository['read']>;
+type ReadReturn = ReturnType<LocalStorageRepository['read']>;
+type ListFilesParams = Parameters<LocalStorageRepository['listFiles']>;
+type ListFilesReturn = ReturnType<LocalStorageRepository['listFiles']>;
+type MkdirParams = Parameters<LocalStorageRepository['mkdir']>;
+
+describe('LocalStorageRepository', () => {
+  const repository = new LocalStorageRepository();
+
+  describe('write', () => {
+    const testCases: Array<{
+      name: string;
+      params: WriteParams;
+      expected: string;
+    }> = [
+      {
+        name: 'writes content to file',
+        params: ['tmp/test/LocalStorageRepository/file.txt', 'content'],
+        expected: 'content',
+      },
+      {
+        name: 'writes empty string to file',
+        params: ['tmp/test/LocalStorageRepository/fileempty.txt', ''],
+        expected: '',
+      },
+    ];
+
+    testCases.forEach(({ name, params }) => {
+      test(name, () => {
+        if (fs.existsSync(params[0])) {
+          fs.unlinkSync(params[0]);
+        }
+        repository.write(...params);
+        const content = fs.readFileSync(params[0], 'utf8');
+        expect(content).toBe(params[1]);
+      });
+    });
+  });
+
+  describe('read', () => {
+    const testCases: Array<{
+      name: string;
+      params: ReadParams;
+      content: string;
+      expected: ReadReturn;
+    }> = [
+      {
+        name: 'reads content from file',
+        params: ['tmp/test/LocalStorageRepository/file.txt'],
+        content: 'file content',
+        expected: 'file content',
+      },
+      {
+        name: 'reads empty file',
+        params: ['tmp/test/LocalStorageRepository/fileempty.txt'],
+        content: '',
+        expected: '',
+      },
+    ];
+
+    testCases.forEach(({ name, params, content, expected }) => {
+      test(name, () => {
+        if (fs.existsSync(params[0])) {
+          fs.unlinkSync(params[0]);
+        }
+        repository.write(params[0], content);
+        const result = repository.read(...params);
+        expect(result).toBe(expected);
+      });
+    });
+  });
+
+  describe('listFiles', () => {
+    const testCases: Array<{
+      name: string;
+      params: ListFilesParams;
+      readdirSyncReturn: string[];
+      expected: ListFilesReturn;
+    }> = [
+      {
+        name: 'lists files in existing directory',
+        params: ['tmp/test/LocalStorageRepository/exists'],
+        readdirSyncReturn: ['file1.txt', 'file2.txt'],
+        expected: ['file1.txt', 'file2.txt'],
+      },
+      {
+        name: 'returns empty array for non-existing directory',
+        params: ['tmp/test/LocalStorageRepository/nonexistent'],
+        readdirSyncReturn: [],
+        expected: [],
+      },
+    ];
+
+    testCases.forEach(({ name, params, readdirSyncReturn, expected }) => {
+      test(name, () => {
+        if (readdirSyncReturn.length > 0) {
+          if (!fs.existsSync(params[0])) {
+            fs.mkdirSync(params[0], { recursive: true });
+          }
+          readdirSyncReturn.forEach((file) => {
+            fs.writeFileSync(`${params[0]}/${file}`, 'content', 'utf8');
+          });
+        }
+        const result = repository.listFiles(...params);
+        expect(result).toEqual(expected);
+      });
+    });
+  });
+
+  describe('mkdir', () => {
+    const testCases: Array<{
+      name: string;
+      params: MkdirParams;
+      expected: void;
+    }> = [
+      {
+        name: 'creates directory with recursive option',
+        params: ['tmp/test/LocalStorageRepository/newdir'],
+        expected: undefined,
+      },
+      {
+        name: 'creates nested directories',
+        params: ['tmp/test/LocalStorageRepository/nested/newdir'],
+        expected: undefined,
+      },
+    ];
+
+    testCases.forEach(({ name, params }) => {
+      test(name, () => {
+        if (fs.existsSync(params[0])) {
+          fs.rmdirSync(params[0], { recursive: true });
+        }
+        repository.mkdir(...params);
+        expect(fs.existsSync(params[0])).toBe(true);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,161 @@
+import fs from 'fs';
+import { LocalStorageRepository } from './LocalStorageRepository';
+
+type WriteParams = Parameters<LocalStorageRepository['write']>;
+type ReadParams = Parameters<LocalStorageRepository['read']>;
+type ReadReturn = ReturnType<LocalStorageRepository['read']>;
+type ListFilesParams = Parameters<LocalStorageRepository['listFiles']>;
+type ListFilesReturn = ReturnType<LocalStorageRepository['listFiles']>;
+type MkdirParams = Parameters<LocalStorageRepository['mkdir']>;
+
+describe('LocalStorageRepository', () => {
+  let repository: LocalStorageRepository;
+  let mockWriteFileSync: jest.SpyInstance;
+  let mockReadFileSync: jest.SpyInstance;
+  let mockReaddirSync: jest.SpyInstance;
+  let mockMkdirSync: jest.SpyInstance;
+  let mockExistsSync: jest.SpyInstance;
+
+  beforeEach(() => {
+    repository = new LocalStorageRepository();
+    mockWriteFileSync = jest.spyOn(fs, 'writeFileSync').mockImplementation();
+    mockReadFileSync = jest.spyOn(fs, 'readFileSync').mockImplementation();
+    mockReaddirSync = jest.spyOn(fs, 'readdirSync').mockImplementation();
+    mockMkdirSync = jest.spyOn(fs, 'mkdirSync').mockImplementation();
+    mockExistsSync = jest.spyOn(fs, 'existsSync').mockImplementation();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('write', () => {
+    const testCases: Array<{
+      name: string;
+      params: WriteParams;
+      expected: void;
+    }> = [
+      {
+        name: 'writes content to file',
+        params: ['/path/to/file.txt', 'content'],
+        expected: undefined,
+      },
+      {
+        name: 'writes empty string to file',
+        params: ['/path/to/file.txt', ''],
+        expected: undefined,
+      },
+    ];
+
+    testCases.forEach(({ name, params }) => {
+      test(name, () => {
+        repository.write(...params);
+        expect(mockWriteFileSync).toHaveBeenCalledWith(
+          params[0],
+          params[1],
+          'utf8',
+        );
+      });
+    });
+  });
+
+  describe('read', () => {
+    const testCases: Array<{
+      name: string;
+      params: ReadParams;
+      mockReturn: string;
+      expected: ReadReturn;
+    }> = [
+      {
+        name: 'reads content from file',
+        params: ['/path/to/file.txt'],
+        mockReturn: 'file content',
+        expected: 'file content',
+      },
+      {
+        name: 'reads empty file',
+        params: ['/path/to/empty.txt'],
+        mockReturn: '',
+        expected: '',
+      },
+    ];
+
+    testCases.forEach(({ name, params, mockReturn, expected }) => {
+      test(name, () => {
+        mockReadFileSync.mockReturnValue(mockReturn);
+        const result = repository.read(...params);
+        expect(result).toBe(expected);
+        expect(mockReadFileSync).toHaveBeenCalledWith(params[0], 'utf8');
+      });
+    });
+  });
+
+  describe('listFiles', () => {
+    const testCases: Array<{
+      name: string;
+      params: ListFilesParams;
+      existsSyncReturn: boolean;
+      readdirSyncReturn: string[];
+      expected: ListFilesReturn;
+    }> = [
+      {
+        name: 'lists files in existing directory',
+        params: ['/path/to/dir'],
+        existsSyncReturn: true,
+        readdirSyncReturn: ['file1.txt', 'file2.txt'],
+        expected: ['file1.txt', 'file2.txt'],
+      },
+      {
+        name: 'returns empty array for non-existing directory',
+        params: ['/path/to/nonexistent'],
+        existsSyncReturn: false,
+        readdirSyncReturn: [],
+        expected: [],
+      },
+    ];
+
+    testCases.forEach(
+      ({ name, params, existsSyncReturn, readdirSyncReturn, expected }) => {
+        test(name, () => {
+          mockExistsSync.mockReturnValue(existsSyncReturn);
+          mockReaddirSync.mockReturnValue(readdirSyncReturn);
+          const result = repository.listFiles(...params);
+          expect(result).toEqual(expected);
+          if (existsSyncReturn) {
+            expect(mockReaddirSync).toHaveBeenCalledWith(params[0]);
+          } else {
+            expect(mockReaddirSync).not.toHaveBeenCalled();
+          }
+        });
+      },
+    );
+  });
+
+  describe('mkdir', () => {
+    const testCases: Array<{
+      name: string;
+      params: MkdirParams;
+      expected: void;
+    }> = [
+      {
+        name: 'creates directory with recursive option',
+        params: ['/path/to/new/dir'],
+        expected: undefined,
+      },
+      {
+        name: 'creates nested directories',
+        params: ['/deeply/nested/directory/path'],
+        expected: undefined,
+      },
+    ];
+
+    testCases.forEach(({ name, params }) => {
+      test(name, () => {
+        repository.mkdir(...params);
+        expect(mockMkdirSync).toHaveBeenCalledWith(params[0], {
+          recursive: true,
+        });
+      });
+    });
+  });
+});

package/src/adapter/repositories/LocalStorageRepository.ts

@@ -0,0 +1,21 @@
+import fs from 'fs';
+
+export class LocalStorageRepository {
+  write = (path: string, value: string) => {
+    const dirPath = path.split('/').slice(0, -1).join('/');
+    this.mkdir(dirPath);
+    fs.writeFileSync(path, value, 'utf8');
+  };
+  read = (path: string): string | null => {
+    return fs.readFileSync(path, 'utf8');
+  };
+  listFiles = (dirPath: string): string[] => {
+    if (!fs.existsSync(dirPath)) {
+      return [];
+    }
+    return fs.readdirSync(dirPath);
+  };
+  mkdir = (dirPath: string) => {
+    fs.mkdirSync(dirPath, { recursive: true });
+  };
+}

package/src/adapter/repositories/SystemDateRepository.ts

@@ -0,0 +1,20 @@
+import { DateRepository } from '../../domain/usecases/adapter-interfaces/DateRepository';
+
+export class SystemDateRepository implements DateRepository {
+  now = async () => new Date();
+  formatDurationToHHMM = (durationMinutes: number): string => {
+    const hours = Math.floor(durationMinutes / 60);
+    const minutes = Math.floor(durationMinutes % 60);
+    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
+  };
+  formatDateTimeWithDayOfWeek = (date: Date): string => {
+    const dayOfWeek = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][
+      date.getDay()
+    ];
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    return `${date.getFullYear()}/${month}/${day} (${dayOfWeek}) ${hours}:${minutes}`;
+  };
+}

package/src/adapter/repositories/issue/ApiV3CheerioRestIssueRepository.test.ts

@@ -0,0 +1,158 @@
+import { mock } from 'jest-mock-extended';
+import { ApiV3CheerioRestIssueRepository } from './ApiV3CheerioRestIssueRepository';
+import { ApiV3IssueRepository } from './ApiV3IssueRepository';
+import { CheerioIssueRepository } from './CheerioIssueRepository';
+import { RestIssueRepository } from './RestIssueRepository';
+import { GraphqlProjectItemRepository } from './GraphqlProjectItemRepository';
+import { LocalStorageCacheRepository } from '../LocalStorageCacheRepository';
+
+describe('ApiV3CheerioRestIssueRepository', () => {
+  describe('convertProjectItemAndCheerioIssueToIssue', () => {
+    const testCases: {
+      name: string;
+      params: Parameters<
+        ApiV3CheerioRestIssueRepository['convertProjectItemAndCheerioIssueToIssue']
+      >;
+      expected: Awaited<
+        ReturnType<
+          ApiV3CheerioRestIssueRepository['convertProjectItemAndCheerioIssueToIssue']
+        >
+      >;
+    }[] = [
+      {
+        name: 'normal case',
+        params: [
+          {
+            id: 'test-id-1',
+            nameWithOwner: 'HiromiShikata/test-repository',
+            number: 38,
+            title: 'test-title',
+            state: 'OPEN',
+            url: 'https://github.com/HiromiShikata/test-repository/issues/38',
+            body: 'test-body',
+            customFields: [
+              { name: 'nextActionDate', value: '2000-01-01' },
+              { name: 'nextActionHour', value: '1' },
+              { name: 'remainingEstimationMinutes', value: '60' },
+              { name: 'story', value: 'test-story' },
+              { name: 'status', value: 'test-status' },
+            ],
+          },
+          {
+            url: 'https://github.com/HiromiShikata/test-repository/issues/38',
+            title: 'test-title',
+            status: 'test-status',
+            assignees: [],
+            labels: [],
+            project: '',
+            statusTimeline: [],
+            inProgressTimeline: [],
+          },
+        ],
+        expected: {
+          assignees: [],
+          body: 'test-body',
+          estimationMinutes: null,
+          isPr: false,
+          itemId: 'test-id-1',
+          labels: [],
+          nameWithOwner: 'HiromiShikata/test-repository',
+          nextActionDate: new Date('2000-01-01'),
+          nextActionHour: 1,
+          number: 38,
+          org: 'HiromiShikata',
+          repo: 'test-repository',
+          state: 'OPEN',
+          status: 'test-status',
+          story: 'test-story',
+          title: 'test-title',
+          url: 'https://github.com/HiromiShikata/test-repository/issues/38',
+          workingTimeline: [],
+        },
+      },
+    ];
+    test.each(testCases)('%s', async (arg) => {
+      const { repository } = createApiV3CheerioRestIssueRepository();
+      const result = await repository.convertProjectItemAndCheerioIssueToIssue(
+        ...arg.params,
+      );
+      expect(result).toEqual(arg.expected);
+    });
+  });
+  describe('getAllIssuesFromCache', () => {
+    const testCases: {
+      name: string;
+      params: Parameters<
+        ApiV3CheerioRestIssueRepository['getAllIssuesFromCache']
+      >;
+      expected: Awaited<
+        ReturnType<ApiV3CheerioRestIssueRepository['getAllIssuesFromCache']>
+      >;
+    }[] = [
+      {
+        name: 'normal case',
+        params: ['test-key', 1],
+        expected: null,
+      },
+    ];
+    test.each(testCases)('%s', async (arg) => {
+      const { repository, localStorageCacheRepository } =
+        createApiV3CheerioRestIssueRepository();
+      localStorageCacheRepository.getLatest.mockResolvedValue({
+        timestamp: new Date('2000-01-01'),
+        value: [],
+      });
+      const result = await repository.getAllIssuesFromCache(...arg.params);
+      expect(result).toEqual(arg.expected);
+    });
+  });
+  describe('getAllIssues', () => {
+    const testCases: {
+      name: string;
+      params: Parameters<ApiV3CheerioRestIssueRepository['getAllIssues']>;
+      expected: Awaited<
+        ReturnType<ApiV3CheerioRestIssueRepository['getAllIssues']>
+      >;
+    }[] = [
+      {
+        name: 'normal case',
+        params: ['test-project-id', 1],
+        expected: { issues: [], cacheUsed: false },
+      },
+    ];
+    test.each(testCases)('%s', async (arg) => {
+      const {
+        repository,
+        graphqlProjectItemRepository,
+        localStorageCacheRepository,
+      } = createApiV3CheerioRestIssueRepository();
+      graphqlProjectItemRepository.fetchProjectItems.mockResolvedValue([]);
+      localStorageCacheRepository.set.mockResolvedValue();
+      const result = await repository.getAllIssues(...arg.params);
+      expect(result).toEqual(arg.expected);
+    });
+  });
+
+  const createApiV3CheerioRestIssueRepository = () => {
+    const apiV3IssueRepository = mock<ApiV3IssueRepository>();
+    const cheerioIssueRepository = mock<CheerioIssueRepository>();
+    const restIssueRepository = mock<RestIssueRepository>();
+    const graphqlProjectItemRepository = mock<GraphqlProjectItemRepository>();
+    const localStorageCacheRepository = mock<LocalStorageCacheRepository>();
+    const repository = new ApiV3CheerioRestIssueRepository(
+      apiV3IssueRepository,
+      cheerioIssueRepository,
+      restIssueRepository,
+      graphqlProjectItemRepository,
+      localStorageCacheRepository,
+    );
+    return {
+      repository,
+      apiV3IssueRepository,
+      cheerioIssueRepository,
+      restIssueRepository,
+      graphqlProjectItemRepository,
+      localStorageCacheRepository,
+    };
+  };
+});