@controleonline/ui-common 1.2.80 → 1.2.82

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

@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildCopyPayloads,
+  buildSourceDeviceOptions,
+  executeCopyDeviceConfigs,
+  listCopyableConfigKeys,
+} from '../../../react/utils/copyDeviceConfigs.js';
+
+const companyId = '42';
+const peopleIri = '/people/42';
+
+const sourceRows = [
+  {
+    id: 1,
+    type: 'PDV',
+    people: {id: 42},
+    device: {id: 10, device: 'src-hash-1', alias: 'Caixa 1'},
+    configs: {
+      'pos-operation-mode': 'cashier',
+      'pos-gateway': 'cielo',
+      'printer-enabled': '1',
+    },
+  },
+  {
+    id: 2,
+    type: 'PRINT',
+    people: {id: 42},
+    device: {id: 10, device: 'src-hash-1', alias: 'Caixa 1'},
+    configs: {'print-network-port': '9100'},
+  },
+  {
+    id: 3,
+    type: 'PDV',
+    people: {id: 99},
+    device: {id: 20, device: 'other-co', alias: 'Outra empresa'},
+    configs: {'pos-gateway': 'infinite-pay'},
+  },
+  {
+    id: 4,
+    type: 'PDV',
+    people: {id: 42},
+    device: {id: 30, device: 'dest-hash', alias: 'Destino'},
+    configs: {'pos-operation-mode': 'waiter'},
+  },
+];
+
+test('listCopyableConfigKeys sorts keys from object or JSON string', () => {
+  assert.deepEqual(listCopyableConfigKeys({'b-key': '1', 'a-key': '2'}), [
+    'a-key',
+    'b-key',
+  ]);
+  assert.deepEqual(
+    listCopyableConfigKeys(JSON.stringify({'pos-gateway': 'cielo'})),
+    ['pos-gateway'],
+  );
+});
+
+test('buildSourceDeviceOptions excludes destination and other tenants', () => {
+  const options = buildSourceDeviceOptions({
+    companyDeviceConfigs: sourceRows,
+    companyId,
+    destinationDeviceString: 'dest-hash',
+  });
+  assert.equal(options.length, 1);
+  assert.equal(options[0].deviceString, 'src-hash-1');
+  assert.equal(options[0].configs.length, 2);
+});
+
+test('buildCopyPayloads keeps destination identity and source config keys', () => {
+  const payloads = buildCopyPayloads({
+    sourceConfigs: sourceRows.filter(r => r.device.device === 'src-hash-1'),
+    destinationDeviceString: 'dest-hash',
+    peopleIri,
+  });
+  assert.equal(payloads.length, 2);
+  const pdv = payloads.find(p => p.type === 'PDV');
+  const print = payloads.find(p => p.type === 'PRINT');
+  assert.equal(pdv.device, 'dest-hash');
+  assert.equal(pdv.people, peopleIri);
+  assert.equal(JSON.parse(pdv.configs)['pos-gateway'], 'cielo');
+  assert.deepEqual(pdv.keys, [
+    'pos-gateway',
+    'pos-operation-mode',
+    'printer-enabled',
+  ]);
+  assert.deepEqual(print.keys, ['print-network-port']);
+});
+
+test('executeCopyDeviceConfigs posts one payload per type', async () => {
+  const calls = [];
+  const addDeviceConfigs = async params => {
+    calls.push(params);
+    return {ok: true, type: params.type};
+  };
+  const summary = await executeCopyDeviceConfigs({
+    addDeviceConfigs,
+    sourceConfigs: sourceRows.filter(r => r.device.device === 'src-hash-1'),
+    destinationDeviceString: 'dest-hash',
+    peopleIri,
+  });
+  assert.equal(calls.length, 2);
+  assert.ok(calls.every(c => c.device === 'dest-hash'));
+  assert.ok(calls.every(c => c.people === peopleIri));
+  assert.deepEqual(summary.types.sort(), ['PDV', 'PRINT']);
+  assert.ok(summary.keys.includes('pos-gateway'));
+  assert.ok(summary.keys.includes('print-network-port'));
+});
+
+test('buildCopyPayloads returns empty without dest or people', () => {
+  assert.deepEqual(
+    buildCopyPayloads({
+      sourceConfigs: sourceRows,
+      destinationDeviceString: '',
+      peopleIri,
+    }),
+    [],
+  );
+  assert.deepEqual(
+    buildCopyPayloads({
+      sourceConfigs: sourceRows,
+      destinationDeviceString: 'dest-hash',
+      peopleIri: '',
+    }),
+    [],
+  );
+});

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

