@controleonline/ui-common 1.2.70

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

@@ -0,0 +1,93 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+const {jest} = require('@jest/globals');
+
+const {beforeEach, describe, expect, it} = global;
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+const mockSetLauncherMode = jest.fn(() => Promise.resolve({}));
+const mockBackHandlerAddEventListener = jest.fn(() => ({
+  remove: jest.fn(),
+}));
+const mockUseStore = jest.fn(name => {
+  if (name === 'device_config') {
+    return {
+      getters: {
+        item: {
+          configs: {
+            'android-launcher-enabled': '1',
+          },
+        },
+      },
+    };
+  }
+
+  return {
+    getters: {},
+  };
+});
+
+jest.mock('@env', () => ({
+  env: {
+    APP_TYPE: 'POS',
+  },
+}));
+
+jest.mock('@store', () => ({
+  useStore: mockUseStore,
+}));
+
+jest.mock('react-native', () => ({
+  AppState: {
+    currentState: 'active',
+  },
+  BackHandler: {
+    addEventListener: mockBackHandlerAddEventListener,
+  },
+  NativeModules: {
+    LauncherMode: {
+      setLauncherMode: mockSetLauncherMode,
+    },
+  },
+  Platform: {
+    OS: 'android',
+  },
+}));
+
+const LauncherModeBridge =
+  require('../../../react/components/LauncherModeBridge').default;
+
+describe('LauncherModeBridge', () => {
+  beforeEach(() => {
+    mockSetLauncherMode.mockClear();
+    mockBackHandlerAddEventListener.mockClear();
+    mockUseStore.mockClear();
+  });
+
+  it('requests launcher mode on mount and reasserts it after returning active', async () => {
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(React.createElement(LauncherModeBridge));
+    });
+
+    expect(mockSetLauncherMode).toHaveBeenCalledTimes(1);
+    expect(mockSetLauncherMode).toHaveBeenLastCalledWith(true);
+    expect(mockBackHandlerAddEventListener).not.toHaveBeenCalled();
+
+    await renderer.act(async () => {
+      tree.update(React.createElement(LauncherModeBridge, {appState: 'background'}));
+    });
+
+    await renderer.act(async () => {
+      tree.update(React.createElement(LauncherModeBridge, {appState: 'active'}));
+    });
+
+    expect(mockSetLauncherMode).toHaveBeenCalledTimes(2);
+    expect(mockSetLauncherMode).toHaveBeenLastCalledWith(true);
+
+    await renderer.act(async () => {
+      tree.unmount();
+    });
+  });
+});

package/src/tests/react/config/deviceConfigBootstrap.test.js

