@controleonline/ui-common 1.2.70 → 1.2.71

package/src/tests/react/services/Cielo.test.js

@@ -0,0 +1,190 @@
+const {jest} = require('@jest/globals')
+
+const mockPayment = jest.fn()
+const mockFetch = jest.fn()
+const mockGetAllStores = jest.fn()
+
+jest.mock('@controleonline-rn/react-native-cielo-payment', () => ({
+  payment: (...args) => mockPayment(...args),
+}))
+
+jest.mock('@controleonline/ui-common/src/api', () => ({
+  api: {
+    fetch: (...args) => mockFetch(...args),
+  },
+}))
+
+jest.mock('@store', () => ({
+  getAllStores: (...args) => mockGetAllStores(...args),
+}))
+
+jest.mock('@env', () => ({
+  env: {
+    CIELO: {
+      ACCESS_TOKEN: '',
+      CLIENT_ID: '',
+      EMAIL: '',
+      MERCHANT_CODE: '',
+    },
+  },
+}))
+
+const {describe, expect, it, beforeEach} = global
+
+const loadService = () => {
+  const serviceModule = require('../../../react/services/Cielo/Cielo')
+  return serviceModule.default || serviceModule
+}
+
+const runtimeStores = merchantCode => ({
+  people: {
+    getters: {
+      currentCompany: {
+        id: 99,
+        configs: {
+          CIELO: JSON.stringify({
+            ACCESS_TOKEN: 'runtime-token',
+            CLIENT_ID: 'runtime-client',
+            EMAIL: 'runtime@empresa.com',
+            ...(merchantCode ? {MERCHANT_CODE: merchantCode} : {}),
+          }),
+        },
+      },
+      defaultCompany: {id: 99},
+    },
+  },
+  configs: {
+    getters: {
+      items: {
+        CIELO: JSON.stringify({
+          ACCESS_TOKEN: 'runtime-token',
+          CLIENT_ID: 'runtime-client',
+          EMAIL: 'runtime@empresa.com',
+          ...(merchantCode ? {MERCHANT_CODE: merchantCode} : {}),
+        }),
+      },
+    },
+  },
+})
+
+describe('CieloService', () => {
+  beforeEach(() => {
+    jest.resetModules()
+    mockPayment.mockReset()
+    mockFetch.mockReset()
+    mockGetAllStores.mockReset()
+
+    mockPayment.mockResolvedValue({
+      success: true,
+      code: '0',
+      result: JSON.stringify({
+        status: 'ok',
+        payments: [{merchantCode: '0000000000000001'}],
+      }),
+    })
+  })
+
+  it('falls back to the main company private CIELO config', async () => {
+    mockGetAllStores.mockReturnValue({
+      people: {
+        getters: {
+          currentCompany: {id: 21, configs: {}},
+          defaultCompany: {id: 99},
+        },
+      },
+      configs: {getters: {items: {}}},
+    })
+    mockFetch.mockResolvedValue({
+      member: [
+        {
+          configKey: 'CIELO',
+          configValue: JSON.stringify({
+            ACCESS_TOKEN: 'private-token',
+            CLIENT_ID: 'private-client',
+            EMAIL: 'cielo@principal.com',
+            MERCHANT_CODE: '0000000000000001',
+          }),
+        },
+      ],
+    })
+
+    const CieloService = loadService()
+    await new CieloService().payment('credit', [{name: 'Produto'}], 1250)
+
+    expect(mockFetch).toHaveBeenCalledWith('/configs', {
+      params: {
+        configKey: 'CIELO',
+        people: '/people/99',
+        visibility: 'private',
+      },
+    })
+    expect(JSON.parse(mockPayment.mock.calls[0][0])).toMatchObject({
+      accessToken: 'private-token',
+      clientID: 'private-client',
+      email: 'cielo@principal.com',
+      merchantCode: '0000000000000001',
+      paymentCode: 'credit',
+      value: 1250,
+    })
+  })
+
+  it('sends the configured merchantCode to Cielo', async () => {
+    mockGetAllStores.mockReturnValue(runtimeStores('0000000000000001'))
+
+    const CieloService = loadService()
+    await new CieloService().payment('debit', [], 500)
+
+    expect(mockFetch).not.toHaveBeenCalled()
+    expect(JSON.parse(mockPayment.mock.calls[0][0])).toMatchObject({
+      merchantCode: '0000000000000001',
+      paymentCode: 'debit',
+      value: 500,
+    })
+  })
+
+  it('keeps the legacy request when merchantCode is not configured', async () => {
+    mockGetAllStores.mockReturnValue(runtimeStores(''))
+
+    const CieloService = loadService()
+    await new CieloService().payment('debit', [], 500)
+
+    expect(JSON.parse(mockPayment.mock.calls[0][0])).not.toHaveProperty(
+      'merchantCode',
+    )
+  })
+
+  it('rejects a successful response without merchantCode', async () => {
+    mockGetAllStores.mockReturnValue(runtimeStores('0000000000000001'))
+    mockPayment.mockResolvedValue({
+      success: true,
+      code: '0',
+      result: JSON.stringify({status: 'ok', payments: [{}]}),
+    })
+
+    const CieloService = loadService()
+    const response = await new CieloService().payment('debit', [], 500)
+
+    expect(response.success).toBe(false)
+  })
+
+  it('rejects a successful response from a different merchantCode', async () => {
+    mockGetAllStores.mockReturnValue(runtimeStores('0000000000000001'))
+    mockPayment.mockResolvedValue({
+      success: true,
+      code: '0',
+      result: JSON.stringify({
+        status: 'ok',
+        payments: [{merchantCode: '0000000000000002'}],
+      }),
+    })
+
+    const CieloService = loadService()
+    const response = await new CieloService().payment('debit', [], 500)
+
+    expect(response).toMatchObject({
+      success: false,
+      result:
+        'Pagamento processado em estabelecimento Cielo diferente do configurado.',
+    })
+  })
+})

