snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-server/test/utils/audit-context.mock.ts

@@ -0,0 +1,31 @@
+import { type TrackEventName } from 'src/engine/core-modules/event-logs/emit/events.type';
+
+export const AuditContextMock = (params?: {
+  insertWorkspaceEvent?:
+    | ((
+        event: TrackEventName,
+        properties: any,
+      ) => Promise<{ success: boolean }>)
+    | jest.Mock<any, any>;
+  createObjectEvent?:
+    | ((
+        event: TrackEventName,
+        properties: any,
+      ) => Promise<{ success: boolean }>)
+    | jest.Mock<any, any>;
+  createPageviewEvent?:
+    | ((name: string, properties: any) => Promise<{ success: boolean }>)
+    | jest.Mock<any, any>;
+}) => {
+  return {
+    insertWorkspaceEvent:
+      params?.insertWorkspaceEvent ??
+      jest.fn().mockResolvedValue({ success: true }),
+    createObjectEvent:
+      params?.createObjectEvent ??
+      jest.fn().mockResolvedValue({ success: true }),
+    createPageviewEvent:
+      params?.createPageviewEvent ??
+      jest.fn().mockResolvedValue({ success: true }),
+  };
+};

packages/twenty-server/test/utils/create-where-expression-recorder.util.ts

@@ -0,0 +1,64 @@
+import {
+  Brackets,
+  NotBrackets,
+  type ObjectLiteral,
+  type WhereExpressionBuilder,
+} from 'typeorm';
+
+export type RecordedWhereNode =
+  | { kind: 'sql'; sql: string; parameters: ObjectLiteral | undefined }
+  | { kind: 'brackets'; children: RecordedWhereCall[] }
+  | { kind: 'notBrackets'; children: RecordedWhereCall[] };
+
+export type RecordedWhereCall = {
+  method: 'where' | 'andWhere' | 'orWhere';
+  node: RecordedWhereNode;
+};
+
+export type WhereExpressionRecorder = {
+  whereExpression: WhereExpressionBuilder;
+  calls: RecordedWhereCall[];
+};
+
+export const createWhereExpressionRecorder = (): WhereExpressionRecorder => {
+  const calls: RecordedWhereCall[] = [];
+
+  const recordNode = (
+    condition: unknown,
+    parameters: ObjectLiteral | undefined,
+  ): RecordedWhereNode => {
+    if (condition instanceof NotBrackets) {
+      const childRecorder = createWhereExpressionRecorder();
+
+      condition.whereFactory(childRecorder.whereExpression);
+
+      return { kind: 'notBrackets', children: childRecorder.calls };
+    }
+
+    if (condition instanceof Brackets) {
+      const childRecorder = createWhereExpressionRecorder();
+
+      condition.whereFactory(childRecorder.whereExpression);
+
+      return { kind: 'brackets', children: childRecorder.calls };
+    }
+
+    return { kind: 'sql', sql: String(condition), parameters };
+  };
+
+  const recordCall =
+    (method: RecordedWhereCall['method']) =>
+    (condition: unknown, parameters?: ObjectLiteral) => {
+      calls.push({ method, node: recordNode(condition, parameters) });
+
+      return whereExpression;
+    };
+
+  const whereExpression = {
+    where: recordCall('where'),
+    andWhere: recordCall('andWhere'),
+    orWhere: recordCall('orWhere'),
+  } as unknown as WhereExpressionBuilder;
+
+  return { whereExpression, calls };
+};

packages/twenty-server/test/utils/extract-record-ids-and-dates-as-expect-any.ts

@@ -0,0 +1,53 @@
+import { isDefined } from 'twenty-shared/utils';
+
+export const extractRecordIdsAndDatesAsExpectAny = (
+  record: Record<string, unknown> | Array<Record<string, unknown>>,
+): any => {
+  if (Array.isArray(record)) {
+    return record.map((item) => extractRecordIdsAndDatesAsExpectAny(item));
+  }
+
+  if (typeof record !== 'object') {
+    return record;
+  }
+
+  return Object.entries(record).reduce((acc, [key, value]) => {
+    if (!isDefined(value)) {
+      return acc;
+    }
+
+    if (value instanceof Date) {
+      return {
+        ...acc,
+        [key]: expect.any(Date),
+      };
+    }
+
+    if (
+      key.endsWith('Id') ||
+      key.endsWith('UniversalIdentifier') ||
+      key === 'universalIdentifier' ||
+      key === 'id' ||
+      key === 'updatedAt' ||
+      key === 'deletedAt' ||
+      key === 'createdAt'
+    ) {
+      return {
+        ...acc,
+        [key]:
+          typeof value === 'object' ? expect.any(Object) : expect.any(String),
+      };
+    }
+
+    if (typeof value === 'object' || Array.isArray(value)) {
+      return {
+        ...acc,
+        [key]: extractRecordIdsAndDatesAsExpectAny(
+          value as Record<string, unknown>,
+        ),
+      };
+    }
+
+    return acc;
+  }, {});
+};

packages/twenty-server/test/utils/jest-expect-to-be-defined.util.test.ts

@@ -0,0 +1,6 @@
+type AssertIsDefined = <T>(value: T) => asserts value is NonNullable<T>;
+
+export const jestExpectToBeDefined: AssertIsDefined = (value) => {
+  expect(value).toBeDefined();
+  expect(value).not.toBeNull();
+};

packages/twenty-server/test/utils/scrub-semver-versions.util.ts

@@ -0,0 +1,2 @@
+export const scrubSemverVersions = (value: string): string =>
+  value.replace(/\d+\.\d+\.\d+/g, '<version>');