@@ -59,4 +59,42 @@ describe('fileUrl helpers', () => {
       headers: {},
     });
   });
+
+  it('does not path-inject environment hosts like staging (app-community#432)', () => {
+    const source = resolveDefaultFileSource(
+      {
+        id: 8444,
+        url: '/files/8444/download',
+      },
+      {
+        company: {
+          domain: 'staging.controleonline.com',
+        },
+        headers: {
+          Authorization: 'Bearer token',
+        },
+      },
+    );
+
+    expect(source).toEqual({
+      uri: 'https://api.controleonline.com/files/8444/download',
+      headers: {
+        Authorization: 'Bearer token',
+        'app-domain': 'staging.controleonline.com',
+      },
+    });
+    expect(source.uri).not.toContain('staging.controleonline.com/files');
+  });
+
+  it('does not path-inject when fallback DOMAIN is manager platform host', () => {
+    // DOMAIN mock is manager.controleonline.com; no company → environment-like
+    const source = resolveDefaultFileSource(
+      {id: 9, url: '/files/9/download'},
+      {headers: {Authorization: 'Bearer t'}},
+    );
+
+    expect(source.uri).toBe('https://api.controleonline.com/files/9/download');
+    expect(source.headers['app-domain']).toBe('manager.controleonline.com');
+    expect(source.uri).not.toMatch(/manager\.controleonline\.com\/files/);
+  });
 });

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

@@ -4,10 +4,11 @@ const {test} = require('node:test')
 const {
   getImportErrorDetail,
   getImportStatusMeta,
-  normalizeImportStatus,
-  resolveImportLabels,
-  resolveImportStatusLabel,
-} = require('@controleonline/ui-common/src/react/utils/importStatus')
+  normalizeImportStatus,
+  resolveImportLabels,
+  resolveImportTranslator,
+  resolveImportStatusLabel,
+} = require('@controleonline/ui-common/src/react/utils/importStatus')
 
 test('normalizeImportStatus trims and lowercases the raw value', () => {
   assert.equal(normalizeImportStatus('  Processing '), 'processing')
@@ -50,7 +51,7 @@ test('getImportErrorDetail returns the first non-empty message candidate', () =>
   )
 })
 
