@controleonline/ui-common 1.2.70

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

@@ -0,0 +1,32 @@
+const {
+  GOOGLE_MAPS_ANDROID_API_KEY_CONFIG_KEY,
+  GOOGLE_MAPS_WEB_API_KEY_CONFIG_KEY,
+  resolveGoogleMapsSettings,
+} = require('../../../react/utils/googleMapsConfig');
+
+const {describe, expect, it} = global;
+
+describe('googleMapsConfig', () => {
+  it('ignores legacy map keys and keeps the dedicated keys empty', () => {
+    expect(
+      resolveGoogleMapsSettings({
+        'shop-google-maps-api-key': '"legacy-key"',
+      }),
+    ).toEqual({
+      webGoogleMapsApiKey: '',
+      androidGoogleMapsApiKey: '',
+    });
+  });
+
+  it('reads the dedicated web and android keys', () => {
+    expect(
+      resolveGoogleMapsSettings({
+        [GOOGLE_MAPS_WEB_API_KEY_CONFIG_KEY]: '"web-key"',
+        [GOOGLE_MAPS_ANDROID_API_KEY_CONFIG_KEY]: '"android-key"',
+      }),
+    ).toEqual({
+      webGoogleMapsApiKey: 'web-key',
+      androidGoogleMapsApiKey: 'android-key',
+    });
+  });
+});

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

@@ -0,0 +1,85 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+
+const {
+  getImportErrorDetail,
+  getImportStatusMeta,
+  normalizeImportStatus,
+  resolveImportLabels,
+  resolveImportStatusLabel,
+} = require('@controleonline/ui-common/src/react/utils/importStatus')
+
+test('normalizeImportStatus trims and lowercases the raw value', () => {
+  assert.equal(normalizeImportStatus('  Processing '), 'processing')
+})
+
+test('getImportStatusMeta keeps queued imports flagged as processing', () => {
+  const result = getImportStatusMeta({
+    status: {
+      status: 'queued',
+    },
+  })
+
+  assert.equal(result.isProcessing, true)
+  assert.equal(result.isError, false)
+  assert.equal(result.labelKey, 'processing')
+})
+
+test('getImportStatusMeta treats invalid imports as errors', () => {
+  const result = getImportStatusMeta({
+    status: {
+      realStatus: 'invalid',
+    },
+  })
+
+  assert.equal(result.isProcessing, false)
+  assert.equal(result.isError, true)
+  assert.equal(result.labelKey, 'error')
+})
+
+test('getImportErrorDetail returns the first non-empty message candidate', () => {
+  assert.equal(
+    getImportErrorDetail({
+      error: '  ',
+      status: {
+        description: 'Arquivo fora do padrão',
+      },
+      message: 'Mensagem menos específica',
+    }),
+    'Arquivo fora do padrão',
+  )
+})
+
+test('resolveImportLabels only reads translation keys without hardcoded fallbacks', () => {
+  const calls = []
+  const labels = resolveImportLabels((...args) => {
+    calls.push(args)
+    return args.join('.')
+  })
+
+  assert.deepEqual(calls, [
+    ['imports', 'button', 'refresh'],
+    ['imports', 'status', 'processing'],
+    ['imports', 'status', 'error'],
+    ['imports', 'status', 'done'],
+    ['imports', 'status', 'no_status'],
+    ['imports', 'message', 'processing_after_upload'],
+  ])
+  assert.equal(labels.refreshLabel, 'imports.button.refresh')
+  assert.equal(labels.processingHelpLabel, 'imports.message.processing_after_upload')
+})
+
+test('resolveImportStatusLabel falls back to the raw backend status before the generic empty label', () => {
+  assert.equal(
+    resolveImportStatusLabel(
+      {
+        labelKey: 'fallback',
+        rawStatus: 'sincronizando',
+      },
+      {
+        noStatusLabel: 'sem status',
+      },
+    ),
+    'sincronizando',
+  )
+})

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

