Merge branch 'main' into feature/process-group-name-parameter

Author: anatolyshipitz

workers/main/src/activities/weeklyFinancialReports/fetchFinancialAppData.test.ts

@@ -0,0 +1,195 @@
+import type { Connection } from 'mongoose';
+import { afterEach, beforeEach, describe, expect, it, Mock, vi } from 'vitest';
+
+import { AppError } from '../../common/errors';
+import * as fileUtils from '../../common/fileUtils';
+import * as mongoPoolModule from '../../common/MongoPool';
+import type { TargetUnit } from '../../common/types';
+import type { Employee, Project } from '../../services/FinApp';
+import type { IFinAppRepository } from '../../services/FinApp';
+import * as finAppService from '../../services/FinApp';
+import { fetchFinancialAppData } from './fetchFinancialAppData';
+
+type MongoPoolMock = {
+  connect: () => Promise<Connection>;
+  disconnect: () => Promise<void>;
+  getConnection: () => unknown;
+  connection: null;
+  uri: string;
+};
+
+vi.mock('../../common/fileUtils', () => ({
+  readJsonFile: vi.fn(),
+  writeJsonFile: vi.fn(),
+}));
+vi.mock('../../common/MongoPool', () => ({
+  MongoPool: {
+    getInstance: vi.fn(),
+  },
+}));
+vi.mock('../../services/FinApp', () => ({
+  FinAppRepository: vi.fn(),
+}));
+
+const mockTargetUnits: TargetUnit[] = [
+  {
+    group_id: 1,
+    group_name: 'Group',
+    project_id: 2,
+    project_name: 'Project',
+    user_id: 3,
+    username: 'User',
+    spent_on: '2024-06-01',
+    total_hours: 8,
+  },
+];
+const mockEmployees: Employee[] = [
+  { redmine_id: 3, history: { rate: { '2024-01-01': 100 } } },
+];
+const mockProjects: Project[] = [
+  {
+    redmine_id: 2,
+    quick_books_id: 10,
+    history: { rate: { '2024-01-01': 200 } },
+  },
+];
+
+function createRepoInstance(
+  overrides: Partial<IFinAppRepository> = {},
+): IFinAppRepository {
+  return {
+    getEmployeesByRedmineIds: vi.fn().mockResolvedValue(mockEmployees),
+    getProjectsByRedmineIds: vi.fn().mockResolvedValue(mockProjects),
+    ...overrides,
+  };
+}
+
+function createMongoPoolInstance(
+  connectImpl?: () => Promise<Connection>,
+  disconnectImpl?: () => Promise<void>,
+): MongoPoolMock {
+  return {
+    connect: connectImpl || vi.fn().mockResolvedValue({} as Connection),
+    disconnect: disconnectImpl || vi.fn().mockResolvedValue(undefined),
+    getConnection: vi.fn(),
+    connection: null,
+    uri: '',
+  };
+}
+
+describe('getFinAppData', () => {
+  let readJsonFile: Mock;
+  let writeJsonFile: Mock;
+  let connect: Mock;
+  let disconnect: Mock;
+  let FinAppRepository: Mock;
+  let dateSpy: ReturnType<typeof vi.spyOn>;
+  let repoInstance: IFinAppRepository;
+  let mongoPoolInstance: MongoPoolMock;
+
+  const fileLink = 'input.json';
+  const expectedFilename =
+    'data/weeklyFinancialReportsWorkflow/getFinAppData/data-123.json';
+
+  function setupSuccessMocks() {
+    readJsonFile.mockResolvedValue(mockTargetUnits);
+    writeJsonFile.mockResolvedValue(undefined);
+    (repoInstance.getEmployeesByRedmineIds as Mock).mockResolvedValue(
+      mockEmployees,
+    );
+    (repoInstance.getProjectsByRedmineIds as Mock).mockResolvedValue(
+      mockProjects,
+    );
+  }
+
+  async function expectAppError(promise: Promise<unknown>, msg: string) {
+    await expect(promise).rejects.toThrow(AppError);
+    await expect(promise).rejects.toThrow(msg);
+    expect(() => mongoPoolInstance.disconnect()).not.toThrow();
+  }
+
+  beforeEach(() => {
+    dateSpy = vi.spyOn(Date, 'now').mockReturnValue(123);
+    readJsonFile = vi.mocked(fileUtils.readJsonFile);
+    writeJsonFile = vi.mocked(fileUtils.writeJsonFile);
+    FinAppRepository = vi.mocked(finAppService.FinAppRepository);
+
+    repoInstance = createRepoInstance();
+    FinAppRepository.mockImplementation(() => repoInstance);
+
+    connect = vi.fn().mockResolvedValue(undefined);
+    disconnect = vi.fn().mockResolvedValue(undefined);
+    mongoPoolInstance = createMongoPoolInstance(connect, disconnect);
+    (mongoPoolModule.MongoPool.getInstance as Mock).mockReturnValue(
+      mongoPoolInstance as unknown as mongoPoolModule.MongoPool,
+    );
+  });
+
+  afterEach(() => {
+    dateSpy.mockRestore();
+    vi.clearAllMocks();
+  });
+
+  describe('success cases', () => {
+    it('returns fileLink when successful', async () => {
+      setupSuccessMocks();
+      const result = await fetchFinancialAppData(fileLink);
+
+      expect(result).toEqual({ fileLink: expectedFilename });
+      expect(() => mongoPoolInstance.connect()).not.toThrow();
+      expect(() => mongoPoolInstance.disconnect()).not.toThrow();
+      expect(readJsonFile).toHaveBeenCalledWith(fileLink);
+      expect(writeJsonFile).toHaveBeenCalledWith(expectedFilename, {
+        employees: mockEmployees,
+        projects: mockProjects,
+      });
+    });
+
+    it('always disconnects the mongo pool', async () => {
+      setupSuccessMocks();
+      await fetchFinancialAppData(fileLink).catch(() => {});
+      expect(() => mongoPoolInstance.disconnect()).not.toThrow();
+    });
+  });
+
+  describe('error cases', () => {
+    it('throws AppError when readJsonFile throws', async () => {
+      readJsonFile.mockRejectedValue(new Error('fail-read'));
+      await expectAppError(
+        fetchFinancialAppData(fileLink),
+        'Failed to get Fin App Data',
+      );
+    });
+
+    it('throws AppError when getEmployees throws', async () => {
+      readJsonFile.mockResolvedValue(mockTargetUnits);
+      (repoInstance.getEmployeesByRedmineIds as Mock).mockRejectedValue(
+        new Error('fail-employees'),
+      );
+      await expectAppError(
+        fetchFinancialAppData(fileLink),
+        'Failed to get Fin App Data',
+      );
+    });
+
+    it('throws AppError when getProjects throws', async () => {
+      readJsonFile.mockResolvedValue(mockTargetUnits);
+      (repoInstance.getProjectsByRedmineIds as Mock).mockRejectedValue(
+        new Error('fail-projects'),
+      );
+      await expectAppError(
+        fetchFinancialAppData(fileLink),
+        'Failed to get Fin App Data',
+      );
+    });
+
+    it('throws AppError when writeJsonFile throws', async () => {
+      readJsonFile.mockResolvedValue(mockTargetUnits);
+      writeJsonFile.mockRejectedValue(new Error('fail-write'));
+      await expectAppError(
+        fetchFinancialAppData(fileLink),
+        'Failed to get Fin App Data',
+      );
+    });
+  });
+});

