admin/twenty
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Fix tests and linter

Browse Source
This commit is contained in:
Charles Bochet
2024-03-15 19:14:57 +01:00
parent 2c09096edd
commit 1cc8edd016
4 changed files with 0 additions and 208 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
packages/twenty-front/src/modules/activities/emails/hooks/__tests__/useEmailThread.test.ts
View File

@ -1,38 +0,0 @@
import { act, renderHook } from '@testing-library/react';
import { useEmailThread } from '../useEmailThread';
const mockSetViewableEmailThreadId = jest.fn();
const mockUseOpenEmailThreadRightDrawer = jest.fn();
jest.mock('recoil', () => ({
useSetRecoilState: () => mockSetViewableEmailThreadId,
}));
jest.mock(
'@/activities/emails/right-drawer/hooks/useOpenEmailThreadRightDrawer',
() => ({
useOpenEmailThreadRightDrawer: () => mockUseOpenEmailThreadRightDrawer,
}),
);
jest.mock('@/activities/emails/state/viewableEmailThreadIdState', () => ({
viewableEmailThreadIdState: () => 'mockViewableEmailThreadIdState',
}));
describe('useEmailThread hook', () => {
beforeEach(() => {
jest.clearAllMocks();
});
it('openEmailThread function', () => {
const { result } = renderHook(() => useEmailThread());
act(() => {
result.current.openEmailThread('mockThreadId');
});
expect(mockSetViewableEmailThreadId).toHaveBeenCalledWith('mockThreadId');
expect(mockUseOpenEmailThreadRightDrawer).toHaveBeenCalled();
});
});

38
packages/twenty-front/src/modules/activities/hooks/__tests__/useActivityById.test.ts
View File

@ -1,38 +0,0 @@
import { renderHook } from '@testing-library/react';
import { RecoilRoot } from 'recoil';
import { useActivityById } from '../useActivityById';
jest.mock('@/object-record/hooks/useFindOneRecord', () => ({
useFindOneRecord: jest.fn(() => ({
record: {
activity: {
id: 'test-activity-id',
name: 'Test Activity',
description: 'This is a test activity',
},
},
loading: false,
})),
}));
describe('useActivityById', () => {
it('fetches activity by id and returns the activity and loading state', async () => {
const activityId = 'test-activity-id';
const { result } = renderHook(() => useActivityById({ activityId }), {
wrapper: RecoilRoot,
});
expect(result.current.loading).toBe(false);
expect(result.current.activity).toEqual({
activity: {
id: 'test-activity-id',
name: 'Test Activity',
description: 'This is a test activity',
},
activityTargets: [],
comments: [],
});
});
});

47
packages/twenty-front/src/modules/activities/tasks/hooks/__tests__/useCompleteTask.test.ts
View File

@ -1,47 +0,0 @@
import { renderHook } from '@testing-library/react';
import { useCompleteTask } from '@/activities/tasks/hooks/useCompleteTask';
const mockUpdateOneRecord = jest.fn();
jest.mock('@/object-record/hooks/useUpdateOneRecord', () => ({
useUpdateOneRecord: () => ({
updateOneRecord: mockUpdateOneRecord,
}),
}));
describe('useCompleteTask', () => {
it('should complete the task when called with true', async () => {
const taskId = 'test-task-id';
const { result } = renderHook(() =>
useCompleteTask({ id: taskId, completedAt: null }),
);
const { completeTask } = result.current;
completeTask(true);
expect(mockUpdateOneRecord).toHaveBeenCalledWith({
idToUpdate: taskId,
updateOneRecordInput: {
completedAt: expect.any(String),
},
});
});
it('should uncomplete the task when called with false', async () => {
const taskId = 'test-task-id';
const { result } = renderHook(() =>
useCompleteTask({ id: taskId, completedAt: '2021-01-01T00:00:00' }),
);
const { completeTask } = result.current;
completeTask(false);
expect(mockUpdateOneRecord).toHaveBeenCalledWith({
idToUpdate: taskId,
updateOneRecordInput: {
completedAt: null,
},
});
});
});

85
packages/twenty-front/src/modules/activities/timeline/hooks/__tests__/useInjectIntoTimelineActivitiesQueries.test.ts
View File

@ -1,85 +0,0 @@
import { renderHook } from '@testing-library/react';
import { useInjectIntoActivitiesQueries } from '@/activities/hooks/useInjectIntoActivitiesQueries';
import { useInjectIntoTimelineActivitiesQueries } from '@/activities/timeline/hooks/useInjectIntoTimelineActivitiesQueries';
import { Activity } from '@/activities/types/Activity';
import { ActivityTarget } from '@/activities/types/ActivityTarget';
import { ActivityTargetableObject } from '@/activities/types/ActivityTargetableEntity';
jest.mock('@/activities/hooks/useInjectIntoActivitiesQueries', () => ({
useInjectIntoActivitiesQueries: jest.fn(() => ({
injectActivitiesQueries: jest.fn(),
})),
}));
describe('useInjectIntoTimelineActivitiesQueries', () => {
beforeEach(() => {
jest.clearAllMocks();
});
it('should inject activities into timeline activities queries correctly', () => {
const mockActivityToInject: Activity = {
id: 'activity1',
createdAt: '2022-01-01T00:00:00',
updatedAt: '2022-01-01T00:00:00',
completedAt: '2022-01-01T00:00:00',
__typename: 'Activity',
reminderAt: '2022-01-01T00:00:00',
dueAt: '2022-01-01T00:00:00',
type: 'Task',
activityTargets: [],
title: 'Activity 1',
body: 'Activity 1 body',
author: {
id: 'author1',
name: {
firstName: 'John',
lastName: 'Doe',
},
avatarUrl: 'https://example.com/avatar1.jpg',
},
authorId: 'author1',
assignee: null,
assigneeId: null,
comments: [],
};
const mockActivityTargetsToInject: ActivityTarget[] = [
{
id: 'target1',
updatedAt: '2022-01-01T00:00:00',
createdAt: '2022-01-01T00:00:00',
activity: {
id: 'activity1',
createdAt: '2022-01-01T00:00:00',
updatedAt: '2022-01-01T00:00:00',
},
},
{
id: 'target2',
updatedAt: '2022-01-01T00:00:00',
createdAt: '2022-01-01T00:00:00',
activity: {
id: 'activity1',
createdAt: '2022-01-01T00:00:00',
updatedAt: '2022-01-01T00:00:00',
},
},
];
const mockTimelineTargetableObject: ActivityTargetableObject = {
id: 'timelineTarget1',
targetObjectNameSingular: 'Timeline',
};
const { result } = renderHook(() =>
useInjectIntoTimelineActivitiesQueries(),
);
result.current.injectIntoTimelineActivitiesQueries({
activityToInject: mockActivityToInject,
activityTargetsToInject: mockActivityTargetsToInject,
timelineTargetableObject: mockTimelineTargetableObject,
});
expect(useInjectIntoActivitiesQueries).toHaveBeenCalledTimes(1);
});
});