@@ -0,0 +1,40 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import invoicePresentation from '../../../react/utils/invoicePresentation.js';
+
+const {
+  formatInvoiceTypeLabel,
+  getInvoicePaymentTypeLabel,
+  getInvoicePartyLabel,
+  normalizeInvoiceType,
+} = invoicePresentation;
+
+test('normalizes invoice type and falls back to invoice', () => {
+  assert.equal(normalizeInvoiceType(' PAYMENT '), 'payment');
+  assert.equal(normalizeInvoiceType(''), 'invoice');
+});
+
+test('formats canonical invoice types with stable labels', () => {
+  assert.equal(formatInvoiceTypeLabel('discount'), 'Discount');
+  assert.equal(formatInvoiceTypeLabel('service_fee'), 'Service Fee');
+});
+
+test('reads payment type and party labels from invoice payloads', () => {
+  assert.equal(
+    getInvoicePaymentTypeLabel({
+      paymentType: {
+        paymentType: 'Credito',
+      },
+    }),
+    'Credito',
+  );
+
+  assert.equal(
+    getInvoicePartyLabel({
+      alias: 'BRUNA',
+      name: 'Bruna Silva',
+    }),
+    'BRUNA',
+  );
+});

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

@@ -0,0 +1,127 @@
+const {jest} = require('@jest/globals');
+
+jest.mock('react-native', () => ({
+  Platform: {
+    OS: 'web',
+  },
+}));
+
+const {
+  applyManagerOrderNotificationPreferences,
+  buildManagerOrderNotificationContent,
+  ensureManagerOrderNotificationPermission,
+  hasStoredManagerOrderNotificationPreferences,
+  isManagerAppType,
+  resolveManagerOrderNotificationPreferences,
+} = require('../../../react/utils/managerOrderNotifications');
+
+const {describe, expect, it} = global;
+
+describe('managerOrderNotifications helpers', () => {
+  it('defaults push to enabled and sound to disabled', () => {
+    expect(resolveManagerOrderNotificationPreferences(null)).toEqual({
+      pushEnabled: true,
+      soundEnabled: false,
+      soundUrl: '',
+    });
+    expect(hasStoredManagerOrderNotificationPreferences(null)).toBe(false);
+  });
+
+  it('stores preferences under localPreferences without losing existing fields', () => {
+    const user = {
+      id: 15,
+      name: 'Gestor',
+      localPreferences: {
+        theme: 'light',
+      },
+    };
+
+    expect(
+      applyManagerOrderNotificationPreferences(user, {
+        pushEnabled: false,
+        soundEnabled: true,
+        soundUrl: 'https://cdn.example.com/alerta.mp3',
+      }),
+    ).toMatchObject({
+      id: 15,
+      localPreferences: {
+        theme: 'light',
+        managerOrderNotifications: {
+          pushEnabled: false,
+          soundEnabled: true,
+          soundUrl: 'https://cdn.example.com/alerta.mp3',
+        },
+      },
+    });
+  });
+
+  it('builds a focused title for one order and a grouped summary for many', () => {
+    expect(
+      buildManagerOrderNotificationContent(
+        [
+          {
+            order: '/orders/77',
+            notificationHeader: 'Pedido #77',
+            notificationSubheader: 'Ref. interna #77',
+            notificationCustomerName: 'Maria Oliveira',
+            notificationPriceLabel: 'R$ 42,90',
+            notificationStatusLabel: 'Fila',
+          },
+        ],
+        {alias: 'Loja Centro'},
+      ),
+    ).toEqual({
+      title: 'Pedido #77',
+      body:
+        'Ref. interna #77 | Cliente: Maria Oliveira | Valor: R$ 42,90 | Loja Centro | Status: Fila',
+      orderIds: ['77'],
+      statusLabel: 'Fila',
+    });
+
+    expect(
+      buildManagerOrderNotificationContent(
+        [{order: 10}, {order: '/orders/12'}, {order: '12'}],
+        {name: 'Operacao Norte'},
+      ),
+    ).toEqual({
+      title: '2 novos pedidos',
+      body: 'Operacao Norte recebeu 2 novos pedidos. Status: Fila.',
+      orderIds: ['10', '12'],
+      statusLabel: 'Fila',
+    });
+  });
+
+  it('recognizes the manager app type safely', () => {
+    expect(isManagerAppType('MANAGER')).toBe(true);
+    expect(isManagerAppType('manager')).toBe(true);
+    expect(isManagerAppType('POS')).toBe(false);
+  });
+
+  it('requests notification permission only when the current status is default', async () => {
+    const getPermissionStatus = jest.fn(() => Promise.resolve('default'));
+    const requestPermission = jest.fn(() => Promise.resolve('granted'));
+
+    const status = await ensureManagerOrderNotificationPermission({
+      getPermissionStatus,
+      requestPermission,
+    });
+
+    expect(getPermissionStatus).toHaveBeenCalledTimes(1);
+    expect(requestPermission).toHaveBeenCalledTimes(1);
+    expect(status).toBe('granted');
+  });
+
+  it('keeps the current permission status when it is already resolved', async () => {
+    const getPermissionStatus = jest.fn(() => Promise.resolve('granted'));
+    const requestPermission = jest.fn(() => Promise.resolve('default'));
+
+    const status = await ensureManagerOrderNotificationPermission({
+      getPermissionStatus,
+      requestPermission,
+    });
+
+    expect(getPermissionStatus).toHaveBeenCalledTimes(1);
+    expect(requestPermission).not.toHaveBeenCalled();
+    expect(status).toBe('granted');
+  });
+});

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