package/src/tests/react/utils/fileUrl.test.js

@@ -0,0 +1,62 @@
+const {describe, expect, it} = global;
+const {jest} = require('@jest/globals');
+
+jest.mock('@env', () => ({
+  env: {
+    API_ENTRYPOINT: 'https://api.controleonline.com',
+    DOMAIN: 'manager.controleonline.com',
+  },
+}));
+
+const {
+  resolveDefaultFileSource,
+  resolveFileImageUrl,
+} = require('../../../react/utils/fileUrl');
+
+describe('fileUrl helpers', () => {
+  it('adds app-domain to backend download urls and keeps headers', () => {
+    const company = {
+      domain: 'maincompany.controleonline.com',
+    };
+
+    const source = resolveDefaultFileSource(
+      {
+        id: 3,
+        url: '/files/3/download',
+      },
+      {
+        company,
+        headers: {
+          Authorization: 'Bearer token',
+        },
+      },
+    );
+
+    expect(source).toEqual({
+      uri: 'https://api.controleonline.com/files/3/download?app-domain=maincompany.controleonline.com',
+      headers: {
+        Authorization: 'Bearer token',
+        'app-domain': 'maincompany.controleonline.com',
+      },
+    });
+    expect(resolveFileImageUrl(3, {company})).toBe(
+      'https://api.controleonline.com/files/3/download?app-domain=maincompany.controleonline.com',
+    );
+  });
+
+  it('keeps external image urls untouched', () => {
+    const source = resolveDefaultFileSource(
+      'https://cdn.controleonline.com/logo.png',
+      {
+        company: {
+          domain: 'maincompany.controleonline.com',
+        },
+      },
+    );
+
+    expect(source).toEqual({
+      uri: 'https://cdn.controleonline.com/logo.png',
+      headers: {},
+    });
+  });
+});

