@controleonline/ui-common 1.2.71 → 1.2.75

package/src/tests/react/api/deviceHeaders.test.js

@@ -0,0 +1,114 @@
+const {afterAll, afterEach, beforeEach, describe, expect, it} = global;
+const {jest} = require('@jest/globals');
+
+jest.mock('react-native', () => ({
+  Platform: {
+    OS: 'web',
+    select: options => options.web || options.default || options.ios || options.android,
+  },
+}));
+
+const originalLocalStorage = global.localStorage;
+
+global.localStorage = {
+  clear: jest.fn(),
+  getItem: jest.fn(() => '{}'),
+  removeItem: jest.fn(),
+  setItem: jest.fn(),
+};
+
+const {api} = require('@controleonline/ui-common/src/api');
+
+describe('device request headers', () => {
+  const originalFetch = global.fetch;
+  const originalGetToken = api.getToken;
+
+  beforeEach(() => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      text: async () => JSON.stringify({'hydra:member': []}),
+    });
+    api.getToken = jest.fn().mockResolvedValue('session-token');
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    api.getToken = originalGetToken;
+    jest.restoreAllMocks();
+  });
+
+  afterAll(() => {
+    global.localStorage = originalLocalStorage;
+  });
+
+  it('sends the operational type from the same runtime device as the identifier', async () => {
+    global.localStorage.getItem.mockImplementation(key => {
+      if (key === 'device') {
+        return JSON.stringify({id: 'web-31477', type: 'PDV'});
+      }
+
+      return '{}';
+    });
+
+    await api.fetch('/product-showcases/catalog', {
+      params: {type: ['service', 'product']},
+    });
+
+    const [, options] = global.fetch.mock.calls[0];
+    expect(options.headers.get('DEVICE')).toBe('web-31477');
+    expect(options.headers.get('DEVICE-TYPE')).toBe('PDV');
+  });
+
+  it('keeps master device identifier and type paired when it is selected', async () => {
+    global.localStorage.getItem.mockImplementation(key => {
+      if (key === 'device') {
+        return JSON.stringify({id: 'web-31477', type: 'MANAGER'});
+      }
+
+      if (key === 'master-device') {
+        return JSON.stringify({id: 'terminal-cielo-01', type: 'PDV'});
+      }
+
+      return '{}';
+    });
+
+    await api.fetch('/product-showcases/catalog');
+
+    const [, options] = global.fetch.mock.calls[0];
+    expect(options.headers.get('DEVICE')).toBe('terminal-cielo-01');
+    expect(options.headers.get('DEVICE-TYPE')).toBe('PDV');
+  });
+
+  it('does not guess a device type when the selected device has none', async () => {
+    global.localStorage.getItem.mockImplementation(key =>
+      key === 'device' ? JSON.stringify({id: 'legacy-device'}) : '{}',
+    );
+
+    await api.fetch('/product-showcases/catalog');
+
+    const [, options] = global.fetch.mock.calls[0];
+    expect(options.headers.get('DEVICE')).toBe('legacy-device');
+    expect(options.headers.get('DEVICE-TYPE')).toBeNull();
+  });
+
+  it('keeps the app domain in the header and removes it from query params', async () => {
+    await api.fetch('/people/company/default?app-domain=loja.exemplo.com.br&existing=1', {
+      params: {
+        'app-domain': 'loja.exemplo.com.br',
+        AppDomain: 'loja.exemplo.com.br',
+        q: 'shop',
+      },
+    });
+
+    const [url, options] = global.fetch.mock.calls[0];
+    const requestUrl = new URL(String(url));
+
+    expect(options.headers.get('App-Domain')).toBeTruthy();
+    expect(requestUrl.searchParams.has('app-domain')).toBe(false);
+    expect(requestUrl.searchParams.has('AppDomain')).toBe(false);
+    expect(requestUrl.searchParams.get('existing')).toBe('1');
+    expect(requestUrl.searchParams.get('q')).toBe('shop');
+  });
+});

package/src/tests/react/components/AddImportModal.test.js

