@controleonline/ui-common 1.2.70 → 1.2.75

package/src/tests/react/pages/DevicesCurrentDevice.test.js

@@ -0,0 +1,198 @@
+/* global describe, expect, it, jest */
+
+jest.mock(
+  '@controleonline/ui-common/src/react/utils/printerDevices',
+  () => ({
+    PDV_DEVICE_TYPE: 'PDV',
+    normalizeDeviceType: value =>
+      String(value || '')
+        .trim()
+        .toUpperCase(),
+  }),
+);
+
+jest.mock(
+  '@controleonline/ui-common/src/react/utils/paymentDevices',
+  () => ({
+    normalizeDeviceId: value => String(value || '').trim(),
+    normalizeEntityId: value =>
+      String(value || '')
+        .replace(/\D+/g, '')
+        .trim(),
+  }),
+);
+
+const {
+  findDeviceConfigByType,
+  filterDeviceConfigsByTypes,
+  getRuntimeDeviceIdentifier,
+  groupDeviceConfigs,
+  hasCurrentPdvConfig,
+  isCurrentDeviceConfig,
+  isCurrentDeviceGroup,
+  prioritizeCurrentDeviceGroups,
+  prioritizeCurrentDeviceConfigs,
+  readStoredRuntimeDevice,
+} = require('../../../react/pages/Devices/currentDevice');
+
+const currentManager = {
+  id: 487,
+  type: 'MANAGER',
+  device: {
+    id: 396,
+    device: '0d1bea46f3d93f07',
+    alias: 'Caixa',
+  },
+};
+
+const currentPdv = {
+  id: 488,
+  type: 'PDV',
+  device: {
+    id: 396,
+    device: '0d1bea46f3d93f07',
+    alias: 'Caixa',
+  },
+};
+
+const remotePdv = {
+  id: 410,
+  type: 'PDV',
+  device: {
+    id: 380,
+    device: '61378bea41ff1712',
+    alias: 'Outro caixa',
+  },
+};
+
+describe('current device profiles', () => {
+  it('reads the runtime identity from persisted device storage', () => {
+    const storage = {
+      getItem: jest.fn(() =>
+        JSON.stringify({
+          id: '0d1bea46f3d93f07',
+          type: 'MANAGER',
+        }),
+      ),
+    };
+
+    const runtimeDevice = readStoredRuntimeDevice(storage);
+
+    expect(getRuntimeDeviceIdentifier(runtimeDevice)).toBe(
+      '0d1bea46f3d93f07',
+    );
+  });
+
+  it('does not fail when persisted device storage is invalid', () => {
+    const storage = {
+      getItem: jest.fn(() => '{invalid'),
+    };
+
+    expect(readStoredRuntimeDevice(storage)).toEqual({});
+  });
+
+  it('recognizes every operational profile of the same physical device', () => {
+    const runtimeDeviceIdentifier = '0d1bea46f3d93f07';
+
+    expect(
+      isCurrentDeviceConfig({
+        deviceConfig: currentManager,
+        runtimeDeviceIdentifier,
+      }),
+    ).toBe(true);
+    expect(
+      isCurrentDeviceConfig({
+        deviceConfig: currentPdv,
+        runtimeDeviceIdentifier,
+      }),
+    ).toBe(true);
+    expect(
+      isCurrentDeviceConfig({
+        deviceConfig: remotePdv,
+        runtimeDeviceIdentifier,
+      }),
+    ).toBe(false);
+  });
+
+  it('pins all current profiles before remote devices without changing their order', () => {
+    expect(
+      prioritizeCurrentDeviceConfigs(
+        [remotePdv, currentManager, currentPdv],
+        '0d1bea46f3d93f07',
+      ).map(item => item.id),
+    ).toEqual([487, 488, 410]);
+  });
+
+  it('keeps only current PDV profiles when the PDV filter is active', () => {
+    expect(
+      filterDeviceConfigsByTypes(
+        [currentManager, currentPdv],
+        ['PDV'],
+      ).map(item => item.id),
+    ).toEqual([488]);
+  });
+
+  it('offers PDV setup only until the current physical device has a PDV profile', () => {
+    expect(
+      hasCurrentPdvConfig(
+        [currentManager, remotePdv],
+        '0d1bea46f3d93f07',
+      ),
+    ).toBe(false);
+    expect(
+      hasCurrentPdvConfig(
+        [currentManager, currentPdv, remotePdv],
+        '0d1bea46f3d93f07',
+      ),
+    ).toBe(true);
+  });
+
+  it('groups every configuration of the same Device into one card', () => {
+    const groups = groupDeviceConfigs([
+      remotePdv,
+      currentManager,
+      currentPdv,
+    ]);
+
+    expect(groups).toHaveLength(2);
+    expect(groups.find(group => group.key === 'device:396').deviceConfigs)
+      .toEqual([currentManager, currentPdv]);
+  });
+
+  it('pins the current Device once and resolves the session configuration by type', () => {
+    const groups = prioritizeCurrentDeviceGroups(
+      groupDeviceConfigs([remotePdv, currentManager, currentPdv]),
+      '0d1bea46f3d93f07',
+    );
+
+    expect(groups[0].key).toBe('device:396');
+    expect(
+      isCurrentDeviceGroup({
+        deviceGroup: groups[0],
+        runtimeDeviceIdentifier: '0d1bea46f3d93f07',
+      }),
+    ).toBe(true);
+    expect(findDeviceConfigByType(groups[0], 'PDV')).toBe(currentPdv);
+  });
+
+  it('creates a synthetic current Device group when it has no configuration yet', () => {
+    const groups = groupDeviceConfigs([remotePdv], {
+      includeRuntimeDevice: true,
+      runtimeDevice: {
+        id: 'new-device',
+        alias: 'Nova maquininha',
+        type: 'MANAGER',
+      },
+    });
+
+    expect(groups).toHaveLength(2);
+    expect(groups[1]).toMatchObject({
+      key: 'identifier:new-device',
+      device: {
+        device: 'new-device',
+        alias: 'Nova maquininha',
+      },
+      deviceConfigs: [],
+    });
+  });
+});