@@ -0,0 +1,58 @@
+const {
+  buildGoogleMapsNavigationUrl,
+  buildNavigationMapQuery,
+  buildWazeNavigationUrl,
+} = require('../../../react/utils/mapNavigation');
+
+const {describe, expect, it} = global;
+
+describe('mapNavigation', () => {
+  it('joins only valid address parts when building the map query', () => {
+    expect(
+      buildNavigationMapQuery([
+        'Rua Emilio Bosco, 5675',
+        '',
+        'Jardim Sao Geronimo',
+        null,
+        'Sumare - SP',
+      ]),
+    ).toBe('Rua Emilio Bosco, 5675, Jardim Sao Geronimo, Sumare - SP');
+  });
+
+  it('builds a Google Maps directions url when coordinates are available', () => {
+    expect(
+      buildGoogleMapsNavigationUrl({
+        coordinates: {latitude: -22.8218, longitude: -47.2669},
+        origin: {latitude: -22.9, longitude: -47.05},
+      }),
+    ).toBe(
+      'https://www.google.com/maps/dir/?api=1&destination=-22.8218%2C-47.2669&origin=-22.9%2C-47.05&travelmode=driving',
+    );
+  });
+
+  it('falls back to a Google Maps search url when only the query is available', () => {
+    expect(
+      buildGoogleMapsNavigationUrl({
+        mapQuery: 'Rua Emilio Bosco, 5675, Sumare - SP',
+      }),
+    ).toBe(
+      'https://www.google.com/maps/search/?api=1&query=Rua%20Emilio%20Bosco%2C%205675%2C%20Sumare%20-%20SP',
+    );
+  });
+
+  it('builds a Waze url for either coordinates or a free-form query', () => {
+    expect(
+      buildWazeNavigationUrl({
+        coordinates: {latitude: -22.8218, longitude: -47.2669},
+      }),
+    ).toBe('https://waze.com/ul?ll=-22.8218,-47.2669&navigate=yes');
+
+    expect(
+      buildWazeNavigationUrl({
+        mapQuery: 'Rua Emilio Bosco, 5675, Sumare - SP',
+      }),
+    ).toBe(
+      'https://waze.com/ul?q=Rua%20Emilio%20Bosco%2C%205675%2C%20Sumare%20-%20SP&navigate=yes',
+    );
+  });
+});

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