@@ -0,0 +1,166 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+const {jest} = require('@jest/globals');
+
+const {describe, expect, it, beforeEach} = global;
+
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+const importActions = {
+  uploadImportFile: jest.fn(),
+};
+
+jest.mock('@store', () => ({
+  useStore: jest.fn(name => {
+    if (name === 'people') {
+      return {
+        getters: {
+          currentCompany: {id: 7},
+        },
+        actions: {},
+      };
+    }
+
+    if (name === 'imports') {
+      return {
+        getters: {},
+        actions: importActions,
+      };
+    }
+
+    return {
+      getters: {},
+      actions: {},
+    };
+  }),
+}));
+
+jest.mock('@controleonline/ui-common/src/react/components/AnimatedModal', () =>
+  props => (props.visible ? React.createElement('modal', props, props.children) : null),
+);
+
+jest.mock('@controleonline/ui-common/src/react/components/MessageService', () => ({
+  useMessage: () => ({
+    showError: jest.fn(),
+    showSuccess: jest.fn(),
+  }),
+}));
+
+jest.mock('react-native-vector-icons/MaterialIcons', () => props =>
+  React.createElement('icon', props, props.children),
+  {virtual: true},
+);
+
+jest.mock('react-native-vector-icons/Feather', () => props =>
+  React.createElement('icon', props, props.children),
+  {virtual: true},
+);
+
+jest.mock('@controleonline/ui-default/src/react/components/upload/DefaultUpload', () => {
+  const React = require('react');
+
+  return props => {
+    const trigger =
+      typeof props.renderTrigger === 'function'
+        ? props.renderTrigger({
+            openManager: jest.fn(),
+            uploading: false,
+          })
+        : null;
+
+    return React.createElement(
+      'defaultupload',
+      props,
+      trigger,
+      React.createElement(
+        'touchableopacity',
+        {
+          onPress: () =>
+            props.onUploadFile({
+              file: {
+                name: 'import.csv',
+                uri: 'file:///import.csv',
+                mimeType: 'text/csv',
+              },
+            }),
+        },
+        React.createElement('text', null, 'Enviar via gerenciador'),
+      ),
+    );
+  };
+});
+
+jest.mock('react-native', () => ({
+  ActivityIndicator: props => React.createElement('activityindicator', props, props.children),
+  Platform: {OS: 'web'},
+  StyleSheet: {
+    create: value => value,
+  },
+  ScrollView: props => React.createElement('scrollview', props, props.children),
+  Text: props => React.createElement('text', props, props.children),
+  TouchableOpacity: props => React.createElement('touchableopacity', props, props.children),
+  View: props => React.createElement('view', props, props.children),
+}));
+
+const AddImportModal = require('@controleonline/ui-common/src/react/components/AddImportModal').default;
+
+const collectText = node =>
+  node
+    .findAllByType('text')
+    .map(textNode => {
+      const children = textNode.props.children;
+      if (Array.isArray(children)) {
+        return children.flat(Infinity).join('');
+      }
+      return children || '';
+    })
+    .join('');
+
+const findButtonByLabel = (root, label) =>
+  root.findAllByType('touchableopacity').find(button => collectText(button).includes(label));
+
+const findButtonByExactLabel = (root, label) =>
+  root.findAllByType('touchableopacity').find(button => collectText(button) === label);
+
+describe('AddImportModal', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    global.t = {
+      t: (_scope, _kind, key) => key,
+    };
+
+    global.document = undefined;
+  });
+
+  it('usa a action do store imports para enviar o arquivo', async () => {
+    importActions.uploadImportFile.mockResolvedValue({});
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        React.createElement(AddImportModal, {
+          visible: true,
+          onClose: jest.fn(),
+          onSuccess: jest.fn(),
+          context: {context: 'product'},
+        }),
+      );
+    });
+
+    const selectButton = findButtonByLabel(tree.root, 'select_file');
+    expect(selectButton).toBeTruthy();
+
+    const importButton = findButtonByExactLabel(tree.root, 'Enviar via gerenciador');
+    expect(importButton).toBeTruthy();
+
+    await renderer.act(async () => {
+      await importButton.props.onPress();
+    });
+
+    expect(importActions.uploadImportFile).toHaveBeenCalledWith({
+      file: expect.objectContaining({name: 'import.csv'}),
+      importType: 'product',
+      peopleId: 7,
+    });
+  });
+});

package/src/tests/react/components/BottomNavigationBar.config.test.js

@@ -0,0 +1,20 @@
+import {
+  resolveBottomNavigationItems,
+  BOTTOM_NAVIGATION_PRESETS,
+} from '../../../react/components/BottomNavigationBar.config';
+
+describe('BottomNavigationBar.config', () => {
+  it('uses Portuguese fallbacks when translate is missing', () => {
+    const items = resolveBottomNavigationItems(
+      BOTTOM_NAVIGATION_PRESETS.crmToolbar.items,
+      null,
+    );
+    const labels = items.map(i => i.label);
+    expect(labels).toContain('Início');
+    expect(labels).toContain('Clientes');
+    expect(labels).toContain('Perfil');
+    expect(labels).not.toContain('Home');
+    expect(labels).not.toContain('Clients');
+    expect(labels).not.toContain('Profile');
+  });
+});

package/src/tests/react/components/UserAvatar.test.js

