asksuite-core/__tests__/SophiaAccessor.test.js

const SophiaAccessor = require('../services/SophiaAccessor');
const nock = require('nock');

describe('SophiaAccessor', () => {
  const baseUrl = 'http://sophia-test.asksuite.com';
  let accessor;

  beforeEach(() => {
    accessor = new SophiaAccessor(baseUrl, true, {});
    nock.cleanAll();
  });

  afterEach(() => {
    nock.cleanAll();
  });

  describe('resolveText - timeConfiguration in metadata', () => {
    const createMockRequest = (overrides = {}) => ({
      text: 'Quero fazer uma reserva',
      originalCompanyId: 'test-company',
      companyName: 'Test Hotel',
      language: 'pt-br',
      conversationId: 'conv-123',
      intents: [{ intent: 'naoentendi', dialog: 'test.fallback' }],
      ip: '192.168.1.1',
      mobile: true,
      platform: 'web',
      botName: 'TestBot',
      ...overrides,
    });

    const mockSophiaResponse = {
      response: ['Claro, posso ajudar com sua reserva!'],
      inputLanguage: 'pt-br',
      genericBotResponse: {
        intent: 'cotacao',
        actions: [],
        tags: [],
      },
    };

    it('should pass timeConfiguration from request to metadata payload', async () => {
      const timeConfiguration = {
        timezone: '-3',
        officeHours: {
          1: { enabled: true, start: '08:00', end: '18:00' },
        },
        isOpen: true,
      };

      let capturedPayload = null;

      nock(baseUrl)
        .post('/', (body) => {
          capturedPayload = body;
          return true;
        })
        .reply(200, mockSophiaResponse);

      const request = createMockRequest({ timeConfiguration });
      await accessor.resolveText(request);

      expect(capturedPayload).not.toBeNull();
      expect(capturedPayload.metadata).toBeDefined();
      expect(capturedPayload.metadata.timeConfiguration).toEqual(timeConfiguration);
    });

    it('should set timeConfiguration as undefined in metadata when not provided in request', async () => {
      let capturedPayload = null;

      nock(baseUrl)
        .post('/', (body) => {
          capturedPayload = body;
          return true;
        })
        .reply(200, mockSophiaResponse);

      const request = createMockRequest();
      await accessor.resolveText(request);

      expect(capturedPayload).not.toBeNull();
      expect(capturedPayload.metadata).toBeDefined();
      expect(capturedPayload.metadata.timeConfiguration).toBeUndefined();
    });

    it('should pass timeConfiguration with isOpen false correctly', async () => {
      const timeConfiguration = {
        timezone: '-3',
        officeHours: {
          0: { enabled: false },
          1: { enabled: true, start: '08:00', end: '18:00' },
        },
        isOpen: false,
      };

      let capturedPayload = null;

      nock(baseUrl)
        .post('/', (body) => {
          capturedPayload = body;
          return true;
        })
        .reply(200, mockSophiaResponse);

      const request = createMockRequest({ timeConfiguration });
      await accessor.resolveText(request);

      expect(capturedPayload.metadata.timeConfiguration).toEqual(timeConfiguration);
      expect(capturedPayload.metadata.timeConfiguration.isOpen).toBe(false);
    });

    it('should pass null timeConfiguration when explicitly set to null', async () => {
      let capturedPayload = null;

      nock(baseUrl)
        .post('/', (body) => {
          capturedPayload = body;
          return true;
        })
        .reply(200, mockSophiaResponse);

      const request = createMockRequest({ timeConfiguration: null });
      await accessor.resolveText(request);

      expect(capturedPayload.metadata.timeConfiguration).toBeNull();
    });
  });

  describe('resolveText - resilience', () => {
    it('should not throw error when request has no timeConfiguration', async () => {
      nock(baseUrl)
        .post('/')
        .reply(200, {
          response: ['Response'],
          inputLanguage: 'pt-br',
          genericBotResponse: { intent: 'test' },
        });

      const request = {
        text: 'Test message',
        originalCompanyId: 'test-company',
        companyName: 'Test Hotel',
        language: 'pt-br',
        conversationId: 'conv-123',
        intents: [{ intent: 'naoentendi', dialog: 'test.fallback' }],
      };

      await expect(accessor.resolveText(request)).resolves.toBeDefined();
    });

    it('should include other metadata fields alongside timeConfiguration', async () => {
      const timeConfiguration = {
        timezone: '-5',
        officeHours: { 2: { enabled: true, start: '09:00', end: '17:00' } },
        isOpen: true,
      };

      let capturedPayload = null;

      nock(baseUrl)
        .post('/', (body) => {
          capturedPayload = body;
          return true;
        })
        .reply(200, {
          response: ['Response'],
          inputLanguage: 'pt-br',
          genericBotResponse: { intent: 'test' },
        });

      const request = {
        text: 'Test message',
        originalCompanyId: 'test-company',
        companyName: 'Test Hotel',
        language: 'pt-br',
        conversationId: 'conv-123',
        intents: [{ intent: 'naoentendi', dialog: 'test.fallback' }],
        ip: '192.168.1.1',
        mobile: true,
        platform: 'web',
        botName: 'TestBot',
        timeConfiguration,
      };

      await accessor.resolveText(request);

      expect(capturedPayload.metadata).toEqual({
        ip: '192.168.1.1',
        mobile: true,
        parentCompanyId: undefined,
        platform: 'web',
        botName: 'TestBot',
        timeConfiguration,
      });
    });
  });
});