package/src/tests/react/utils/importStatus.test.js

@@ -1,5 +1,5 @@
-const assert = require('node:assert/strict')
-const test = require('node:test')
+const assert = require('node:assert/strict')
+const {test} = global
 
 const {
   getImportErrorDetail,

package/src/tests/react/utils/orderIdentity.test.js

@@ -0,0 +1,139 @@
+const {jest} = require('@jest/globals');
+
+const {resolveOrderIdentity} = require('../../../react/utils/orderIdentity');
+
+const {describe, expect, it} = global;
+
+global.t = {
+  t: jest.fn((store, type, key) => {
+    if (store === 'orders' && type === 'title' && key === 'table') {
+      return 'Mesa';
+    }
+
+    if (store === 'orders' && type === 'title' && key === 'order') {
+      return 'Pedido';
+    }
+
+    return '';
+  }),
+};
+
+describe('orderIdentity', () => {
+  it('prioritizes the 99Food code field from extra data', () => {
+    const order = {
+      id: 70911,
+      app: '99Food',
+      extraData: [
+        {
+          extraFields: {
+            context: 'Food99',
+            name: 'id',
+          },
+          value: '71759',
+        },
+        {
+          extraFields: {
+            context: 'Food99',
+            name: 'code',
+          },
+          value: '70001',
+        },
+      ],
+    };
+
+    const identity = resolveOrderIdentity(order);
+
+    expect(identity.externalLabel).toBe('99');
+    expect(identity.externalId).toBe('70001');
+    expect(identity.primaryText).toBe('#70001');
+    expect(identity.secondaryText).toBe('#70911');
+  });
+
+  it('does not invent an iFood marketplace code from pickup or display ids', () => {
+    const order = {
+      id: 81234,
+      app: 'ifood',
+      otherInformations: JSON.stringify({
+        ifood: {
+          latest_event_type: 'PLACED',
+          PLACED: {
+            order: {
+              id: 'ifood-order-1',
+              displayId: '70002',
+              delivery: {
+                pickupCode: '0176',
+              },
+            },
+          },
+        },
+      }),
+    };
+
+    const identity = resolveOrderIdentity(order);
+
+    expect(identity.externalLabel).toBe('');
+    expect(identity.externalId).toBe('');
+    expect(identity.primaryText).toBe('#81234');
+    expect(identity.secondaryText).toBe('');
+  });
+
+  it('prioritizes iFood code from extra data over pickup code', () => {
+    const order = {
+      id: 71759,
+      app: 'iFood',
+      extra_data: [
+        {
+          extra_fields: {
+            context: 'iFood',
+            name: 'pickup_code',
+          },
+          value: '9103',
+        },
+        {
+          extra_fields: {
+            context: 'iFood',
+            name: 'code',
+          },
+          value: '3984',
+        },
+      ],
+    };
+
+    const identity = resolveOrderIdentity(order);
+
+    expect(identity.externalLabel).toBe('IFOOD');
+    expect(identity.externalId).toBe('3984');
+    expect(identity.primaryText).toBe('#3984');
+    expect(identity.secondaryText).toBe('#71759');
+  });
+
+  it('prioritizes POS externalCode as the main order identity', () => {
+    const order = {
+      id: 71604,
+      app: 'POS',
+      externalCode: '570002',
+    };
+
+    const identity = resolveOrderIdentity(order);
+
+    expect(identity.externalLabel).toBe('');
+    expect(identity.externalId).toBe('570002');
+    expect(identity.primaryText).toBe('Mesa #570002');
+    expect(identity.secondaryText).toBe('#71604');
+    expect(global.t.t).toHaveBeenCalledWith('orders', 'title', 'table');
+  });
+
+  it('uses only the hash-prefixed local id for non-marketplace orders', () => {
+    const order = {
+      id: 70700,
+      app: 'shop',
+    };
+
+    const identity = resolveOrderIdentity(order);
+
+    expect(identity.externalLabel).toBe('');
+    expect(identity.externalId).toBe('');
+    expect(identity.primaryText).toBe('#70700');
+    expect(identity.secondaryText).toBe('');
+  });
+});

package/src/tests/react/utils/remotePayment.test.js

@@ -0,0 +1,62 @@
+const {
+  buildRemotePaymentResultMessage,
+  isRemotePaymentCancellation,
+  normalizeRemotePaymentResultStatus,
+} = require('../../../react/utils/remotePayment')
+
+const {describe, expect, it} = global
+
+describe('remotePayment result status', () => {
+  it.each(['canceled', 'cancelled', 'cancel'])(
+    'normalizes the explicit %s status as a cancellation',
+    status => {
+      expect(normalizeRemotePaymentResultStatus({status})).toBe('canceled')
+      expect(isRemotePaymentCancellation({status})).toBe(true)
+    },
+  )
+
+  it.each([
+    'Pagamento PIX cancelado pelo usuario.',
+    'Pagamento cancelado pelo usuário',
+    'Payment cancelled by user',
+    'Payment canceled by customer',
+  ])('recognizes legacy cancellation errors: %s', error => {
+    const result = {status: 'error', error}
+
+    expect(normalizeRemotePaymentResultStatus(result)).toBe('canceled')
+    expect(isRemotePaymentCancellation(result)).toBe(true)
+  })
+
+  it.each([
+    'Falha de comunicacao com o terminal.',
+    'Nao foi possivel cancelar a transacao.',
+    'Tempo limite excedido.',
+  ])('keeps a real gateway failure as an error: %s', error => {
+    const result = {status: 'error', error}
+
+    expect(normalizeRemotePaymentResultStatus(result)).toBe('error')
+    expect(isRemotePaymentCancellation(result)).toBe(false)
+  })
+
+  it('preserves cancellation when building the remote result message', () => {
+    expect(
+      buildRemotePaymentResultMessage({
+        destinationDeviceId: 'web-7',
+        orderId: 123,
+        requestKey: '123:158:pix:1',
+        status: 'cancelled',
+      }),
+    ).toMatchObject({
+      action: 'pay-result',
+      destination: 'web-7',
+      order: '123',
+      requestKey: '123:158:pix:1',
+      status: 'canceled',
+    })
+  })
+
+  it('keeps successful and unknown results compatible with the existing contract', () => {
+    expect(normalizeRemotePaymentResultStatus({status: 'success'})).toBe('success')
+    expect(normalizeRemotePaymentResultStatus({status: 'unexpected'})).toBe('error')
+  })
+})

package/src/tests/react/utils/runtimeFooter.test.js

@@ -1,6 +1,6 @@
 const assert = require('node:assert/strict')
-const test = require('node:test')
-const {jest, test: jestCompatTest} = require('@jest/globals')
+const {beforeAll, afterAll, test} = global
+const {jest} = require('@jest/globals')
 
 jest.mock('@controleonline/ui-common/src/react/utils/printerDevices', () => ({
   getDeviceTypeLabel: value => String(value || ''),
@@ -43,7 +43,7 @@ const restoreLocation = () => {
   delete globalThis.location
 }
 
-test.before(() => {
+beforeAll(() => {
   global.t = {
     getMessageFromBuckets: (store, type, key) =>
       store === 'common' && type === 'option'
@@ -52,7 +52,7 @@ test.before(() => {
   }
 })
 
-test.after(() => {
+afterAll(() => {
   global.t = originalTranslator
 })
 
@@ -425,5 +425,3 @@ test('falls back to the local device id when the backend identifier is unavailab
   assert.equal(candidates[0]?.value, 'local-device-99')
   assert.equal(candidates[0]?.source, 'device.id')
 })
-
-jestCompatTest('jest compatibility placeholder', () => {})

package/src/tests/react/utils/runtimeLanguage.test.js

@@ -1,5 +1,5 @@
-const assert = require('node:assert/strict')
-const test = require('node:test')
+const assert = require('node:assert/strict')
+const {test} = global
 
 const {
   normalizeLanguageCode,

package/src/tests/react/utils/runtimeMenu.test.js

@@ -157,9 +157,29 @@ describe('runtimeMenu', () => {
     expect(menus[3].menus.map(item => item.route)).toEqual([
       'DevicesIndex',
       'ConfiguratorPage',
-    ]);
-  });
-
+    ]);
+  });
+
+  it('falls back to the admin starter menu when the runtime menu is empty', () => {
+    const menus = normalizeRuntimeMenuResponse({}, {appType: 'ADMIN'});
+
+    expect(menus).toHaveLength(1);
+    expect(menus[0].label).toBe('Configuracoes');
+    expect(menus[0].menus).toHaveLength(2);
+    expect(menus[0].menus[0]).toMatchObject({
+      label: 'Menus por perfil',
+      menuKey: 'menu_access',
+      route: 'MenuAccessConfigPage',
+      menuType: 'home',
+    });
+    expect(menus[0].menus[1]).toMatchObject({
+      label: 'Resultados de testes',
+      menuKey: 'test_results',
+      route: 'TestsPlaygroundPage',
+      menuType: 'home',
+    });
+  });
+
   it('does not invent a fallback menu for non-manager apps', () => {
     expect(
       normalizeRuntimeMenuResponse({}, {appType: 'SHOP'}),

package/src/tests/react/utils/shopConfig.test.js

@@ -0,0 +1,74 @@
+const assert = require('node:assert/strict');
+const {describe, it} = global;
+
+const {
+  resolveShopSettings,
+  SHOP_LOYALTY_STAMP_ICON_URL_CONFIG_KEY,
+  toggleAndSaveBooleanConfig,
+} = require('../../../react/utils/shopConfig');
+
+describe('shopConfig', () => {
+  it('reads the configured loyalty stamp icon URL from general settings', () => {
+    const result = resolveShopSettings({
+      [SHOP_LOYALTY_STAMP_ICON_URL_CONFIG_KEY]:
+        '"https://cdn.example.com/loyalty-stamp.png"',
+    });
+
+    assert.equal(
+      result.loyaltyStampIconUrl,
+      'https://cdn.example.com/loyalty-stamp.png',
+    );
+  });
+
+  it('keeps the loyalty stamp icon URL empty when it is not configured', () => {
+    const result = resolveShopSettings({});
+
+    assert.equal(result.loyaltyStampIconUrl, '');
+  });
+
+  it('persists the next boolean value when a toggle is clicked', async () => {
+    const calls = [];
+    const setValue = value => {
+      calls.push(['setValue', value]);
+    };
+    const saveConfig = async (configKey, value) => {
+      calls.push(['saveConfig', configKey, value]);
+      return true;
+    };
+
+    await toggleAndSaveBooleanConfig({
+      configKey: 'shop-sales-page-enabled',
+      currentValue: false,
+      saveConfig,
+      setValue,
+    });
+
+    assert.deepEqual(calls, [
+      ['setValue', true],
+      ['saveConfig', 'shop-sales-page-enabled', '1'],
+    ]);
+  });
+
+  it('persists the disabled value when toggling an enabled config', async () => {
+    const calls = [];
+    const setValue = value => {
+      calls.push(['setValue', value]);
+    };
+    const saveConfig = async (configKey, value) => {
+      calls.push(['saveConfig', configKey, value]);
+      return true;
+    };
+
+    await toggleAndSaveBooleanConfig({
+      configKey: 'shop-bottom-bar-enabled',
+      currentValue: true,
+      saveConfig,
+      setValue,
+    });
+
+    assert.deepEqual(calls, [
+      ['setValue', false],
+      ['saveConfig', 'shop-bottom-bar-enabled', '0'],
+    ]);
+  });
+});