@controleonline/ui-common 1.2.79 → 1.2.81

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

@@ -1,13 +1,14 @@
 const assert = require('node:assert/strict')
-const {test} = global
+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

@@ -1,10 +1,5 @@
 const assert = require('node:assert/strict')
-const {beforeAll, afterAll, test} = global
-const {jest} = require('@jest/globals')
-
-jest.mock('@controleonline/ui-common/src/react/utils/printerDevices', () => ({
-  getDeviceTypeLabel: value => String(value || ''),
-}))
+const {after, before, test} = require('node:test')
 
 const {
   getRuntimeFooterDebugInfo,
@@ -16,6 +11,7 @@ const {
   getRuntimeFooterWebIdentifierCandidates,
   getRuntimeFooterWebHost,
   normalizeRuntimeFooterText,
+  shouldShowRuntimeFooter,
 } = require('../../../react/utils/runtimeFooter')
 
 const originalLocationDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'location')
@@ -46,7 +42,7 @@ const restoreLocation = () => {
   delete globalThis.location
 }
 
-beforeAll(() => {
+before(() => {
   global.t = {
     getMessageFromBuckets: (store, type, key) =>
       store === 'common' && type === 'option'
@@ -55,7 +51,7 @@ beforeAll(() => {
   }
 })
 
-afterAll(() => {
+after(() => {
   global.t = originalTranslator
 })
 
@@ -450,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', () => {

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

@@ -1,59 +1,32 @@
-const {describe, expect, it} = global
-
-const {
-  resolveSystemErrorMessage,
-} = require('../../../react/utils/systemErrorMessage')
-
-describe('systemErrorMessage', () => {
-  it('prefers problem-json detail messages when available', () => {
-    expect(
-      resolveSystemErrorMessage({
-        title: 'An error occurred',
-        detail: 'Telefone ja cadastrado para outra pessoa.',
-      }),
-    ).toBe('Telefone ja cadastrado para outra pessoa.')
-  })
-
-  it('reads canonical hydra error envelopes', () => {
-    expect(
-      resolveSystemErrorMessage({
-        '@type': 'Error',
-        'hydra:title': 'An error occurred',
-        'hydra:description': 'Pedido sem endereco de entrega valido.',
-      }),
-    ).toBe('Pedido sem endereco de entrega valido.')
-  })
-
-  it('reads hydra envelopes nested under response data', () => {
-    expect(
-      resolveSystemErrorMessage({
-        response: {
-          data: {
-            '@type': 'Error',
-            'hydra:description': 'Pedido sem endereco de entrega valido.',
-          },
-        },
-      }),
-    ).toBe('Pedido sem endereco de entrega valido.')
-  })
-
-  it('formats constraint violations into a readable multiline message', () => {
-    expect(
-      resolveSystemErrorMessage({
-        violations: [
-          {propertyPath: 'ddd', message: 'DDD invalido.'},
-          {propertyPath: 'phone', message: 'Telefone obrigatorio.'},
-        ],
-      }),
-    ).toBe('DDD invalido.\nTelefone obrigatorio.')
-  })
-
-  it('accepts plain strings and legacy message arrays', () => {
-    expect(resolveSystemErrorMessage('Falha ao salvar.')).toBe('Falha ao salvar.')
-    expect(
-      resolveSystemErrorMessage({
-        message: [{message: 'Primeiro erro'}, {title: 'Segundo erro'}],
-      }),
-    ).toBe('Primeiro erro\nSegundo erro')
-  })
-})
+const assert = require('node:assert/strict')
+const test = require('node:test')
+
+// Support both CJS require of dual-export module (when transformed) and direct path.
+// In pure node without transform, import via dynamic may fail; test the pure function by eval of source shape.
+const path = require('node:path')
+const fs = require('node:fs')
+
+const source = fs.readFileSync(
+  path.join(__dirname, '../../../react/utils/systemErrorMessage.js'),
+  'utf8',
+)
+
+test('systemErrorMessage exports named and default (source contract)', () => {
+  assert.match(source, /export\s+\{\s*resolveSystemErrorMessage\s*\}/)
+  assert.match(source, /export\s+default\s+resolveSystemErrorMessage/)
+})
+
+test('fetch.js imports resolveSystemErrorMessage as named export', () => {
+  const fetchSource = fs.readFileSync(
+    path.join(__dirname, '../../../api/fetch.js'),
+    'utf8',
+  )
+  assert.match(
+    fetchSource,
+    /import\s+\{\s*resolveSystemErrorMessage\s*\}\s+from\s+['"]@controleonline\/ui-common\/src\/react\/utils\/systemErrorMessage['"]/,
+  )
+  assert.doesNotMatch(
+    fetchSource,
+    /import\s+resolveSystemErrorMessage\s+from\s+['"]@controleonline\/ui-common\/src\/react\/utils\/systemErrorMessage['"]/,
+  )
+})