@@ -0,0 +1,39 @@
+const {jest} = require('@jest/globals');
+
+const {describe, expect, it, beforeEach} = global;
+
+const {
+  clearNotificationNavigationQueue,
+  flushNotificationNavigationQueue,
+  queueNotificationNavigation,
+  setNotificationNavigationHandler,
+} = require('../../../react/utils/notificationNavigation');
+
+describe('notificationNavigation helpers', () => {
+  beforeEach(() => {
+    clearNotificationNavigationQueue();
+    setNotificationNavigationHandler(null);
+  });
+
+  it('queues notification navigation until the handler is ready', () => {
+    const handler = jest.fn(() => true);
+
+    expect(queueNotificationNavigation('OrderDetails', {id: '71137'})).toBe(true);
+    expect(handler).not.toHaveBeenCalled();
+
+    setNotificationNavigationHandler(handler);
+    expect(flushNotificationNavigationQueue()).toBe(true);
+    expect(handler).toHaveBeenCalledWith('OrderDetails', {id: '71137'});
+  });
+
+  it('deduplicates the same cold-start notification request', () => {
+    const handler = jest.fn(() => true);
+
+    expect(queueNotificationNavigation('OrderDetails', {id: '71137'})).toBe(true);
+    expect(queueNotificationNavigation('OrderDetails', {id: '71137'})).toBe(false);
+
+    setNotificationNavigationHandler(handler);
+    flushNotificationNavigationQueue();
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -0,0 +1,27 @@
+const {describe, expect, it} = global;
+
+const {
+  DEFAULT_NOTIFICATION_SOUND_FILE,
+  resolveNotificationSoundSource,
+} = require('../../../react/utils/notificationSound');
+
+describe('notificationSound helpers', () => {
+  it('keeps the custom sound url when it is provided', () => {
+    expect(
+      resolveNotificationSoundSource(
+        'https://cdn.example.com/alerta.mp3',
+        'fallback-source',
+      ),
+    ).toBe('https://cdn.example.com/alerta.mp3');
+  });
+
+  it('falls back to the bundled source when the url is blank', () => {
+    expect(resolveNotificationSoundSource('   ', 'fallback-source')).toBe(
+      'fallback-source',
+    );
+  });
+
+  it('exposes the bundled sound file name', () => {
+    expect(DEFAULT_NOTIFICATION_SOUND_FILE).toBe('caixa.m4a');
+  });
+});

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

@@ -0,0 +1,88 @@
+const {jest} = require('@jest/globals')
+
+jest.mock('react-native', () => ({
+  Platform: {
+    OS: 'android',
+    select: options => options?.android,
+  },
+}))
+
+const {describe, expect, it} = global
+
+const {
+  PAYMENT_TYPE_IDS_CONFIG_KEY,
+  filterWalletPaymentTypesByAllowedIds,
+  isLocalCieloPrintCapableDeviceConfig,
+  resolveDevicePaymentTypeIds,
+} = require('../../../react/utils/paymentDevices')
+
+describe('paymentDevices local Cielo print support', () => {
+  it('resolves the payment type allowlist from the new config key', () => {
+    expect(
+      resolveDevicePaymentTypeIds({
+        configs: {
+          [PAYMENT_TYPE_IDS_CONFIG_KEY]: [1, '2', '/payment_types/3'],
+        },
+      }),
+    ).toEqual(['1', '2', '3'])
+  })
+
+  it('returns an empty list when no payment types are configured', () => {
+    expect(resolveDevicePaymentTypeIds({})).toEqual([])
+  })
+
+  it('filters wallet payment types by association id instead of payment type id', () => {
+    const paymentTypes = [
+      {
+        id: 11,
+        wallet: {id: 1, wallet: 'Cielo'},
+        paymentType: {id: 5, paymentType: 'Débito'},
+      },
+      {
+        id: 12,
+        wallet: {id: 2, wallet: 'Infinite Pay'},
+        paymentType: {id: 5, paymentType: 'Débito'},
+      },
+      {
+        id: 13,
+        wallet: {id: 2, wallet: 'Infinite Pay'},
+        paymentType: {id: 6, paymentType: 'PIX'},
+      },
+    ]
+
+    expect(
+      filterWalletPaymentTypesByAllowedIds(paymentTypes, [11, '13']),
+    ).toEqual([paymentTypes[0], paymentTypes[2]])
+  })
+
+  it('allows local Cielo print only for PDV devices with Cielo gateway', () => {
+    expect(
+      isLocalCieloPrintCapableDeviceConfig({
+        type: 'PDV',
+        configs: {
+          'pos-gateway': 'cielo',
+        },
+      }),
+    ).toBe(true)
+  })
+
+  it('blocks local Cielo print for non-Cielo and non-PDV devices', () => {
+    expect(
+      isLocalCieloPrintCapableDeviceConfig({
+        type: 'PDV',
+        configs: {
+          'pos-gateway': 'infinite-pay',
+        },
+      }),
+    ).toBe(false)
+
+    expect(
+      isLocalCieloPrintCapableDeviceConfig({
+        type: 'PRINT',
+        configs: {
+          'pos-gateway': 'cielo',
+        },
+      }),
+    ).toBe(false)
+  })
+})