-test('resolveImportLabels only reads translation keys without hardcoded fallbacks', () => {
+test('resolveImportLabels only reads translation keys without hardcoded fallbacks', () => {
   const calls = []
   const labels = resolveImportLabels((...args) => {
     calls.push(args)
@@ -66,10 +67,26 @@ test('resolveImportLabels only reads translation keys without hardcoded fallback
     ['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(labels.processingHelpLabel, 'imports.message.processing_after_upload')
+})
+
+test('resolveImportTranslator preserves translator object context', () => {
+  const translator = {
+    prefix: 'translated',
+    t(type, scope, key) {
+      return `${this.prefix}.${type}.${scope}.${key}`
+    },
+  }
+
+  const translate = resolveImportTranslator(translator)
+
+  assert.equal(
+    translate('imports', 'button', 'refresh'),
+    'translated.imports.button.refresh',
+  )
+})
+
+test('resolveImportStatusLabel falls back to the raw backend status before the generic empty label', () => {
   assert.equal(
     resolveImportStatusLabel(
       {

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

@@ -0,0 +1,27 @@
+import {
+  PASSWORD_MIN_LENGTH,
+  PASSWORD_MSG_COMPROMISED,
+  PASSWORD_MSG_MIN_LENGTH,
+  mapPasswordErrorMessage,
+  validatePasswordClient,
+} from '../../../react/utils/passwordPolicy';
+
+describe('passwordPolicy', () => {
+  it('rejects short password with explicit min length', () => {
+    expect(validatePasswordClient('123')).toBe(PASSWORD_MSG_MIN_LENGTH);
+  });
+
+  it('accepts password meeting min length', () => {
+    expect(validatePasswordClient('abcdef')).toBeNull();
+  });
+
+  it('maps english breach message to portuguese', () => {
+    const raw =
+      'This password has been leaked in a data breach, it must not be used. Please use another password.';
+    expect(mapPasswordErrorMessage(raw)).toBe(PASSWORD_MSG_COMPROMISED);
+  });
+
+  it('exposes policy min length constant', () => {
+    expect(PASSWORD_MIN_LENGTH).toBe(6);
+  });
+});

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

@@ -0,0 +1,86 @@
+import {describe, it} from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  PRINT_ROUTE_MISSING_DESTINATION,
+  resolvePrintRoutingError,
+  resolveSpoolDeviceIdsForRuntime,
+} from '../../../react/utils/printRouting.js';
+
+const PRINT_DEVICE_TYPE = 'PRINT';
+const PDV_DEVICE_TYPE = 'PDV';
+const DISPLAY_DEVICE_TYPE = 'DISPLAY';
+
+describe('resolveSpoolDeviceIdsForRuntime (print routing #628)', () => {
+  const managedPrinters = [
+    {device: 'printer-a', type: PRINT_DEVICE_TYPE},
+    {device: 'printer-b', type: PRINT_DEVICE_TYPE},
+  ];
+
+  it('PDV includes local + managed .device ids', () => {
+    const ids = resolveSpoolDeviceIdsForRuntime({
+      runtimeDeviceId: 'pdv-1',
+      runtimeDeviceType: PDV_DEVICE_TYPE,
+      managedPrinters,
+      includeLocalDevice: true,
+    });
+    assert.deepEqual(ids.sort(), ['pdv-1', 'printer-a', 'printer-b'].sort());
+  });
+
+  it('accepts deviceId fallback and prefers device', () => {
+    const idsWithOnlyDeviceId = resolveSpoolDeviceIdsForRuntime({
+      runtimeDeviceId: 'pdv-1',
+      runtimeDeviceType: PDV_DEVICE_TYPE,
+      managedPrinters: [{deviceId: 'should-not-be-used', type: PRINT_DEVICE_TYPE}],
+      includeLocalDevice: false,
+    });
+    const preferred = resolveSpoolDeviceIdsForRuntime({
+      runtimeDeviceId: 'pdv-1',
+      runtimeDeviceType: PDV_DEVICE_TYPE,
+      managedPrinters: [{device: 'printer-a'}],
+      includeLocalDevice: false,
+    });
+    assert.deepEqual(preferred, ['printer-a']);
+    assert.deepEqual(idsWithOnlyDeviceId, ['should-not-be-used']);
+  });
+
+  it('DISPLAY only polls managed printers', () => {
+    const ids = resolveSpoolDeviceIdsForRuntime({
+      runtimeDeviceId: 'display-1',
+      runtimeDeviceType: DISPLAY_DEVICE_TYPE,
+      managedPrinters,
+    });
+    assert.deepEqual(ids.sort(), ['printer-a', 'printer-b'].sort());
+  });
+
+  it('PRINT runtime does not receive jobs (no spool poll)', () => {
+    const ids = resolveSpoolDeviceIdsForRuntime({
+      runtimeDeviceId: 'printer-a',
+      runtimeDeviceType: PRINT_DEVICE_TYPE,
+      managedPrinters,
+    });
+    assert.deepEqual(ids, []);
+  });
+
+  it('empty managed list + no local => no destinations', () => {
+    const ids = resolveSpoolDeviceIdsForRuntime({
+      runtimeDeviceId: 'pdv-1',
+      runtimeDeviceType: PDV_DEVICE_TYPE,
+      managedPrinters: [],
+      includeLocalDevice: false,
+    });
+    assert.deepEqual(ids, []);
+  });
+});
+
+describe('resolvePrintRoutingError', () => {
+  it('returns a visible message when routing has no destination', () => {
+    assert.equal(resolvePrintRoutingError({}), PRINT_ROUTE_MISSING_DESTINATION);
+  });
+
+  it('is silent when a printer device is selected', () => {
+    assert.equal(
+      resolvePrintRoutingError({selectedPrinter: {device: 'printer-a'}}),
+      '',
+    );
+  });
+});

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

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+import {
+  resolveSpoolId,
+  extractCollectionMembers,
+  mergeOpenSpoolCollections,
+  resolveRequestedTargetDeviceId,
+  resolveRequestedTargetDeviceTypeValue,
+} from '../../../react/utils/printSpoolUtils.js';
+
+describe('printSpoolUtils (#628 modularization)', () => {
+  it('resolveSpoolId handles number, string, object and @id', () => {
+    assert.equal(resolveSpoolId(12), 12);
+    assert.equal(resolveSpoolId('spool/34'), 34);
+    assert.equal(resolveSpoolId({id: 7}), 7);
+    assert.equal(resolveSpoolId({'@id': '/spools/9'}), 9);
+    assert.equal(resolveSpoolId(null), null);
+  });
+
+  it('extractCollectionMembers supports array, member, hydra:member', () => {
+    assert.deepEqual(extractCollectionMembers([1]), [1]);
+    assert.deepEqual(extractCollectionMembers({member: [2]}), [2]);
+    assert.deepEqual(extractCollectionMembers({'hydra:member': [3]}), [3]);
+    assert.deepEqual(extractCollectionMembers({}), []);
+  });
+
+  it('mergeOpenSpoolCollections dedupes and sorts by id', () => {
+    const merged = mergeOpenSpoolCollections([
+      [{id: 3}, {id: 1}],
+      [{id: 1}, {id: 2}],
+    ]);
+    assert.deepEqual(
+      merged.map(s => s.id),
+      [1, 2, 3],
+    );
+  });
+
+  it('resolveRequestedTargetDeviceId prefers explicit fields', () => {
+    assert.equal(
+      resolveRequestedTargetDeviceId({targetDeviceId: 5}, 9),
+      '5',
+    );
+    assert.equal(resolveRequestedTargetDeviceId({}, 9), '9');
+  });
+
+  it('resolveRequestedTargetDeviceTypeValue normalizes type', () => {
+    assert.equal(
+      resolveRequestedTargetDeviceTypeValue({targetDeviceType: 'pdv'}),
+      'PDV',
+    );
+  });
+});

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

@@ -11,6 +11,7 @@ const {
   getRuntimeFooterWebIdentifierCandidates,
   getRuntimeFooterWebHost,
   normalizeRuntimeFooterText,
+  shouldShowRuntimeFooter,
 } = require('../../../react/utils/runtimeFooter')
 
 const originalLocationDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'location')
@@ -445,3 +446,9 @@ test('rotates each footer line before the runtime version entry', () => {
     ['www.site.com', '(11) 99999-9999', 'web (203.0.113.42) / v1.3.6'],
   )
 })
+
+test('hides runtime device information on the customer paylist only', () => {
+  assert.equal(shouldShowRuntimeFooter('PaylistPage'), false)
+  assert.equal(shouldShowRuntimeFooter('LoginPage'), true)
+  assert.equal(shouldShowRuntimeFooter('WalletsPage'), true)
+})

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

@@ -1,152 +1,158 @@
-jest.mock('@controleonline/ui-common/src/api', () => ({
-  api: {
-    fetch: jest.fn(),
-  },
-}));
-
-const {api} = require('@controleonline/ui-common/src/api');
+jest.mock('@controleonline/ui-common/src/api', () => ({
+  api: {
+    fetch: jest.fn(),
+  },
+}));
+
+const {api} = require('@controleonline/ui-common/src/api');
 const {
   extractAddressCategoryIds,
   filterShopFranchiseDirectory,
   fetchAllShopFranchiseDirectory,
   fetchShopFranchiseDirectory,
 } = require('../../../react/utils/shopFranchises');
-
-const {beforeEach, describe, expect, it} = global;
-
-describe('shopFranchises', () => {
-  beforeEach(() => {
-    api.fetch.mockReset();
-  });
-
-  it('uses the public shop franchises endpoint and preserves shop addresses', async () => {
-    api.fetch.mockResolvedValueOnce({
-      member: [
-        {
-          id: 21,
-          alias: 'Centro',
-          shopAddresses: [{id: 501, nickname: 'Loja Centro'}],
-        },
-      ],
-      'hydra:member': [
-        {
-          id: 21,
-          alias: 'Centro',
-          shopAddresses: [{id: 501, nickname: 'Loja Centro'}],
-        },
-      ],
-    });
-
-    const directory = await fetchShopFranchiseDirectory({
-      companyId: 10,
-      publicDirectory: true,
-    });
-
-    expect(api.fetch).toHaveBeenCalledWith('/shop/franchises', {
-      params: {
-        itemsPerPage: 50,
-        page: 1,
-      },
-    });
-    expect(directory).toEqual([
-      {
-        id: 21,
-        alias: 'Centro',
-        shopAddresses: [{id: 501, nickname: 'Loja Centro'}],
-      },
-    ]);
-  });
-
-  it('keeps authenticated management lookup scoped by company', async () => {
+
+const {beforeEach, describe, expect, it} = global;
+
+describe('shopFranchises', () => {
+  beforeEach(() => {
+    api.fetch.mockReset();
+  });
+
+  it('uses the public shop franchises endpoint and preserves shop addresses', async () => {
     api.fetch.mockResolvedValueOnce({
       member: [
         {
-          id: 22,
-          alias: 'Norte',
-          address: [{id: 601, nickname: 'Loja Norte'}],
-        },
-      ],
-    });
-
-    const directory = await fetchShopFranchiseDirectory({companyId: 10});
-
-    expect(api.fetch).toHaveBeenCalledWith('people', {
-      params: {
-        'link.company': '/people/10',
-        'link.linkType': 'franchisee',
-        itemsPerPage: 50,
-        page: 1,
-      },
-    });
+          id: 21,
+          alias: 'Centro',
+          shopAddresses: [{id: 501, nickname: 'Loja Centro'}],
+        },
+      ],
+      'hydra:member': [
+        {
+          id: 21,
+          alias: 'Centro',
+          shopAddresses: [{id: 501, nickname: 'Loja Centro'}],
+        },
+      ],
+    });
+
+    const directory = await fetchShopFranchiseDirectory({
+      companyId: 10,
+      publicDirectory: true,
+    });
+
+    expect(api.fetch).toHaveBeenCalledWith('/shop/franchises', {
+      params: {
+        itemsPerPage: 50,
+        page: 1,
+      },
+    });
+    expect(directory).toEqual([
+      {
+        id: 21,
+        alias: 'Centro',
+        shopAddresses: [{id: 501, nickname: 'Loja Centro'}],
+      },
+    ]);
+  });
+
+  it('loads franchises from people_links on both company and people sides', async () => {
+    api.fetch
+      .mockResolvedValueOnce({
+        member: [
+          {
+            id: 51,
+            linkType: 'franchisee',
+            company: {id: 10, alias: 'Franchisor'},
+            people: {
+              id: 22,
+              alias: 'Norte',
+              address: [{id: 601, nickname: 'Loja Norte'}],
+            },
+          },
+        ],
+      })
+      .mockResolvedValueOnce({
+        member: [],
+      });
+
+    const directory = await fetchShopFranchiseDirectory({companyId: 10});
+
+    expect(api.fetch).toHaveBeenCalledWith('people_links', {
+      params: {
+        company: '/people/10',
+        linkType: 'franchisee',
+        itemsPerPage: 50,
+        page: 1,
+      },
+    });
+    expect(api.fetch).toHaveBeenCalledWith('people_links', {
+      params: {
+        people: '/people/10',
+        linkType: 'franchisee',
+        itemsPerPage: 50,
+        page: 1,
+      },
+    });
+    expect(directory[0].id).toBe(22);
+    expect(directory[0].alias).toBe('Norte');
     expect(directory[0].shopAddresses).toEqual([
       {id: 601, nickname: 'Loja Norte'},
     ]);
   });
 
-  it('loads every page when building the full franchise directory', async () => {
+    it('loads every page when building the full franchise directory', async () => {
+    // Dual-side people_links: company side page1 (full), page2 empty break;
+    // people side empty.
     api.fetch
       .mockResolvedValueOnce({
         member: [
           {
-            id: 21,
-            alias: 'Centro',
-            shopAddresses: [{id: 501, nickname: 'Loja Centro'}],
+            id: 1,
+            linkType: 'franchisee',
+            company: {id: 10},
+            people: {
+              id: 21,
+              alias: 'Centro',
+              shopAddresses: [{id: 501, nickname: 'Loja Centro'}],
+            },
           },
           {
-            id: 22,
-            alias: 'Norte',
-            shopAddresses: [{id: 601, nickname: 'Loja Norte'}],
+            id: 2,
+            linkType: 'franchisee',
+            company: {id: 10},
+            people: {
+              id: 22,
+              alias: 'Norte',
+              shopAddresses: [{id: 601, nickname: 'Loja Norte'}],
+            },
           },
         ],
       })
       .mockResolvedValueOnce({
         member: [
           {
-            id: 23,
-            alias: 'Sul',
-            shopAddresses: [{id: 701, nickname: 'Loja Sul'}],
+            id: 3,
+            linkType: 'franchisee',
+            company: {id: 10},
+            people: {
+              id: 23,
+              alias: 'Sul',
+              shopAddresses: [{id: 701, nickname: 'Loja Sul'}],
+            },
           },
         ],
-      });
+      })
+      .mockResolvedValueOnce({member: []});
 
     const directory = await fetchAllShopFranchiseDirectory({
       companyId: 10,
       itemsPerPage: 2,
     });
 
-    expect(api.fetch).toHaveBeenNthCalledWith(1, 'people', {
-      params: {
-        'link.company': '/people/10',
-        'link.linkType': 'franchisee',
-        itemsPerPage: 2,
-        page: 1,
-      },
-    });
-    expect(api.fetch).toHaveBeenNthCalledWith(2, 'people', {
-      params: {
-        'link.company': '/people/10',
-        'link.linkType': 'franchisee',
-        itemsPerPage: 2,
-        page: 2,
-      },
-    });
-    expect(directory).toEqual([
-      {
-        id: 21,
-        alias: 'Centro',
-        shopAddresses: [{id: 501, nickname: 'Loja Centro'}],
-      },
-      {
-        id: 22,
-        alias: 'Norte',
-        shopAddresses: [{id: 601, nickname: 'Loja Norte'}],
-      },
-      {
-        id: 23,
-        alias: 'Sul',
-        shopAddresses: [{id: 701, nickname: 'Loja Sul'}],
-      },
-    ]);
+    expect(api.fetch.mock.calls[0][0]).toBe('people_links');
+    expect(directory.map(item => item.id).sort()).toEqual([21, 22, 23]);
   });
 
   it('extracts category ids from address category payload variants', () => {