add tests

Author: etiennejouan

packages/twenty-server/src/modules/contact-creation-manager/services/__tests__/create-company-and-contact.service.spec.ts

@@ -0,0 +1,161 @@
+import { Test, type TestingModule } from '@nestjs/testing';
+
+import { ExceptionHandlerService } from 'src/engine/core-modules/exception-handler/exception-handler.service';
+import { FieldActorSource } from 'src/engine/metadata-modules/field-metadata/composite-types/actor.composite-type';
+import { TwentyORMGlobalManager } from 'src/engine/twenty-orm/twenty-orm-global.manager';
+import { type ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+import { CreateCompanyAndContactService } from 'src/modules/contact-creation-manager/services/create-company-and-contact.service';
+import { CreateCompanyService } from 'src/modules/contact-creation-manager/services/create-company.service';
+import { CreateContactService } from 'src/modules/contact-creation-manager/services/create-contact.service';
+import { type PersonWorkspaceEntity } from 'src/modules/person/standard-objects/person.workspace-entity';
+
+describe('CreateCompanyAndContactService', () => {
+  let service: CreateCompanyAndContactService;
+  let createCompaniesService: CreateCompanyService;
+  let createContactService: CreateContactService;
+
+  const workspaceId = 'workspace-1';
+
+  const mockConnectedAccount = {} as ConnectedAccountWorkspaceEntity;
+
+  beforeEach(async () => {
+    const mockCreateCompaniesService = {
+      createOrRestoreCompanies: jest.fn(),
+    };
+    const mockCreateContactService = {
+      restorePeople: jest.fn(),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        CreateCompanyAndContactService,
+        {
+          provide: CreateCompanyService,
+          useValue: mockCreateCompaniesService,
+        },
+        {
+          provide: CreateContactService,
+          useValue: mockCreateContactService,
+        },
+        {
+          provide: TwentyORMGlobalManager,
+          useValue: {},
+        },
+        {
+          provide: ExceptionHandlerService,
+          useValue: {},
+        },
+      ],
+    }).compile();
+
+    service = module.get<CreateCompanyAndContactService>(
+      CreateCompanyAndContactService,
+    );
+    createContactService =
+      module.get<CreateContactService>(CreateContactService);
+    createCompaniesService =
+      module.get<CreateCompanyService>(CreateCompanyService);
+  });
+
+  describe('restorePeopleAndRestoreOrCreateCompanies - method', () => {
+    it('should restore the soft deleted contact - matching primary email', async () => {
+      await service.restorePeopleAndRestoreOrCreateCompanies(
+        [
+          {
+            id: 'contact-1',
+            emails: {
+              primaryEmail: '[email protected]',
+              additionalEmails: [],
+            },
+            deletedAt: new Date(),
+          } as unknown as PersonWorkspaceEntity,
+        ],
+        [
+          {
+            handle: '[email protected]',
+            displayName: 'Contact 1',
+          },
+        ],
+        workspaceId,
+        FieldActorSource.CALENDAR,
+        mockConnectedAccount,
+      );
+      expect(createContactService.restorePeople).toHaveBeenCalledWith(
+        [
+          {
+            id: 'contact-1',
+            companyId: undefined,
+          },
+        ],
+        workspaceId,
+      );
+      expect(
+        createCompaniesService.createOrRestoreCompanies,
+      ).toHaveBeenCalled();
+    });
+    it('should restore the soft deleted contact - matching primary email', async () => {
+      await service.restorePeopleAndRestoreOrCreateCompanies(
+        [
+          {
+            id: 'contact-1',
+            emails: {
+              primaryEmail: '[email protected]',
+              additionalEmails: [
+                '[email protected]',
+              ],
+            },
+            deletedAt: new Date(),
+          } as unknown as PersonWorkspaceEntity,
+        ],
+        [
+          {
+            handle: '[email protected]',
+            displayName: 'Contact 1',
+          },
+        ],
+        workspaceId,
+        FieldActorSource.CALENDAR,
+        mockConnectedAccount,
+      );
+      expect(createContactService.restorePeople).toHaveBeenCalledWith(
+        [
+          {
+            id: 'contact-1',
+            companyId: undefined,
+          },
+        ],
+        workspaceId,
+      );
+      expect(
+        createCompaniesService.createOrRestoreCompanies,
+      ).toHaveBeenCalled();
+    });
+    it('should not restore any contact', async () => {
+      await service.restorePeopleAndRestoreOrCreateCompanies(
+        [
+          {
+            id: 'contact-1',
+            emails: {
+              primaryEmail: '[email protected]',
+              additionalEmails: [],
+            },
+            deletedAt: new Date(),
+          } as unknown as PersonWorkspaceEntity,
+        ],
+        [
+          {
+            handle: '[email protected]',
+            displayName: 'Contact 1',
+          },
+        ],
+        workspaceId,
+        FieldActorSource.CALENDAR,
+        mockConnectedAccount,
+      );
+      expect(createContactService.restorePeople).not.toHaveBeenCalled();
+      expect(
+        createCompaniesService.createOrRestoreCompanies,
+      ).not.toHaveBeenCalled();
+    });
+  });
+});

