Skip to content

The open alternative to Salesforce, designed for AI.

3.9 KB
Raw Blame
import { type MockedResponse } from '@apollo/client/testing';
import { act, renderHook } from '@testing-library/react';

import { createOneActivityOperationSignatureFactory } from '@/activities/graphql/operation-signatures/factories/createOneActivityOperationSignatureFactory';
import { useCreateActivityInDB } from '@/activities/hooks/useCreateActivityInDB';
import { type Task } from '@/activities/types/Task';
import { getObjectMorphJunctionConfig } from '@/object-record/record-field/ui/utils/junction/getObjectMorphJunctionConfig';
import { CoreObjectNameSingular } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
import { generateCreateOneRecordMutation } from '@/object-metadata/utils/generateCreateOneRecordMutation';
import { getRecordFromRecordNode } from '@/object-record/cache/utils/getRecordFromRecordNode';
import { recordStoreFamilyState } from '@/object-record/record-store/states/recordStoreFamilyState';
import { jotaiStore } from '@/ui/utilities/state/jotai/jotaiStore';
import { getJestMetadataAndApolloMocksWrapper } from '~/testing/jest/getJestMetadataAndApolloMocksWrapper';
import { mockedTaskRecords } from '~/testing/mock-data/generated/data/tasks/mock-tasks-data';
import { getTestEnrichedObjectMetadataItemsMock } from '~/testing/utils/getTestEnrichedObjectMetadataItemsMock';
import { getMockObjectMetadataItemOrThrow } from '~/testing/utils/getMockObjectMetadataItemOrThrow';

const mockedTasks = mockedTaskRecords.map((record) =>
  getRecordFromRecordNode<Task>({ recordNode: record }),
);

const mockedDate = '2024-03-15T12:00:00.000Z';
const toISOStringMock = jest.fn(() => mockedDate);
global.Date.prototype.toISOString = toISOStringMock;

const { id, title, status, dueAt } = mockedTasks[0];
const bodyV2 = {
  markdown: null,
  tiptap:
    '{"type":"doc","attrs":{"schemaVersion":1},"content":[{"type":"paragraph","content":[{"type":"text","text":"Arrange a follow-up call"}]}]}',
};
const mockedActivity = {
  id,
  title,
  bodyV2,
  status,
  dueAt,
  updatedAt: mockedDate,
};

const taskMetadataItem = getMockObjectMetadataItemOrThrow('task');
const objectMetadataItems = getTestEnrichedObjectMetadataItemsMock();
const activityTargetFieldName = getObjectMorphJunctionConfig({
  objectMetadata: taskMetadataItem,
  objectMetadataItems,
})?.junctionField.name;

if (!isDefined(activityTargetFieldName)) {
  throw new Error('Task target junction metadata is missing');
}

const operationSignature = createOneActivityOperationSignatureFactory({
  objectNameSingular: CoreObjectNameSingular.Task,
});

const createOneTaskMutation = generateCreateOneRecordMutation({
  objectMetadataItem: taskMetadataItem,
  objectMetadataItems,
  recordGqlFields: operationSignature.fields,
  objectPermissionsByObjectMetadataId: {},
});

const mockResult = jest.fn(() => ({
  data: {
    createTask: {
      ...mockedActivity,
      __typename: 'Activity',
      assigneeId: '',
      authorId: '1',
      reminderAt: null,
      createdAt: mockedDate,
    },
  },
}));

const mocks: MockedResponse[] = [
  {
    request: {
      query: createOneTaskMutation,
      variables: {
        input: {
          ...mockedActivity,
          bodyV2,
        },
      },
    },
    result: mockResult,
  },
];

const Wrapper = getJestMetadataAndApolloMocksWrapper({
  apolloMocks: mocks,
});

describe('useCreateActivityInDB', () => {
  it('Should create activity in DB', async () => {
    const { result } = renderHook(
      () =>
        useCreateActivityInDB({
          activityObjectNameSingular: CoreObjectNameSingular.Task,
        }),
      {
        wrapper: Wrapper,
      },
    );

    await act(async () => {
      await result.current.createActivityInDB({
        ...mockedActivity,
      });
    });

    expect(mockResult).toHaveBeenCalled();
    expect(jotaiStore.get(recordStoreFamilyState.atomFamily(id))).toMatchObject(
      {
        [activityTargetFieldName]: [],
      },
    );
  });
});