Skip to content

The open alternative to Salesforce, designed for AI.

6.3 KB
Raw Blame
import { type Response } from 'express';
import { HTTPMethod } from 'twenty-shared/types';

import { RouteTriggerService } from 'src/engine/core-modules/logic-function/logic-function-trigger/triggers/route/route-trigger.service';
import { RouteTriggerController } from 'src/engine/metadata-modules/route-trigger/route-trigger.controller';

const createResponseMock = () => {
  const headers: Record<string, string> = {};

  return {
    status: jest.fn(),
    setHeader: jest.fn((key: string, value: string) => {
      headers[key.toLowerCase()] = value;
    }),
    getHeader: jest.fn((key: string) => headers[key.toLowerCase()]),
    send: jest.fn(),
    json: jest.fn(),
  } as unknown as Response;
};

describe('RouteTriggerController', () => {
  let controller: RouteTriggerController;
  const handle = jest.fn();

  beforeEach(() => {
    const routeTriggerService = { handle } as unknown as RouteTriggerService;

    controller = new RouteTriggerController(routeTriggerService);
  });

  afterEach(() => {
    jest.clearAllMocks();
  });

  it('should be defined', () => {
    expect(controller).toBeDefined();
  });

  it('delegates to the service with the POST http method and applies status 200', async () => {
    const request = { path: '/s/webhooks/google/leads' } as never;
    const response = createResponseMock();

    handle.mockResolvedValue({
      response: { statusCode: 200, headers: {}, body: { ok: true } },
      isPublicDomain: false,
    });

    await controller.post(request, response);

    expect(handle).toHaveBeenCalledWith({
      request,
      httpMethod: HTTPMethod.POST,
    });
    expect(response.status).toHaveBeenCalledWith(200);
    expect(response.json).toHaveBeenCalledWith({ ok: true });
  });

  it('applies the status code and allow-listed headers from the service result', async () => {
    const response = createResponseMock();

    handle.mockResolvedValue({
      response: {
        statusCode: 201,
        headers: { 'Content-Type': 'text/html', 'Cache-Control': 'no-store' },
        body: '<h1>Hi</h1>',
      },
      isPublicDomain: false,
    });

    await controller.get({} as never, response);

    expect(response.status).toHaveBeenCalledWith(201);
    expect(response.setHeader).toHaveBeenCalledWith(
      'Content-Type',
      'text/html',
    );
    expect(response.setHeader).toHaveBeenCalledWith(
      'Cache-Control',
      'no-store',
    );
    expect(response.send).toHaveBeenCalledWith('<h1>Hi</h1>');
  });

  it('drops headers that are not in the allow-list on the same-site /s/ route', async () => {
    const response = createResponseMock();

    handle.mockResolvedValue({
      response: {
        statusCode: 200,
        headers: {
          'Content-Type': 'text/html',
          'Set-Cookie': 'session=abc',
          'Access-Control-Allow-Origin': '*',
          'X-Custom': 'foo',
        },
        body: '<h1>Hi</h1>',
      },
      isPublicDomain: false,
    });

    await controller.get({} as never, response);

    expect(response.setHeader).toHaveBeenCalledWith(
      'Content-Type',
      'text/html',
    );
    expect(response.setHeader).not.toHaveBeenCalledWith(
      'Set-Cookie',
      'session=abc',
    );
    expect(response.setHeader).not.toHaveBeenCalledWith(
      'Access-Control-Allow-Origin',
      '*',
    );
    expect(response.setHeader).not.toHaveBeenCalledWith('X-Custom', 'foo');
  });

  it('forwards every header when the request is served from a public domain', async () => {
    const response = createResponseMock();

    handle.mockResolvedValue({
      response: {
        statusCode: 200,
        headers: {
          'Content-Type': 'text/html',
          'Permissions-Policy': 'camera=(self)',
          'Cross-Origin-Opener-Policy': 'same-origin',
          'Cross-Origin-Embedder-Policy': 'require-corp',
          'Set-Cookie': 'session=abc',
          'X-Custom': 'foo',
        },
        body: '<h1>Hi</h1>',
      },
      isPublicDomain: true,
    });

    await controller.get({} as never, response);

    expect(response.setHeader).toHaveBeenCalledWith(
      'Permissions-Policy',
      'camera=(self)',
    );
    expect(response.setHeader).toHaveBeenCalledWith(
      'Cross-Origin-Opener-Policy',
      'same-origin',
    );
    expect(response.setHeader).toHaveBeenCalledWith(
      'Cross-Origin-Embedder-Policy',
      'require-corp',
    );
    expect(response.setHeader).toHaveBeenCalledWith(
      'Set-Cookie',
      'session=abc',
    );
    expect(response.setHeader).toHaveBeenCalledWith('X-Custom', 'foo');
  });

  it('sends an empty response when the body is nil', async () => {
    const response = createResponseMock();

    handle.mockResolvedValue({
      response: { statusCode: 200, headers: {}, body: null },
      isPublicDomain: false,
    });

    await controller.get({} as never, response);

    expect(response.status).toHaveBeenCalledWith(200);
    expect(response.send).toHaveBeenCalledWith();
    expect(response.json).not.toHaveBeenCalled();
  });

  it('defaults a string body content-type to text/plain when none is set', async () => {
    const response = createResponseMock();

    handle.mockResolvedValue({
      response: { statusCode: 200, headers: {}, body: 'plain' },
      isPublicDomain: false,
    });

    await controller.get({} as never, response);

    expect(response.setHeader).toHaveBeenCalledWith(
      'content-type',
      'text/plain',
    );
    expect(response.send).toHaveBeenCalledWith('plain');
  });

  it('sends an object body as JSON when no content-type is set', async () => {
    const response = createResponseMock();

    handle.mockResolvedValue({
      response: { statusCode: 200, headers: {}, body: { ok: true } },
      isPublicDomain: false,
    });

    await controller.get({} as never, response);

    expect(response.json).toHaveBeenCalledWith({ ok: true });
  });

  it('pre-serializes an object body when a custom content-type is set', async () => {
    const response = createResponseMock();

    handle.mockResolvedValue({
      response: {
        statusCode: 200,
        headers: { 'Content-Type': 'application/ld+json' },
        body: { ok: true },
      },
      isPublicDomain: false,
    });

    await controller.get({} as never, response);

    expect(response.send).toHaveBeenCalledWith(JSON.stringify({ ok: true }));
    expect(response.json).not.toHaveBeenCalled();
  });
});