Adm 793 [frontend] Reduce the time of timeout to 10 minutes

frontend/__tests__/client/PipelineToolClient.test.ts

@@ -21,7 +21,7 @@ afterAll(() => server.close());
 describe('PipelineToolClient', () => {
   describe('verify pipelineTool request', () => {
     it('should isPipelineVerified is true when pipelineTool verify response status 204', async () => {
-      const result = await pipelineToolClient.verify(MOCK_PIPELINE_VERIFY_REQUEST_PARAMS);
+      const result = await pipelineToolClient.verify(MOCK_PIPELINE_VERIFY_REQUEST_PARAMS, jest.fn(), jest.fn());
 
       expect(result.code).toEqual(HttpStatusCode.NoContent);
     });
@@ -45,7 +45,7 @@ describe('PipelineToolClient', () => {
       it.each(errorCases)('should return error code when verify endponint returns error', async ({ code }) => {
         server.use(rest.post(MOCK_PIPELINE_VERIFY_URL, (req, res, ctx) => res(ctx.status(code))));
 
-        const result = await pipelineToolClient.verify(MOCK_PIPELINE_VERIFY_REQUEST_PARAMS);
+        const result = await pipelineToolClient.verify(MOCK_PIPELINE_VERIFY_REQUEST_PARAMS, jest.fn(), jest.fn());
 
         expect(result.code).toEqual(code);
       });

frontend/__tests__/client/SourceControlClient.test.ts

@@ -15,7 +15,11 @@ describe('verify sourceControl request', () => {
   afterAll(() => server.close());
 
   it('should return isSourceControlVerify true when sourceControl verify response status is 204', async () => {
-    const result = await sourceControlClient.verifyToken(MOCK_SOURCE_CONTROL_VERIFY_REQUEST_PARAMS);
+    const result = await sourceControlClient.verifyToken(
+      MOCK_SOURCE_CONTROL_VERIFY_REQUEST_PARAMS,
+      jest.fn(),
+      jest.fn(),
+    );
 
     expect(result.code).toEqual(204);
   });
@@ -27,7 +31,7 @@ describe('verify sourceControl request', () => {
       ),
     );
 
-    sourceControlClient.verifyToken(MOCK_SOURCE_CONTROL_VERIFY_REQUEST_PARAMS).catch((e) => {
+    sourceControlClient.verifyToken(MOCK_SOURCE_CONTROL_VERIFY_REQUEST_PARAMS, jest.fn(), jest.fn()).catch((e) => {
       expect(e).toBeInstanceOf(Error);
       expect((e as Error).message).toMatch(VERIFY_ERROR_MESSAGE.BAD_REQUEST);
     });
@@ -40,7 +44,7 @@ describe('verify sourceControl request', () => {
       ),
     );
 
-    sourceControlClient.verifyToken(MOCK_SOURCE_CONTROL_VERIFY_REQUEST_PARAMS).catch((e) => {
+    sourceControlClient.verifyToken(MOCK_SOURCE_CONTROL_VERIFY_REQUEST_PARAMS, jest.fn(), jest.fn()).catch((e) => {
       expect(e).toBeInstanceOf(Error);
       expect((e as Error).message).toMatch(VERIFY_ERROR_MESSAGE.NOT_FOUND);
     });
@@ -58,7 +62,7 @@ describe('verify sourceControl request', () => {
       ),
     );
 
-    sourceControlClient.verifyToken(MOCK_SOURCE_CONTROL_VERIFY_REQUEST_PARAMS).catch((e) => {
+    sourceControlClient.verifyToken(MOCK_SOURCE_CONTROL_VERIFY_REQUEST_PARAMS, jest.fn(), jest.fn()).catch((e) => {
       expect(e).toBeInstanceOf(Error);
       expect((e as Error).message).toMatch(VERIFY_ERROR_MESSAGE.INTERNAL_SERVER_ERROR);
     });

frontend/__tests__/containers/ConfigStep/ConfigButtonGroup.test.tsx

@@ -0,0 +1,28 @@
+import { ConfigButtonGrop } from '@src/containers/ConfigStep/ConfigButton';
+import { render, screen } from '@testing-library/react';
+import React from 'react';
+
+describe('ConfigButtonGroup', () => {
+  const setup = (isVerified: boolean, isLoading: boolean, isHBTimeOut: boolean, isDisableVerifyButton: boolean) => {
+    return render(
+      <ConfigButtonGrop
+        isHBTimeOut={isHBTimeOut}
+        isVerified={isVerified}
+        isLoading={isLoading}
+        isDisableVerifyButton={isDisableVerifyButton}
+      />,
+    );
+  };
+
+  it('should render a disabled VerifyButton with "Verified" text when isVerified is true and isLoading is false', () => {
+    setup(true, false, false, false); // Use a different moduleType for clarity
+    expect(screen.getByText('Verified')).toBeInTheDocument();
+    expect(screen.getByText('Reset')).toBeInTheDocument();
+    expect(screen.getByText('Verified')).toBeDisabled();
+  });
+  it('should render a VerifyButton with "Reverify" text when isHBTimeOut is true', () => {
+    setup(false, false, true, false); // Use a different moduleType for clarity
+    expect(screen.getByText('Reverify')).toBeInTheDocument();
+    expect(screen.getByText('Reverify')).toHaveAttribute('type', 'submit');
+  });
+});

frontend/__tests__/containers/ConfigStep/TimeoutAlet.test.tsx

@@ -0,0 +1,48 @@
+import { TimeoutAlert } from '@src/containers/ConfigStep/TimeoutAlert';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import React from 'react';
+
+describe('TimeoutAlert', () => {
+  const setIsShowAlert = jest.fn();
+  const setup = (
+    setIsShowAlert: (value: boolean) => void,
+    isShowAlert: boolean,
+    isHBTimeOut: boolean,
+    moduleType: string,
+  ) => {
+    return render(
+      <TimeoutAlert
+        setIsShowAlert={setIsShowAlert}
+        isShowAlert={isShowAlert}
+        isHBTimeOut={isHBTimeOut}
+        moduleType={moduleType}
+      />,
+    );
+  };
+
+  it('should render the correct message when given the moduleType', () => {
+    setup(setIsShowAlert, true, true, 'Board'); // Use a different moduleType for clarity
+    const message = screen.getByText('Board'); // Use a regex for flexibility
+    expect(message).toBeInTheDocument();
+  });
+  it('should not render the alert when isHBTimeOut or isShowAlert is false', () => {
+    setup(setIsShowAlert, false, true, 'Board');
+    expect(screen.queryByText('Board')).not.toBeInTheDocument();
+
+    setup(setIsShowAlert, true, false, 'Board');
+    expect(screen.queryByText('Board')).not.toBeInTheDocument();
+  });
+
+  it('should call setIsShowAlert with false and hides the alert when click the close icon', async () => {
+    setup(setIsShowAlert, true, true, 'any'); // Ensure alert is visible
+    const closeIcon = screen.getByTestId('CloseIcon');
+    act(() => {
+      userEvent.click(closeIcon);
+    });
+    await waitFor(() => {
+      expect(setIsShowAlert).toHaveBeenCalledTimes(1);
+      expect(setIsShowAlert).toHaveBeenCalledWith(false);
+    });
+  });
+});

frontend/__tests__/fixtures.ts

@@ -747,6 +747,9 @@ export const CYCLE_TIME_SETTINGS_SECTION = 'Cycle time settings section';
 export const REAL_DONE_SETTING_SECTION = 'Real done setting section';
 export const SELECT_CONSIDER_AS_DONE_MESSAGE = 'Must select which you want to consider as Done';
 export const MOCK_SOURCE_CONTROL_VERIFY_ERROR_CASE_TEXT = 'Token is incorrect!';
+export const MOCK_PIPELINE_VERIFY_UNAUTHORIZED_TEXT = 'Token is incorrect!';
+export const MOCK_PIPELINE_VERIFY_FORBIDDEN_ERROR_TEXT =
+  'Forbidden request, please change your token with correct access permission.';
 
 export const FAKE_TOKEN = 'fake-token';
 

frontend/__tests__/hooks/useVerifyBoardEffect.test.tsx

@@ -1,11 +1,15 @@
 import { useVerifyBoardEffect, useVerifyBoardStateInterface } from '@src/hooks/useVerifyBoardEffect';
-import { MOCK_BOARD_URL_FOR_JIRA, FAKE_TOKEN } from '@test/fixtures';
 import { act, renderHook, waitFor } from '@testing-library/react';
-import { setupServer } from 'msw/node';
+import { FAKE_TOKEN } from '@test/fixtures';
 import { HttpStatusCode } from 'axios';
 
+import { InternalServerException } from '@src/exceptions/InternalServerException';
+import { UnauthorizedException } from '@src/exceptions/UnauthorizedException';
+import { NotFoundException } from '@src/exceptions/NotFoundException';
+import { TimeoutException } from '@src/exceptions/TimeoutException';
+import { HEARTBEAT_EXCEPTION_CODE } from '@src/constants/resources';
+import { boardClient } from '@src/clients/board/BoardClient';
 import { BOARD_TYPES } from '@test/fixtures';
-import { rest } from 'msw';
 
 const mockDispatch = jest.fn();
 jest.mock('react-redux', () => ({
@@ -18,8 +22,6 @@ jest.mock('@src/hooks/useAppDispatch', () => ({
   useAppDispatch: jest.fn(() => jest.fn()),
 }));
 
-const server = setupServer();
-
 const updateFields = (result: { current: useVerifyBoardStateInterface }) => {
   result.current.updateField('Board Id', '1');
   result.current.updateField('Email', 'fake@qq.com');
@@ -28,10 +30,8 @@ const updateFields = (result: { current: useVerifyBoardStateInterface }) => {
 };
 
 describe('use verify board state', () => {
-  beforeAll(() => server.listen());
   afterAll(() => {
     jest.clearAllMocks();
-    server.close();
   });
   it('should got initial data state when hook render given none input', async () => {
     const { result } = renderHook(() => useVerifyBoardEffect());
@@ -41,16 +41,13 @@ describe('use verify board state', () => {
   });
 
   it('should got email and token fields error message when call verify function given a invalid token', async () => {
-    server.use(
-      rest.post(MOCK_BOARD_URL_FOR_JIRA, (_, res, ctx) => {
-        return res(ctx.status(HttpStatusCode.Unauthorized));
-      }),
-    );
+    const mockedError = new UnauthorizedException('', HttpStatusCode.Unauthorized, '');
+    boardClient.getVerifyBoard = jest.fn().mockImplementation(() => Promise.reject(mockedError));
 
     const { result } = renderHook(() => useVerifyBoardEffect());
-    await act(() => {
-      updateFields(result);
-      result.current.verifyJira();
+    await act(async () => {
+      await updateFields(result);
+      await result.current.verifyJira();
     });
 
     const emailFiled = result.current.fields.find((field) => field.key === 'Email');
@@ -61,22 +58,34 @@ describe('use verify board state', () => {
     );
   });
 
-  it('when call verify function given a invalid site then should got site field error message', async () => {
-    server.use(
-      rest.post(MOCK_BOARD_URL_FOR_JIRA, (_, res, ctx) => {
-        return res(
-          ctx.status(HttpStatusCode.NotFound),
-          ctx.json({
-            message: 'site is incorrect',
-          }),
-        );
-      }),
-    );
+  it('should clear email validatedError when updateField by Email', async () => {
+    const mockedError = new UnauthorizedException('', HttpStatusCode.Unauthorized, '');
+    boardClient.getVerifyBoard = jest.fn().mockImplementation(() => Promise.reject(mockedError));
 
     const { result } = renderHook(() => useVerifyBoardEffect());
-    await act(() => {
-      updateFields(result);
-      result.current.verifyJira();
+    await act(async () => {
+      await updateFields(result);
+      await result.current.verifyJira();
+    });
+
+    const emailFiled = result.current.fields.find((field) => field.key === 'Email');
+    expect(emailFiled?.verifiedError).toBe('Email is incorrect!');
+
+    await act(async () => {
+      await result.current.updateField('Email', 'fake@qq.com');
+    });
+    const emailText = result.current.fields.find((field) => field.key === 'Email');
+    expect(emailText?.verifiedError).toBe('');
+  });
+
+  it('should got site field error message when call verify function given a invalid site', async () => {
+    const mockedError = new NotFoundException('site is incorrect', HttpStatusCode.NotFound, 'site is incorrect');
+    boardClient.getVerifyBoard = jest.fn().mockImplementation(() => Promise.reject(mockedError));
+
+    const { result } = renderHook(() => useVerifyBoardEffect());
+    await act(async () => {
+      await updateFields(result);
+      await result.current.verifyJira();
     });
 
     await waitFor(() => {
@@ -87,16 +96,8 @@ describe('use verify board state', () => {
   });
 
   it('should got board id field error message when call verify function given a invalid board id', async () => {
-    server.use(
-      rest.post(MOCK_BOARD_URL_FOR_JIRA, (_, res, ctx) => {
-        return res(
-          ctx.status(HttpStatusCode.NotFound),
-          ctx.json({
-            message: 'boardId is incorrect',
-          }),
-        );
-      }),
-    );
+    const mockedError = new NotFoundException('boardId is incorrect', HttpStatusCode.NotFound, 'boardId is incorrect');
+    boardClient.getVerifyBoard = jest.fn().mockImplementation(() => Promise.reject(mockedError));
 
     const { result } = renderHook(() => useVerifyBoardEffect());
     await act(() => {
@@ -111,28 +112,22 @@ describe('use verify board state', () => {
   });
 
   it('should got token fields error message when call verify function given a unknown error', async () => {
-    server.use(
-      rest.post(MOCK_BOARD_URL_FOR_JIRA, (_, res, ctx) => {
-        return res(ctx.status(HttpStatusCode.ServiceUnavailable));
-      }),
-    );
+    const mockedError = new InternalServerException('', HttpStatusCode.ServiceUnavailable, '');
+    boardClient.getVerifyBoard = jest.fn().mockImplementation(() => Promise.reject(mockedError));
 
     const { result } = renderHook(() => useVerifyBoardEffect());
-    await act(() => {
-      updateFields(result);
-      result.current.verifyJira();
+    await act(async () => {
+      await updateFields(result);
+      await result.current.verifyJira();
     });
 
     const tokenField = result.current.fields.find((field) => field.key === 'Token');
     expect(tokenField?.verifiedError).toBe('Unknown error');
   });
 
   it('should clear all verified error messages when update a verified error field', async () => {
-    server.use(
-      rest.post(MOCK_BOARD_URL_FOR_JIRA, (_, res, ctx) => {
-        return res(ctx.status(HttpStatusCode.Unauthorized));
-      }),
-    );
+    const mockedError = new UnauthorizedException('', HttpStatusCode.Unauthorized, '');
+    boardClient.getVerifyBoard = jest.fn().mockImplementation(() => Promise.reject(mockedError));
 
     const { result } = renderHook(() => useVerifyBoardEffect());
     await act(() => {
@@ -148,4 +143,19 @@ describe('use verify board state', () => {
     expect(emailFiled?.verifiedError).toBe('');
     expect(tokenField?.verifiedError).toBe('');
   });
+
+  it('should set timeout is true when getVerifyBoard api is timeout', async () => {
+    const mockedError = new TimeoutException('', HEARTBEAT_EXCEPTION_CODE.TIMEOUT);
+    boardClient.getVerifyBoard = jest.fn().mockImplementation(() => Promise.reject(mockedError));
+
+    const { result } = renderHook(() => useVerifyBoardEffect());
+    await act(() => {
+      result.current.verifyJira();
+    });
+
+    await waitFor(() => {
+      const isHBTimeOut = result.current.isHBTimeOut;
+      expect(isHBTimeOut).toBe(true);
+    });
+  });
 });