@@ -0,0 +1,52 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+const {jest} = require('@jest/globals');
+
+jest.mock('react-native', () => ({
+  Image: props => React.createElement('Image', props),
+  StyleSheet: {
+    create: styles => styles,
+  },
+  Text: props => React.createElement('Text', props, props.children),
+  View: props => React.createElement('View', props, props.children),
+}));
+
+const UserAvatar = require('../../../react/components/UserAvatar').default;
+
+const {describe, expect, it} = global;
+
+describe('UserAvatar', () => {
+  it('renders initials without requesting gravatar when disabled', () => {
+    let tree;
+
+    renderer.act(() => {
+      tree = renderer.create(
+        React.createElement(UserAvatar, {
+          email: 'client@example.com',
+          name: 'Client Test',
+          useGravatar: false,
+        }),
+      );
+    });
+
+    expect(tree.root.findAllByType('Image')).toHaveLength(0);
+    expect(tree.root.findByType('Text').props.children).toBe('CT');
+  });
+
+  it('uses gravatar as fallback when enabled', () => {
+    let tree;
+
+    renderer.act(() => {
+      tree = renderer.create(
+        React.createElement(UserAvatar, {
+          email: 'client@example.com',
+          name: 'Client Test',
+        }),
+      );
+    });
+
+    const image = tree.root.findByType('Image');
+
+    expect(image.props.source.uri).toContain('gravatar.com/avatar/');
+  });
+});

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

@@ -0,0 +1,47 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {test} = require('@jest/globals');
+
+const readFixture = relativePath =>
+  fs.readFileSync(path.resolve(__dirname, relativePath), 'utf8');
+
+test('device detail display pickers keep explicit native styling hooks', () => {
+  const source = readFixture('../../../react/pages/DeviceDetailPage.js');
+  const styles = readFixture('../../../react/pages/DeviceDetailPage.styles.js');
+
+  assert.match(
+    source,
+    /selectedValue=\{linkedDisplayId \|\| ''\}[\s\S]*style=\{styles\.picker\}[\s\S]*dropdownIconColor="#64748B"/,
+  );
+  assert.match(
+    source,
+    /selectedValue=\{displayPrinterId \|\| ''\}[\s\S]*style=\{styles\.picker\}[\s\S]*dropdownIconColor="#64748B"/,
+  );
+  assert.match(
+    source,
+    /selectedValue=\{devicePaymentTarget \|\| ''\}[\s\S]*style=\{styles\.picker\}[\s\S]*dropdownIconColor="#64748B"/,
+  );
+  assert.match(
+    styles,
+    /picker:\s*\{[\s\S]*minHeight:\s*44,[\s\S]*color:\s*'#0F172A'[\s\S]*backgroundColor:\s*'#F8FAFC'/,
+  );
+});
+
+test('printer device detail pickers keep explicit native styling hooks', () => {
+  const source = readFixture('../../../react/pages/PrinterDeviceDetailPage.js');
+  const styles = readFixture('../../../react/pages/PrinterDeviceDetailPage.styles.js');
+
+  assert.match(
+    source,
+    /selectedValue=\{protocol \|\| DEFAULT_NETWORK_CAMERA_PROTOCOL\}[\s\S]*style=\{styles\.picker\}[\s\S]*dropdownIconColor="#64748B"/,
+  );
+  assert.match(
+    source,
+    /selectedValue=\{managerDeviceId \|\| ''\}[\s\S]*style=\{styles\.picker\}[\s\S]*dropdownIconColor="#64748B"/,
+  );
+  assert.match(
+    styles,
+    /picker:\s*\{[\s\S]*minHeight:\s*44,[\s\S]*color:\s*'#0F172A'[\s\S]*backgroundColor:\s*'#F8FAFC'/,
+  );
+});

package/src/tests/react/pages/Devices/deviceListHelpers.test.js

@@ -0,0 +1,39 @@
+/* global describe, expect, it */
+
+const {
+  mergeDeviceConfigs,
+  buildDeviceListParams,
+  PAGE_SIZE,
+} = require('../../../../react/pages/Devices/deviceTypes/deviceListHelpers');
+
+describe('deviceListHelpers', () => {
+  it('mergeDeviceConfigs dedupes by id', () => {
+    const merged = mergeDeviceConfigs(
+      [{id: 1, type: 'PDV'}, {id: 2, type: 'PRINTER'}],
+      [{id: 2, type: 'PRINTER'}, {id: 3, type: 'DISPLAY'}],
+    );
+    expect(merged.map(item => item.id)).toEqual([1, 2, 3]);
+  });
+
+  it('buildDeviceListParams sets people and single type', () => {
+    const params = buildDeviceListParams({
+      companyId: 9,
+      page: 1,
+      pageSize: PAGE_SIZE,
+      queryTypes: ['PDV'],
+    });
+    expect(params.people).toBe('/people/9');
+    expect(params.type).toBe('PDV');
+    expect(params.itemsPerPage).toBe(PAGE_SIZE);
+  });
+
+  it('buildDeviceListParams accepts multiple types', () => {
+    const params = buildDeviceListParams({
+      companyId: 1,
+      page: 2,
+      queryTypes: ['PDV', 'PRINTER'],
+    });
+    expect(params.type).toEqual(['PDV', 'PRINTER']);
+    expect(params.page).toBe(2);
+  });
+});

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/);
+});