@@ -0,0 +1,337 @@
+const {jest} = require('@jest/globals')
+
+jest.mock('../../../react/utils/screenMetrics', () => ({
+  appendScreenMetrics: configs => configs,
+  hasScreenMetricsChanges: () => false,
+}))
+
+const {
+  buildProviderManagedDeviceConfigs,
+  DEVICE_ANDROID_KIOSK_ENABLED_CONFIG_KEY,
+  DEVICE_ANDROID_LAUNCHER_ENABLED_CONFIG_KEY,
+  DISPLAY_SIZE_CONFIG_KEY,
+  DISPLAY_SIZE_DEFAULT,
+  DISPLAY_SIZE_MAX,
+  DISPLAY_SIZE_MIN,
+  DISPLAY_SIDE_BREAK_CONFIG_KEY,
+  POS_AUTO_PRINT_ENABLED_CONFIG_KEY,
+  POS_CASH_MANAGEMENT_MODE_CONFIG_KEY,
+  POS_DELIVERY_ENABLED_CONFIG_KEY,
+  POS_OPERATION_MODE_CONFIG_KEY,
+  isPosSingleItemMode,
+  isPosAutoPrintEnabled,
+  isPosCashRegisterClosed,
+  isPosCashRegisterOpen,
+  isPosCounterMode,
+  isAndroidLauncherEnabled,
+  isPosDeliveryEnabled,
+  isPosKioskMode,
+  isPosSelfServiceMode,
+  isDisplaySideBreakEnabled,
+  normalizeDisplaySize,
+  resolveDisplaySize,
+  resolvePosCashManagementMode,
+  resolvePosOperationMode,
+  resolvePosPrintMode,
+  shouldEnableAndroidKioskMode,
+  shouldEnableAndroidLauncherMode,
+  shouldUsePosCashRegisterLifecycle,
+  isPosTotemMode,
+} = require('../../../react/config/deviceConfigBootstrap')
+
+const {describe, expect, it} = global
+
+describe('deviceConfigBootstrap POS operation helpers', () => {
+  it('normalizes balcão as counter and treats counter as self service', () => {
+    const configs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'balcao',
+    }
+
+    expect(resolvePosOperationMode(configs)).toBe('counter')
+    expect(isPosCounterMode(configs)).toBe(true)
+    expect(isPosSelfServiceMode(configs)).toBe(true)
+  })
+
+  it('normalizes venda unitaria as single-item mode', () => {
+    const configs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'venda unitaria',
+    }
+
+    expect(resolvePosOperationMode(configs)).toBe('single-item')
+    expect(isPosSingleItemMode(configs)).toBe(true)
+    expect(isPosSelfServiceMode(configs)).toBe(false)
+  })
+
+  it('keeps counter auto print disabled by default and allows explicit enablement', () => {
+    const counterConfigs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+    }
+
+    expect(isPosAutoPrintEnabled(counterConfigs)).toBe(false)
+
+    expect(
+      isPosAutoPrintEnabled({
+        ...counterConfigs,
+        [POS_AUTO_PRINT_ENABLED_CONFIG_KEY]: '1',
+      }),
+    ).toBe(true)
+  })
+
+  it('defaults non-counter modes to auto print enabled', () => {
+    expect(
+      isPosAutoPrintEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'cashier',
+      }),
+    ).toBe(true)
+  })
+
+  it('resolves counter daily close mode and skips cash register lifecycle', () => {
+    const configs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+      [POS_CASH_MANAGEMENT_MODE_CONFIG_KEY]: 'daily',
+    }
+
+    expect(resolvePosCashManagementMode(configs)).toBe('daily')
+    expect(shouldUsePosCashRegisterLifecycle(configs)).toBe(false)
+    expect(isPosCashRegisterOpen(configs)).toBe(true)
+    expect(isPosCashRegisterClosed(configs)).toBe(false)
+  })
+
+  it('requires cash register lifecycle for counter with open/close policy', () => {
+    const closedConfigs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+      [POS_CASH_MANAGEMENT_MODE_CONFIG_KEY]: 'cash-register',
+      'cash-wallet-closed-id': 1,
+    }
+
+    expect(shouldUsePosCashRegisterLifecycle(closedConfigs)).toBe(true)
+    expect(isPosCashRegisterClosed(closedConfigs)).toBe(true)
+
+    expect(
+      isPosCashRegisterOpen({
+        ...closedConfigs,
+        'cash-wallet-closed-id': 0,
+      }),
+    ).toBe(true)
+  })
+
+  it('keeps empty configs open until the runtime loads the real cash register state', () => {
+    expect(isPosCashRegisterOpen({})).toBe(true)
+    expect(isPosCashRegisterClosed({})).toBe(false)
+  })
+
+  it('keeps configs without cash-wallet-closed-id open during provider bootstrap', () => {
+    const configs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'cashier',
+      'config-version': '1.0.0',
+      'pos-gateway': 'cielo',
+    }
+
+    expect(isPosCashRegisterOpen(configs)).toBe(true)
+    expect(isPosCashRegisterClosed(configs)).toBe(false)
+  })
+
+  it('preserves a manually configured pos gateway during provider sync', () => {
+    const {nextConfigs, needsUpdate} = buildProviderManagedDeviceConfigs({
+      appVersion: '1.3.74',
+      configs: {
+        'config-version': '1.3.74',
+        'pos-gateway': 'cielo',
+      },
+      deviceInfo: {
+        isEmulator: true,
+        manufacturer: 'Google',
+      },
+    })
+
+    expect(nextConfigs['pos-gateway']).toBe('cielo')
+    expect(needsUpdate).toBe(false)
+  })
+
+  it('keeps totem without cash register lifecycle and normalizes print mode', () => {
+    const configs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'totem',
+      'print-mode': 'form',
+    }
+
+    expect(resolvePosOperationMode(configs)).toBe('totem')
+    expect(isPosTotemMode(configs)).toBe(true)
+    expect(isPosKioskMode(configs)).toBe(true)
+    expect(shouldUsePosCashRegisterLifecycle(configs)).toBe(false)
+    expect(resolvePosPrintMode(configs)).toBe('form')
+  })
+
+  it('does not accept the legacy kiosk operation mode value', () => {
+    expect(
+      resolvePosOperationMode({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'kiosk',
+      }),
+    ).toBe('')
+    expect(
+      isPosTotemMode({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'kiosk',
+      }),
+    ).toBe(false)
+    expect(
+      isPosKioskMode({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'kiosk',
+      }),
+    ).toBe(false)
+  })
+
+  it('defaults display size to 5 and clamps the configured range to 1..10', () => {
+    expect(resolveDisplaySize({})).toBe(DISPLAY_SIZE_DEFAULT)
+    expect(
+      resolveDisplaySize({
+        [DISPLAY_SIZE_CONFIG_KEY]: '1',
+      }),
+    ).toBe(DISPLAY_SIZE_MIN)
+    expect(
+      normalizeDisplaySize('18'),
+    ).toBe(DISPLAY_SIZE_MAX)
+  })
+
+  it('treats display side break as an explicit boolean flag', () => {
+    expect(isDisplaySideBreakEnabled({})).toBe(false)
+    expect(
+      isDisplaySideBreakEnabled({
+        [DISPLAY_SIDE_BREAK_CONFIG_KEY]: '1',
+      }),
+    ).toBe(true)
+  })
+
+  it('does not enable Android kiosk without the explicit device flag', () => {
+    expect(
+      shouldEnableAndroidKioskMode({
+        appType: 'POS',
+        configs: {
+          [POS_OPERATION_MODE_CONFIG_KEY]: 'totem',
+        },
+        platform: 'android',
+      }),
+    ).toBe(false)
+
+    expect(
+      shouldEnableAndroidKioskMode({
+        appType: 'POS',
+        configs: {
+          [POS_OPERATION_MODE_CONFIG_KEY]: 'totem',
+        },
+        platform: 'android',
+      }),
+    ).toBe(false)
+  })
+
+  it('respects the explicit Android kiosk flag independently of the operation mode', () => {
+    expect(
+      shouldEnableAndroidKioskMode({
+        appType: 'POS',
+        configs: {
+          [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+          [DEVICE_ANDROID_KIOSK_ENABLED_CONFIG_KEY]: '1',
+        },
+        platform: 'android',
+      }),
+    ).toBe(true)
+
+    expect(
+      shouldEnableAndroidKioskMode({
+        appType: 'POS',
+        configs: {
+          [POS_OPERATION_MODE_CONFIG_KEY]: 'totem',
+          [DEVICE_ANDROID_KIOSK_ENABLED_CONFIG_KEY]: '0',
+        },
+        platform: 'android',
+      }),
+    ).toBe(false)
+
+    expect(
+      shouldEnableAndroidKioskMode({
+        appType: 'MANAGER',
+        configs: {
+          [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+          [DEVICE_ANDROID_KIOSK_ENABLED_CONFIG_KEY]: '1',
+        },
+        platform: 'android',
+      }),
+    ).toBe(false)
+
+    expect(
+      shouldEnableAndroidKioskMode({
+        appType: 'POS',
+        configs: {
+          [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+          [DEVICE_ANDROID_KIOSK_ENABLED_CONFIG_KEY]: '1',
+        },
+        platform: 'web',
+      }),
+    ).toBe(false)
+  })
+
+  it('does not enable Android launcher without the explicit device flag', () => {
+    expect(
+      isAndroidLauncherEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'totem',
+      }),
+    ).toBe(false)
+
+    expect(
+      shouldEnableAndroidLauncherMode({
+        appType: 'POS',
+        configs: {
+          [POS_OPERATION_MODE_CONFIG_KEY]: 'totem',
+        },
+        platform: 'android',
+      }),
+    ).toBe(false)
+  })
+
+  it('respects the explicit Android launcher flag independently of the operation mode', () => {
+    expect(
+      shouldEnableAndroidLauncherMode({
+        appType: 'POS',
+        configs: {
+          [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+          [DEVICE_ANDROID_LAUNCHER_ENABLED_CONFIG_KEY]: '1',
+        },
+        platform: 'android',
+      }),
+    ).toBe(true)
+
+    expect(
+      shouldEnableAndroidLauncherMode({
+        appType: 'MANAGER',
+        configs: {
+          [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+          [DEVICE_ANDROID_LAUNCHER_ENABLED_CONFIG_KEY]: '1',
+        },
+        platform: 'android',
+      }),
+    ).toBe(false)
+
+    expect(
+      shouldEnableAndroidLauncherMode({
+        appType: 'POS',
+        configs: {
+          [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+          [DEVICE_ANDROID_LAUNCHER_ENABLED_CONFIG_KEY]: '1',
+        },
+        platform: 'web',
+      }),
+    ).toBe(false)
+  })
+
+  it('keeps delivery enabled by default and respects explicit disablement', () => {
+    expect(isPosDeliveryEnabled({})).toBe(true)
+    expect(
+      isPosDeliveryEnabled({
+        [POS_DELIVERY_ENABLED_CONFIG_KEY]: '0',
+      }),
+    ).toBe(false)
+    expect(
+      isPosDeliveryEnabled({
+        [POS_DELIVERY_ENABLED_CONFIG_KEY]: '1',
+      }),
+    ).toBe(true)
+  })
+})

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

@@ -0,0 +1,45 @@
+const {jest} = require('@jest/globals')
+
+const mockPrint = jest.fn()
+
+jest.mock('@controleonline/ui-orders/src/react/services/Cielo/Print', () => ({
+  CieloPrint: jest.fn().mockImplementation(() => ({
+    print: mockPrint,
+  })),
+}))
+
+const {describe, expect, it, beforeEach} = global
+
+const {
+  LOCAL_CIELO_PRINT_UNAVAILABLE_MESSAGE,
+  printOnLocalCielo,
+} = require('../../../react/print/providers/local')
+
+describe('local print provider', () => {
+  beforeEach(() => {
+    mockPrint.mockReset()
+  })
+
+  it('normalizes missing local Cielo handler errors', async () => {
+    mockPrint.mockResolvedValue({
+      success: false,
+      result:
+        'No Activity found to handle Intent { act=android.intent.action.VIEW dat=lio://print/... }',
+    })
+
+    await expect(printOnLocalCielo('payload')).rejects.toThrow(
+      LOCAL_CIELO_PRINT_UNAVAILABLE_MESSAGE,
+    )
+  })
+
+  it('keeps explicit provider error messages when available', async () => {
+    mockPrint.mockResolvedValue({
+      success: false,
+      result: 'Papel ausente.',
+    })
+
+    await expect(printOnLocalCielo('payload')).rejects.toThrow(
+      'Papel ausente.',
+    )
+  })
+})

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

@@ -0,0 +1,123 @@
+const {jest} = require('@jest/globals');
+
+const {
+  syncBackgroundRuntimeRegistration,
+} = require('../../../react/utils/backgroundRuntimeRegistration');
+
+const {describe, expect, it, beforeEach} = global;
+
+const buildModule = () => ({
+  clearRegistration: jest.fn(() => Promise.resolve('removed')),
+  syncRegistration: jest.fn(() => Promise.resolve('started')),
+});
+
+const buildRefs = () => ({
+  lastRegistrationIdRef: {current: ''},
+  lastRegistrationPayloadRef: {current: ''},
+});
+
+describe('backgroundRuntimeRegistration lifecycle', () => {
+  let backgroundRuntimeModule;
+
+  beforeEach(() => {
+    backgroundRuntimeModule = buildModule();
+  });
+
+  it('syncs a valid registration and does not create an unmount cleanup', () => {
+    const refs = buildRefs();
+
+    const result = syncBackgroundRuntimeRegistration({
+      backgroundRuntimeModule,
+      registration: {
+        registrationId: 'com.controleonline.manager::device-1::company-1',
+        packageName: 'com.controleonline.manager',
+        companyId: 'company-1',
+        deviceId: 'device-1',
+        backgroundEnabled: true,
+        socketUrl: 'wss://example.test/socket',
+        token: 'session-token',
+      },
+      ...refs,
+    });
+
+    expect(result).toBeUndefined();
+    expect(backgroundRuntimeModule.syncRegistration).toHaveBeenCalledTimes(1);
+    expect(backgroundRuntimeModule.clearRegistration).not.toHaveBeenCalled();
+    expect(refs.lastRegistrationIdRef.current).toBe(
+      'com.controleonline.manager::device-1::company-1',
+    );
+  });
+
+  it('clears the registration when the session becomes invalid', () => {
+    const refs = buildRefs();
+    const registration = {
+      registrationId: 'com.controleonline.manager::device-1::company-1',
+      packageName: 'com.controleonline.manager',
+      companyId: 'company-1',
+      deviceId: 'device-1',
+      backgroundEnabled: true,
+      socketUrl: 'wss://example.test/socket',
+      token: 'session-token',
+    };
+
+    syncBackgroundRuntimeRegistration({
+      backgroundRuntimeModule,
+      registration,
+      ...refs,
+    });
+
+    expect(backgroundRuntimeModule.syncRegistration).toHaveBeenCalledTimes(1);
+    expect(backgroundRuntimeModule.clearRegistration).not.toHaveBeenCalled();
+
+    syncBackgroundRuntimeRegistration({
+      backgroundRuntimeModule,
+      registration: null,
+      ...refs,
+    });
+
+    expect(backgroundRuntimeModule.clearRegistration).toHaveBeenCalledTimes(1);
+    expect(backgroundRuntimeModule.clearRegistration).toHaveBeenCalledWith(
+      'com.controleonline.manager::device-1::company-1',
+    );
+  });
+
+  it('replaces the previous registration when the company changes', () => {
+    const refs = buildRefs();
+
+    syncBackgroundRuntimeRegistration({
+      backgroundRuntimeModule,
+      registration: {
+        registrationId: 'com.controleonline.manager::device-1::company-1',
+        packageName: 'com.controleonline.manager',
+        companyId: 'company-1',
+        deviceId: 'device-1',
+        backgroundEnabled: true,
+        socketUrl: 'wss://example.test/socket',
+        token: 'session-token',
+      },
+      ...refs,
+    });
+
+    syncBackgroundRuntimeRegistration({
+      backgroundRuntimeModule,
+      registration: {
+        registrationId: 'com.controleonline.manager::device-1::company-2',
+        packageName: 'com.controleonline.manager',
+        companyId: 'company-2',
+        deviceId: 'device-1',
+        backgroundEnabled: true,
+        socketUrl: 'wss://example.test/socket',
+        token: 'session-token',
+      },
+      ...refs,
+    });
+
+    expect(backgroundRuntimeModule.clearRegistration).toHaveBeenCalledWith(
+      'com.controleonline.manager::device-1::company-1',
+    );
+    expect(backgroundRuntimeModule.syncRegistration).toHaveBeenCalledTimes(2);
+    expect(refs.lastRegistrationIdRef.current).toBe(
+      'com.controleonline.manager::device-1::company-2',
+    );
+  });
+});

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

@@ -0,0 +1,41 @@
+const {
+  isGatewayFreePayment,
+  shouldBypassGatewayForPayment,
+} = require('../../../react/utils/cashPayment')
+
+const {describe, expect, it} = global
+
+describe('cashPayment gateway bypass rules', () => {
+  it('treats DINHEIRO as a gateway-free payment even when a payment code exists', () => {
+    const payment = {
+      wallet: {id: 1},
+      paymentCode: 'DINHEIRO',
+      paymentType: {id: 22, paymentType: 'Dinheiro'},
+    }
+
+    expect(shouldBypassGatewayForPayment(payment)).toBe(true)
+    expect(isGatewayFreePayment(payment)).toBe(true)
+  })
+
+  it('treats courtesy voucher as a gateway-free payment', () => {
+    const payment = {
+      wallet: {id: 1},
+      paymentCode: 'VOUCHER_CORTESIA',
+      paymentType: {id: 12, paymentType: 'Cartão Gratidão'},
+    }
+
+    expect(shouldBypassGatewayForPayment(payment)).toBe(true)
+    expect(isGatewayFreePayment(payment)).toBe(true)
+  })
+
+  it('keeps card payments integrated when they have a real gateway code', () => {
+    const payment = {
+      wallet: {id: 1},
+      paymentCode: 'CREDITO_AVISTA',
+      paymentType: {id: 8, paymentType: 'Crédito à Vista'},
+    }
+
+    expect(shouldBypassGatewayForPayment(payment)).toBe(false)
+    expect(isGatewayFreePayment(payment)).toBe(false)
+  })
+})

package/src/tests/react/utils/dateRangeFilter.test.mjs

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  buildDateFilterOptions,
+  getDateRange,
+  resolveDateRangeSummary,
+} from '../../../react/utils/dateRangeFilter.js';
+
+test('keeps 90d available in the shared date filter contract', () => {
+  const baseDate = new Date(2026, 5, 8, 12, 0, 0, 0);
+
+  assert.deepEqual(buildDateFilterOptions(['90d']), [
+    { key: '90d', label: '90 dias' },
+  ]);
+
+  assert.deepEqual(
+    getDateRange('90d', null, { baseDate }),
+    {
+      after: '2026-03-11 00:00:00',
+      before: '2026-06-08 23:59:59',
+    },
+  );
+
+  assert.equal(
+    resolveDateRangeSummary('90d', null, { baseDate }),
+    '11/03/2026 - 08/06/2026',
+  );
+});

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

@@ -0,0 +1,18 @@
+const {describe, expect, it} = global;
+
+const {
+  formatDisplayUppercase,
+  uppercaseText,
+} = require('../../../react/utils/entityDisplay');
+
+describe('entityDisplay helpers', () => {
+  it('uppercases raw text with accented characters correctly', () => {
+    expect(uppercaseText('Cláudia')).toBe('CLÁUDIA');
+    expect(uppercaseText('Kibelicia Comida árabe')).toBe('KIBELICIA COMIDA ÁRABE');
+  });
+
+  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');
+  });
+});