packages/twenty-server/src/modules/contact-creation-manager/services/__tests__/create-company.service.spec.ts

@@ -46,6 +46,13 @@ describe('CreateCompanyService', () => {
       provider: ConnectedAccountProvider.GOOGLE,
     },
   };
+  const companyToRestore: CompanyToCreate = {
+    domainName: 'soft-deleted-company.com',
+    createdBySource: FieldActorSource.MANUAL,
+    createdByContext: {
+      provider: ConnectedAccountProvider.GOOGLE,
+    },
+  };
   const inputForCompanyToCreate1 = {
     address: {
       addressCity: undefined,
@@ -89,6 +96,7 @@ describe('CreateCompanyService', () => {
       find: jest.fn(),
       save: jest.fn(),
       maximum: jest.fn().mockResolvedValue(0),
+      updateMany: jest.fn(),
     };
 
     const module: TestingModule = await Test.createTestingModule({
@@ -199,4 +207,44 @@ describe('CreateCompanyService', () => {
       expect(mockCompanyRepository.save).not.toHaveBeenCalled();
     });
   });
+
+  describe('With existing companies and some deleted', () => {
+    beforeEach(() => {
+      mockCompanyRepository.find.mockResolvedValue([
+        {
+          id: 'soft-deleted-company-1',
+          domainName: { primaryLinkUrl: 'https://soft-deleted-company.com' },
+          deletedAt: new Date(),
+        },
+      ]);
+      mockCompanyRepository.save.mockResolvedValue([]);
+      mockCompanyRepository.updateMany.mockResolvedValue({
+        raw: [
+          {
+            id: 'soft-deleted-company-1',
+            domainNamePrimaryLinkUrl: 'https://soft-deleted-company.com',
+          },
+        ],
+      });
+    });
+
+    it('should restore the soft deleted company', async () => {
+      await service.createOrRestoreCompanies([companyToRestore], workspaceId);
+
+      expect(mockCompanyRepository.find).toHaveBeenCalled();
+      expect(mockCompanyRepository.save).toHaveBeenCalledWith([]);
+      expect(mockCompanyRepository.updateMany).toHaveBeenCalledWith(
+        [
+          {
+            criteria: 'soft-deleted-company-1',
+            partialEntity: {
+              deletedAt: null,
+            },
+          },
+        ],
+        undefined,
+        ['domainNamePrimaryLinkUrl', 'id'],
+      );
+    });
+  });
 });

packages/twenty-server/src/modules/contact-creation-manager/services/create-company-and-contact.service.ts

@@ -209,6 +209,8 @@ export class CreateCompanyAndContactService {
       })
       .filter(isDefined);
 
+    if (filteredContactsToRestore.length === 0) return [];
+
     const workDomainNamesToCreate = filteredContactsToRestore
       .filter(
         (participant) =>