workers/main/src/activities/weeklyFinancialReports/fetchFinancialAppData.ts

@@ -0,0 +1,44 @@
+import { AppError } from '../../common/errors';
+import { readJsonFile, writeJsonFile } from '../../common/fileUtils';
+import { MongoPool } from '../../common/MongoPool';
+import { TargetUnit } from '../../common/types';
+import { FinAppRepository } from '../../services/FinApp';
+
+interface GetTargetUnitsResult {
+  fileLink: string;
+}
+
+const getUniqueIds = <T, K extends keyof T>(items: T[], key: K): T[K][] => [
+  ...new Set(items.map((item) => item[key])),
+];
+
+export const fetchFinancialAppData = async (
+  fileLink: string,
+): Promise<GetTargetUnitsResult> => {
+  const mongoPool = MongoPool.getInstance();
+  const filename = `data/weeklyFinancialReportsWorkflow/getFinAppData/data-${Date.now()}.json`;
+
+  try {
+    await mongoPool.connect();
+    const repo = new FinAppRepository();
+
+    const targetUnits = await readJsonFile<TargetUnit[]>(fileLink);
+    const employeeIds = getUniqueIds(targetUnits, 'user_id');
+    const projectIds = getUniqueIds(targetUnits, 'project_id');
+
+    const [employees, projects] = await Promise.all([
+      repo.getEmployeesByRedmineIds(employeeIds),
+      repo.getProjectsByRedmineIds(projectIds),
+    ]);
+
+    await writeJsonFile(filename, { employees, projects });
+
+    return { fileLink: filename };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+
+    throw new AppError('Failed to get Fin App Data', message);
+  } finally {
+    await mongoPool.disconnect();
+  }
+};

workers/main/src/activities/weeklyFinancialReports/index.ts

@@ -1 +1,2 @@
+export * from './fetchFinancialAppData';
 export * from './getTargetUnits';

workers/main/src/workflows/weeklyFinancialReports/weeklyFinancialReports.workflow.ts

@@ -5,7 +5,9 @@ import { AppError } from '../../common/errors';
 import { GroupName } from '../../common/types';
 import { GroupNameEnum } from '../../configs/weeklyFinancialReport';
 
-const { getTargetUnits } = proxyActivities<typeof activities>({
+const { getTargetUnits, fetchFinancialAppData } = proxyActivities<
+  typeof activities
+>({
   startToCloseTimeout: '10 minutes',
 });
 
@@ -19,6 +21,7 @@ export async function weeklyFinancialReportsWorkflow(
     );
   }
   const targetUnits = await getTargetUnits(groupName);
+  const finData = await fetchFinancialAppData(targetUnits.fileLink);
 
-  return targetUnits.fileLink;
+  return finData.fileLink;
 }