package/src/tests/react/pages/connectionsHelpers.test.js

@@ -0,0 +1,34 @@
+/* global describe, expect, it */
+
+describe('connections phone/status helpers (migration #288)', () => {
+  const formatPhoneLabel = phone => {
+    if (!phone) return 'Nao informado';
+    if (typeof phone === 'string') return phone;
+    const ddd = String(phone?.ddd || '').trim();
+    const digits = String(phone?.phone || '').replace(/\D/g, '');
+    if (!ddd && !digits) return 'Nao informado';
+    if (!digits) return `(${ddd})`;
+    const lastFour = digits.slice(-4);
+    const firstPart = digits.slice(0, -4);
+    if (!firstPart) return ddd ? `(${ddd}) ${lastFour}` : lastFour;
+    return ddd ? `(${ddd}) ${firstPart}-${lastFour}` : `${firstPart}-${lastFour}`;
+  };
+
+  const formatStatusLabel = status => {
+    if (!status) return '—';
+    if (typeof status === 'string') return status;
+    return status?.status || status?.name || '—';
+  };
+
+  it('formats phone objects', () => {
+    expect(formatPhoneLabel({ddd: '11', phone: '988887777'})).toBe('(11) 98888-7777');
+  });
+
+  it('handles missing phone', () => {
+    expect(formatPhoneLabel(null)).toBe('Nao informado');
+  });
+
+  it('formats status objects', () => {
+    expect(formatStatusLabel({status: 'connected'})).toBe('connected');
+  });
+});

package/src/tests/react/pages/mercadoLivreIntegrationPageContract.test.mjs

@@ -0,0 +1,16 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import test from 'node:test';
+
+const pagePath = resolve('modules/controleonline/ui-common/src/react/pages/MercadoLivreIntegrationPage.js');
+const pageSource = readFileSync(pagePath, 'utf8');
+
+test('MercadoLivreIntegrationPage keeps the backend contract for connect and import actions', () => {
+  assert.match(pageSource, /\/marketplace\/integrations\/mercadolivre\/authorization-page/);
+  assert.match(pageSource, /\/marketplace\/integrations\/mercadolivre\/products\/import/);
+  assert.match(pageSource, /provider_id/);
+  assert.match(pageSource, /showcase_id/);
+  assert.doesNotMatch(pageSource, /callback_url/);
+  assert.doesNotMatch(pageSource, /mercadolivre\/oauth\/return/);
+});

package/src/tests/react/print/localPrintProvider.test.js

@@ -2,7 +2,7 @@ const {jest} = require('@jest/globals')
 
 const mockPrint = jest.fn()
 
