Files
cal.diy/packages/app-store/salesforce/lib/CrmService.test.ts
T
Hariom Balhara e3bd90c4f2 fix: Handle calendar-cache with Delegation Credentials
Fixes CAL-5372

# Delegation Credentials with CalendarCache.

Following content is a snapshot of the [internal document](https://calendso.slack.com/docs/T08B8KA2BNF/F08L5JYU3V3)



**Problem-1 :** 

CalendarCache needs SelectedCalendar records to work but SelectedCalendar record is only created when a user connects their calendar and then enables some calendar for conflict checking. Because with Delegation, no manual connection is done by any of the members, we need a way to create SelectedCalendar records automatically.

**Problem-2**

CalendarCache connects to credential(regular credential) which doesn’t exist for Delegation Credential scenario. Also, DelegationCredential is common for all the members(different from Credential which is different for different members) of the organization and we need to identify to which user the CalendarCache belongs.  

**Solution for both problems**
- Create credential records for Delegation Credentials as well - Through Cron(new - we could schedule it every 5mins)
- Now create SelectedCalendar  records for those Credential records -  Through another Cron(new - we could schedule it every 5mins)
- Now CalendarCache records will automatically be created for those SelectedCalendar records -existing cron

## Fixed some Delegation Credentials bugs unrelated to calendar-cache
- If DestinationCalendar wasn't set(which is possible only with Delegation Credentials), then Google Meet wasn't used as a conferencing app - [Added a test]
- If no SelectedCalendar is there but Google Calendar connection exists(possible only with Delegation Credential) then we were not doing conflict checking. It is expected to not do it for Regular Credentials, but for Delegation Credential we must check for conflict in that case too [Added a test]
- Earlier if a user has Regular Credential as well as Delegation Credential for the same external id which is the member email(say [email protected]) then availability were retrieved twice because we weren't deduplicating credentials as it wasn't a trivial thing to do. Now that is being done.


**Env Variables:**
Note this PR doesn't introduce any new env variable. The existing env variable has been added to .env.example. But if this env variable isn't already set, it must be set.

`CALCOM_SERVICE_ACCOUNT_ENCRYPTION_KEY={SAME_AS_SET_FOR_V2_API}`

**Deployment Plan:**
1. Add Observability for SelectedCalendar when _error_ field is set
2. Follow https://github.com/calcom/cal.com/blob/calendar-cache-dwd-support/apps/web/app/(use-page-wrapper)/settings/(settings-layout)/organizations/delegation-credential/delegation-credential.md#setting-up-delegation-credential-for-google-calendar-api to enable Delegation Credential for i.cal.com
3. Note that to be able to see the option to enable Delegation Credential for an organization, you need to enable `teamFeature` and `feature` for `delegation-credential`

## Automation Tests
- Introduced tests for calendar-cache.repository.ts
   - Tests all methods of the repository
- Added more tests for handleNewBooking/delegation-credential flow.
   - Added test to verify the bug fix when no DestinationCalendar exists and Google Meet should be used still 
- Added more tests for Google Calendar/CalendarService targeting DelegationCredential
- Added more tests for getCalendarsEvents. 
    - To test the new logic of calling getAvailability still if there are no selectedCalendars in case of Delegation Credential
    - Also introduced tests for `getAvailabitlityWithTimezones` which was an existing function but now has some new changes.
- Added tests for deduplication logic in CalendarManager.ts

## How to Test
Enable Calendar Cache and Delegation Credential feature for acme org through `features` and `teamFeatures` tables.
- Enable Delegation Credential for acme org
- Enable atleast 1 calendar for conflict checking for one of the users(say owner1)
- Ensure GOOGLE_WEBHOOK_TOKEN is set in .env file
- Ensure GOOGLE_WEBHOOK_URL is set to ngrok url of webapp in .env file
- Hit cron endpoint `curl http://localhost:3000/api/calendar-cache/cron\?apiKey\={API_KEY}` that would cache the freebusy result for the selected calendars



Followup 
- https://github.com/calcom/cal.com/pull/20698
- https://github.com/calcom/cal.com/pull/18619/files#r2046795643
2025-04-28 18:11:29 -03:00

585 lines
17 KiB
TypeScript

import { setupAndTeardown } from "@calcom/web/test/utils/bookingScenario/setupAndTeardown";
import { describe, expect, it, beforeEach, vi } from "vitest";
import type { z } from "zod";
import type { CredentialPayload } from "@calcom/types/Credential";
import type { appDataSchema } from "../zod";
import SalesforceCRMService from "./CrmService";
import { SalesforceRecordEnum } from "./enums";
type AppOptions = z.infer<typeof appDataSchema>;
const contactQueryResponse = {
records: [
{
Id: "001",
Email: "[email protected]",
OwnerId: "owner001",
attributes: { type: "Contact" },
Owner: {
Email: "[email protected]",
},
},
],
};
const contactUnderAccountQueryResponse = {
records: [
{
Id: "001",
Email: "[email protected]",
OwnerId: "owner001",
AccountId: "acc001",
attributes: { type: "Contact" },
Account: {
attributes: { type: "Account" },
Owner: {
Email: "[email protected]",
},
},
},
],
};
const leadQueryResponse = {
records: [
{
Id: "001",
Email: "[email protected]",
OwnerId: "owner001",
attributes: { type: "Lead" },
Owner: {
Email: "[email protected]",
},
},
],
};
const ownerQueryResponse = {
records: [
{
Id: "owner001",
Email: "[email protected]",
Name: "Test Owner",
},
],
};
const accountQueryResponse = {
records: [
{
Id: "acc001",
OwnerId: "owner001",
Email: "[email protected]",
attributes: { type: "Account" },
},
],
};
const mockSalesforceGraphQLClientQuery = vi.fn();
vi.mock("./graphql/SalesforceGraphQLClient", () => ({
SalesforceGraphQLClient: class {
GetAccountRecordsForRRSkip = mockSalesforceGraphQLClientQuery;
},
}));
describe("SalesforceCRMService", () => {
let service: SalesforceCRMService;
let mockConnection: { query: any; sobject: any };
setupAndTeardown();
beforeEach(() => {
mockConnection = {
query: vi.fn(),
sobject: vi.fn(),
};
const mockCredential: CredentialPayload = {
id: 1,
type: "salesforce_crm",
key: {
access_token: "mock_token",
refresh_token: "mock_refresh",
instance_url: "https://mock.salesforce.com",
},
userId: 1,
appId: "salesforce",
teamId: null,
invalid: false,
user: {
email: "[email protected]",
},
delegationCredentialId: null,
};
service = new SalesforceCRMService(mockCredential, {}, true);
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
service.conn = Promise.resolve(mockConnection);
});
const mockAppOptions = (appOptions: AppOptions) => {
const appOptionsSpy = vi.spyOn(service, "getAppOptions");
appOptionsSpy.mockReturnValue(appOptions);
};
describe("getContacts", () => {
it("should return empty array when no records found", async () => {
// Setup mock response
mockConnection.query.mockResolvedValueOnce({ records: [] });
const result = await service.getContacts({ emails: "[email protected]" });
expect(result).toEqual([]);
expect(mockConnection.query).toHaveBeenCalledWith(
"SELECT Id, Email, OwnerId, Owner.Email FROM Contact WHERE Email IN ('[email protected]')"
);
});
it("should handle single email string input", async () => {
// Setup mock response with descriptive name
const contactQueryResponse = {
records: [
{
Id: "001",
Email: "[email protected]",
OwnerId: "owner001",
attributes: { type: "Contact" },
},
],
};
// Setup query spy
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(contactQueryResponse);
const result = await service.getContacts({ emails: "[email protected]" });
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
recordType: "Contact",
},
]);
// Verify the exact query made
expect(querySpy).toHaveBeenCalledWith(
"SELECT Id, Email, OwnerId, Owner.Email FROM Contact WHERE Email IN ('[email protected]')"
);
});
it("should handle array of emails input", async () => {
const contactsQueryResponse = {
records: [
{
Id: "001",
Email: "[email protected]",
OwnerId: "owner001",
attributes: { type: "Contact" },
},
{
Id: "002",
Email: "[email protected]",
OwnerId: "owner002",
attributes: { type: "Contact" },
},
],
};
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(contactsQueryResponse);
const result = await service.getContacts({
emails: ["[email protected]", "[email protected]"],
});
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
recordType: "Contact",
},
{
id: "002",
email: "[email protected]",
recordType: "Contact",
},
]);
expect(querySpy).toHaveBeenCalledWith(
"SELECT Id, Email, OwnerId, Owner.Email FROM Contact WHERE Email IN ('[email protected]','[email protected]')"
);
});
it("should return contacts when includeOwner is true but no owner is found", async () => {
mockAppOptions({
roundRobinSkipCheckRecordOn: SalesforceRecordEnum.CONTACT,
createEventOn: SalesforceRecordEnum.CONTACT,
});
const contactQueryResponse = {
records: [
{
Id: "001",
Email: "[email protected]",
// OwnerId: "owner001",
attributes: { type: "Contact" },
Owner: {
Email: "[email protected]",
},
},
],
};
// Setup query spy with specific responses
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(contactQueryResponse); // Contact query
const result = await service.getContacts({
emails: "[email protected]",
includeOwner: true,
});
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
ownerId: undefined,
ownerEmail: "[email protected]",
recordType: "Contact",
},
]);
expect(querySpy).toHaveBeenNthCalledWith(
1,
"SELECT Id, Email, OwnerId, Owner.Email FROM Contact WHERE Email IN ('[email protected]')"
);
});
describe("no additional params are passed", () => {
it("when createEventOn is contact", async () => {
mockAppOptions({
createEventOn: SalesforceRecordEnum.CONTACT,
});
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(contactQueryResponse);
const result = await service.getContacts({
emails: "[email protected]",
});
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
recordType: "Contact",
},
]);
expect(querySpy).toHaveBeenNthCalledWith(
1,
"SELECT Id, Email, OwnerId, Owner.Email FROM Contact WHERE Email IN ('[email protected]')"
);
});
it("when createEventOn is lead", async () => {
mockAppOptions({
createEventOn: SalesforceRecordEnum.LEAD,
});
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(leadQueryResponse);
const result = await service.getContacts({
emails: "[email protected]",
});
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
recordType: "Lead",
},
]);
expect(querySpy).toHaveBeenNthCalledWith(
1,
"SELECT Id, Email, OwnerId, Owner.Email FROM Lead WHERE Email IN ('[email protected]')"
);
});
it("when createEventOn is contact under an account", async () => {
mockAppOptions({
createEventOn: SalesforceRecordEnum.ACCOUNT,
});
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(contactUnderAccountQueryResponse);
const result = await service.getContacts({
emails: "[email protected]",
});
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
recordType: "Contact",
},
]);
expect(querySpy).toHaveBeenNthCalledWith(
1,
"SELECT Id, Email, OwnerId, AccountId, Account.Owner.Email, Account.Website FROM Contact WHERE Email = '[email protected]' AND AccountId != null"
);
});
});
describe("includeOwner param is passed", () => {
it("when createEventOn is contact", async () => {
mockAppOptions({
createEventOn: SalesforceRecordEnum.CONTACT,
});
// Setup query spy with specific responses
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(contactQueryResponse); // Contact query
const result = await service.getContacts({
emails: "[email protected]",
includeOwner: true,
});
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
ownerId: "owner001",
ownerEmail: "[email protected]",
recordType: "Contact",
},
]);
expect(querySpy).toHaveBeenNthCalledWith(
1,
"SELECT Id, Email, OwnerId, Owner.Email FROM Contact WHERE Email IN ('[email protected]')"
);
});
it("when createEventOn is lead", async () => {
mockAppOptions({
createEventOn: SalesforceRecordEnum.LEAD,
});
// Setup query spy with specific responses
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(leadQueryResponse);
const result = await service.getContacts({
emails: "[email protected]",
includeOwner: true,
});
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
ownerId: "owner001",
ownerEmail: "[email protected]",
recordType: "Lead",
},
]);
expect(querySpy).toHaveBeenNthCalledWith(
1,
"SELECT Id, Email, OwnerId, Owner.Email FROM Lead WHERE Email IN ('[email protected]')"
);
});
it("when createEventOn is contact under an account", async () => {
mockAppOptions({
createEventOn: SalesforceRecordEnum.ACCOUNT,
});
// Setup query spy with specific responses
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(contactUnderAccountQueryResponse);
const result = await service.getContacts({
emails: "[email protected]",
includeOwner: true,
});
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
ownerId: "owner001",
ownerEmail: "[email protected]",
recordType: "Contact",
},
]);
expect(querySpy).toHaveBeenNthCalledWith(
1,
"SELECT Id, Email, OwnerId, AccountId, Account.Owner.Email, Account.Website FROM Contact WHERE Email = '[email protected]' AND AccountId != null"
);
});
});
describe("forRoundRobinSkip param is passed", () => {
it("checking against contacts", async () => {
mockAppOptions({
roundRobinSkipCheckRecordOn: SalesforceRecordEnum.CONTACT,
createEventOn: SalesforceRecordEnum.CONTACT,
});
// Setup query spy with specific responses
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(contactQueryResponse); // Contact query
const result = await service.getContacts({
emails: "[email protected]",
forRoundRobinSkip: true,
});
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
ownerId: "owner001",
ownerEmail: "[email protected]",
recordType: "Contact",
},
]);
expect(querySpy).toHaveBeenNthCalledWith(
1,
"SELECT Id, Email, OwnerId, Owner.Email FROM Contact WHERE Email IN ('[email protected]')"
);
});
it("checking against leads", async () => {
mockAppOptions({
roundRobinSkipCheckRecordOn: SalesforceRecordEnum.LEAD,
});
// Setup query spy with specific responses
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(leadQueryResponse);
const result = await service.getContacts({
emails: "[email protected]",
forRoundRobinSkip: true,
});
expect(result).toEqual([
{
id: "001",
email: "[email protected]",
ownerId: "owner001",
ownerEmail: "[email protected]",
recordType: "Lead",
},
]);
expect(querySpy).toHaveBeenNthCalledWith(
1,
"SELECT Id, Email, OwnerId, Owner.Email FROM Lead WHERE Email IN ('[email protected]')"
);
});
it("checking against contacts under an account", async () => {
mockAppOptions({
roundRobinSkipCheckRecordOn: SalesforceRecordEnum.ACCOUNT,
});
mockSalesforceGraphQLClientQuery.mockResolvedValueOnce([
{
id: "acc001",
email: "[email protected]",
ownerId: "owner001",
ownerEmail: "[email protected]",
recordType: SalesforceRecordEnum.ACCOUNT,
},
]);
const result = await service.getContacts({
emails: "[email protected]",
forRoundRobinSkip: true,
});
expect(result).toEqual([
{
id: "acc001",
email: "[email protected]",
ownerId: "owner001",
ownerEmail: "[email protected]",
recordType: "Account",
},
]);
});
});
});
describe("createContacts", () => {
describe("createEventOn lead", () => {
describe("createNewContactUnderAccount enabled", () => {
it("when attendee has an account", async () => {
mockAppOptions({
createNewContactUnderAccount: true,
createEventOn: SalesforceRecordEnum.LEAD,
});
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce(accountQueryResponse);
querySpy.mockResolvedValueOnce({ records: [] });
mockConnection.sobject.mockReturnValue({
create: vi.fn().mockResolvedValue({
success: true,
id: "newContactId",
name: "New Contact",
email: "[email protected]",
}),
});
const result = await service.createContacts([{ name: "New Contact", email: "[email protected]" }]);
expect(result).toEqual([{ id: "newContactId", email: "[email protected]" }]);
});
it("attendee has no account", async () => {
mockAppOptions({
createNewContactUnderAccount: true,
createEventOn: SalesforceRecordEnum.LEAD,
});
const querySpy = vi.spyOn(mockConnection, "query");
querySpy.mockResolvedValueOnce({ records: [] });
querySpy.mockResolvedValueOnce({ records: [] });
mockConnection.sobject.mockReturnValue({
create: vi.fn().mockResolvedValue({
success: true,
id: "newLeadId",
name: "New Lead",
email: "[email protected]",
}),
});
const result = await service.createContacts([{ name: "New Lead", email: "[email protected]" }]);
expect(result).toEqual([{ id: "newLeadId", email: "[email protected]" }]);
});
});
});
});
describe("getAllPossibleAccountWebsiteFromEmailDomain", () => {
it("should return all possible account websites from email domain", () => {
const result = service.getAllPossibleAccountWebsiteFromEmailDomain("example.com");
expect(result).toEqual(
"'example.com', 'www.example.com', 'http://www.example.com', 'http://example.com', 'https://www.example.com', 'https://example.com'"
);
});
});
});