-jest.mock('@controleonline/ui-orders/src/react/services/Cielo/Print', () => ({
+jest.mock('../../../react/services/Cielo/Print', () => ({
   CieloPrint: jest.fn().mockImplementation(() => ({
     print: mockPrint,
   })),

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/store/categoriesOrdering.test.js

@@ -0,0 +1,26 @@
+/* global jest */
+jest.mock('@controleonline/ui-default/src/store/default/actions', () => ({}))
+jest.mock('@controleonline/ui-default/src/store/default/getters', () => ({}))
+jest.mock('@controleonline/ui-default/src/store/default/mutations', () => ({
+  __esModule: true,
+  default: {},
+}))
+
+const categoriesStore = require('../../../store/categories').default
+
+const {describe, expect, it} = global
+
+describe('categories store ordering', () => {
+  it('exposes the canonical order as the editable default table sort', () => {
+    const column = categoriesStore.state.columns.find(item => item.name === 'sortOrder')
+
+    expect(column).toMatchObject({
+      defaultSort: 'ASC',
+      editable: true,
+      inputType: 'number',
+      sortable: true,
+    })
+    expect(column.saveFormat(0)).toBe(0)
+    expect(column.saveFormat('')).toBeNull()
+  })
+})

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

@@ -0,0 +1,62 @@
+const {describe, expect, it} = global
+
+const {resolveAppDomain} = require('../../../utils/appDomain')
+
+describe('resolveAppDomain', () => {
+  const withLocation = (host, fn) => {
+    const previousLocation = Object.getOwnPropertyDescriptor(global, 'location')
+    try {
+      Object.defineProperty(global, 'location', {
+        configurable: true,
+        value: {host},
+      })
+      fn()
+    } finally {
+      if (previousLocation) {
+        Object.defineProperty(global, 'location', previousLocation)
+      } else {
+        delete global.location
+      }
+    }
+  }
+
+  it('ignores invalid configured domain values and uses the runtime host', () => {
+    withLocation('erp.exemplo.com.br', () => {
+      expect(resolveAppDomain('undefined')).toBe('erp.exemplo.com.br')
+      expect(resolveAppDomain('null')).toBe('erp.exemplo.com.br')
+      expect(resolveAppDomain('false')).toBe('erp.exemplo.com.br')
+    })
+  })
+
+  it('prefers window.location.host over configured DOMAIN (multi-tenant web)', () => {
+    withLocation('erpjaguncos.com.br', () => {
+      expect(resolveAppDomain('https://app.controleonline.com')).toBe(
+        'erpjaguncos.com.br',
+      )
+      expect(resolveAppDomain('app.controleonline.com')).toBe(
+        'erpjaguncos.com.br',
+      )
+    })
+  })
+
+  it('uses configured domain when there is no runtime location (native)', () => {
+    const previousLocation = Object.getOwnPropertyDescriptor(global, 'location')
+    try {
+      Object.defineProperty(global, 'location', {
+        configurable: true,
+        value: undefined,
+      })
+      // resolveRuntimeHost returns '' when location is undefined
+      expect(resolveAppDomain('https://app.controleonline.com')).toBe(
+        'app.controleonline.com',
+      )
+      expect(resolveAppDomain('app.controleonline.com')).toBe(
+        'app.controleonline.com',
+      )
+    } finally {
+      if (previousLocation) {
+        Object.defineProperty(global, 'location', previousLocation)
+      }
+    }
+  })
+})

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

@@ -12,7 +12,7 @@ describe('entityDisplay helpers', () => {
   });
 
   it('uppercases pt-BR strings with cedilla correctly', () => {
-    expect(formatDisplayUppercase('Jagunços')).toBe('JAGUNÇOS');
-    expect(formatDisplayUppercase('Empório Jagunços Ltda')).toBe('EMPÓRIO JAGUNÇOS LTDA');
+    expect(formatDisplayUppercase('Empresa Exemplo')).toBe('EMPRESA EXEMPLO');
+    expect(formatDisplayUppercase('Empresa Exemplo Ltda')).toBe('EMPRESA EXEMPLO LTDA');
   });
 });

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('uses path app-domain for 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/maincompany.controleonline.com/files/3/download',
+      headers: {
+        Authorization: 'Bearer token',
+        'app-domain': 'maincompany.controleonline.com',
+      },
+    });
+    expect(resolveFileImageUrl(3, {company})).toBe(
+      'https://api.controleonline.com/maincompany.controleonline.com/files/3/download',
+    );
+  });
+
+  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/formatter.test.mjs

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import Formatter from '../../../utils/formatter.js';
+
+test('formats API datetimes using the numeric offset returned by the backend', () => {
+  assert.equal(
+    Formatter.formatDateYmdTodmY('2026-07-22T00:00:00-02:00'),
+    '22/07/2026',
+  );
+
+  assert.equal(
+    Formatter.formatDateYmdTodmY('2026-07-22T22:34:22-02:00', true),
+    '22/07/2026, 22:34:22',
+  );
+
+  assert.equal(
+    Formatter.formatDateYmdTodmY('2026-07-22T21:34:22-03:00', true),
+    '22/07/2026, 21:34:22',
+  );
+});
+
+test('repairs mojibake from API text payloads', () => {
+  assert.equal(
+    Formatter.repairMojibake('Não, saída, cobrança, garçom, conferência'),
+    'Não, saída, cobrança, garçom, conferência',
+  );
+
+  assert.equal(
+    Formatter.repairMojibake('Produção entrada → trabalhando → pronto'),
+    'Produção entrada → trabalhando → pronto',
+  );
+});

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,