@controleonline/ui-common 1.2.70

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

@@ -0,0 +1,82 @@
+jest.mock('@controleonline/ui-common/src/api', () => ({
+  api: {
+    fetch: jest.fn(),
+  },
+}));
+
+const {api} = require('@controleonline/ui-common/src/api');
+const {
+  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 () => {
+    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,
+      },
+    });
+    expect(directory[0].shopAddresses).toEqual([
+      {id: 601, nickname: 'Loja Norte'},
+    ]);
+  });
+});

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

@@ -0,0 +1,124 @@
+const {jest} = require('@jest/globals');
+
+const {
+  createSocketRuntimePipeline,
+} = require('../../../react/utils/socketRuntimePipeline');
+
+const {describe, expect, it, beforeEach, afterEach} = global;
+
+describe('socketRuntimePipeline', () => {
+  let websocketActions;
+  let runtimeDebugActions;
+  let storeMessages;
+  let stores;
+
+  beforeEach(() => {
+    storeMessages = [];
+    stores = {
+      orders: {
+        getters: {
+          messages: storeMessages,
+        },
+        actions: {
+          setMessages: nextMessages => {
+            storeMessages = nextMessages;
+            stores.orders.getters.messages = nextMessages;
+          },
+        },
+      },
+    };
+
+    websocketActions = {
+      setSummary: jest.fn(),
+    };
+
+    runtimeDebugActions = {
+      setFooterEntry: jest.fn(),
+    };
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('tags delivered messages and updates the socket summary', async () => {
+    const pipeline = createSocketRuntimePipeline({
+      getDeviceId: () => 'device-1',
+      getCurrentCompanyId: () => 'company-1',
+      websocketActions,
+      runtimeDebugActions,
+      getStoreByName: name => stores[name],
+    });
+
+    pipeline.processPayload([
+      {
+        store: 'orders',
+        company: {id: 'company-1'},
+        order: '/orders/11',
+      },
+    ]);
+
+    await Promise.resolve();
+
+    expect(storeMessages).toEqual([
+      {
+        store: 'orders',
+        company: {id: 'company-1'},
+        order: '/orders/11',
+        source: 'background-runtime',
+      },
+    ]);
+    expect(websocketActions.setSummary).toHaveBeenCalledWith(
+      expect.objectContaining({
+        connected: true,
+        identified: true,
+        status: 'connected',
+        device: 'device-1',
+        lastEventCount: 1,
+        lastStores: ['orders'],
+        lastCompanies: ['company-1'],
+      }),
+    );
+    expect(runtimeDebugActions.setFooterEntry).toHaveBeenCalledWith(
+      expect.objectContaining({
+        key: 'socket',
+      }),
+    );
+  });
+
+  it('applies socket-state snapshots without dropping owner metadata', () => {
+    const pipeline = createSocketRuntimePipeline({
+      getDeviceId: () => 'device-1',
+      getCurrentCompanyId: () => 'company-1',
+      websocketActions,
+      runtimeDebugActions,
+      getStoreByName: name => stores[name],
+    });
+
+    pipeline.processPayload({
+      type: 'socket-state',
+      connected: true,
+      identified: true,
+      status: 'connected',
+      attempts: 0,
+      device: 'device-1',
+      ownerRegistrationId: 'manager::device-1::company-1',
+      ownerPackageName: 'com.controleonline.manager',
+      ownerCompanyId: 'company-1',
+      lastEventCount: 3,
+      lastStores: ['orders', 'print'],
+      lastCompanies: ['company-1'],
+    });
+
+    expect(websocketActions.setSummary).toHaveBeenCalledWith(
+      expect.objectContaining({
+        connected: true,
+        identified: true,
+        status: 'connected',
+        ownerRegistrationId: 'manager::device-1::company-1',
+        ownerPackageName: 'com.controleonline.manager',
+        ownerCompanyId: 'company-1',
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,40 @@
+/* global describe, it, expect */
+
+const {
+  forgetTrackedSpool,
+  getTrackedSpoolKey,
+  hasTrackedSpool,
+  pruneTrackedSpools,
+  rememberTrackedSpool,
+} = require('../../../react/utils/spoolAckTracker')
+
+describe('spoolAckTracker', () => {
+  it('normalizes spool ids before tracking them', () => {
+    expect(getTrackedSpoolKey('/spools/123')).toBe('123')
+    expect(getTrackedSpoolKey(' spool-456 ')).toBe('456')
+    expect(getTrackedSpoolKey(null)).toBe('')
+  })
+
+  it('tracks and forgets printed spools by normalized id', () => {
+    const registry = new Map()
+
+    rememberTrackedSpool(registry, '/spools/77', {printedAt: 123})
+
+    expect(hasTrackedSpool(registry, 77)).toBe(true)
+    expect(registry.get('77')).toEqual({printedAt: 123})
+
+    forgetTrackedSpool(registry, '77')
+
+    expect(hasTrackedSpool(registry, '/spools/77')).toBe(false)
+  })
+
+  it('prunes spools that are no longer open', () => {
+    const registry = new Map()
+
+    rememberTrackedSpool(registry, 10, {printedAt: 1})
+    rememberTrackedSpool(registry, 20, {printedAt: 2})
+    pruneTrackedSpools(registry, ['/spools/20', '/spools/30'])
+
+    expect(Array.from(registry.keys())).toEqual(['20'])
+  })
+})

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

@@ -0,0 +1,66 @@
+/* global jest */
+
+const {beforeEach, describe, expect, it} = global
+
+jest.mock('@controleonline/ui-common/src/react/utils/systemErrorChannel', () => ({
+  publishSystemError: jest.fn(() => true),
+}))
+
+const {publishSystemError} = require('@controleonline/ui-common/src/react/utils/systemErrorChannel')
+const {
+  bridgeStoreError,
+  isStoreErrorMutation,
+  shouldSkipStoreErrorMutation,
+} = require('../../../react/stores/storeErrorBridge')
+
+describe('storeErrorBridge', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('recognizes store error mutations by suffix and ignores empty payloads', () => {
+    expect(isStoreErrorMutation('SET_ERROR', 'Falha')).toBe(true)
+    expect(isStoreErrorMutation('LOGIN_SET_ERROR', 'Falha')).toBe(true)
+    expect(isStoreErrorMutation('SET_ERROR', '')).toBe(false)
+    expect(isStoreErrorMutation('SET_ITEMS', 'Falha')).toBe(false)
+  })
+
+  it('allows a caller to suppress the shared visual error for locally handled flows', () => {
+    expect(shouldSkipStoreErrorMutation({skipSystemError: true})).toBe(true)
+    expect(isStoreErrorMutation('SET_ERROR', 'Falha', {skipSystemError: true})).toBe(false)
+  })
+
+  it('publishes canonical visual errors for store mutations', () => {
+    expect(
+      bridgeStoreError({
+        storeName: 'invoice',
+        mutationType: 'SET_ERROR',
+        error: 'Nao foi possivel gerar a cobranca.',
+      }),
+    ).toBe(true)
+
+    expect(publishSystemError).toHaveBeenCalledWith(
+      'Nao foi possivel gerar a cobranca.',
+      expect.objectContaining({
+        source: 'store',
+        storeName: 'invoice',
+        mutationType: 'SET_ERROR',
+      }),
+    )
+  })
+
+  it('does not publish when the store caller opted to handle the error locally', () => {
+    expect(
+      bridgeStoreError({
+        storeName: 'phones',
+        mutationType: 'SET_ERROR',
+        error: 'Item not found for "/people/30".',
+        options: {
+          skipSystemError: true,
+        },
+      }),
+    ).toBe(false)
+
+    expect(publishSystemError).not.toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,58 @@
+/* global jest */
+
+const {beforeEach, describe, expect, it} = global
+
+const {
+  publishSystemError,
+  subscribeSystemErrors,
+  resetSystemErrorChannel,
+  DEFAULT_SYSTEM_ERROR_DEDUPE_WINDOW_MS,
+} = require('../../../react/utils/systemErrorChannel')
+
+describe('systemErrorChannel', () => {
+  beforeEach(() => {
+    resetSystemErrorChannel()
+    jest.restoreAllMocks()
+  })
+
+  it('queues store and manual errors until the presenter subscribes', () => {
+    expect(publishSystemError('Falha ao salvar')).toBe(true)
+
+    const received = []
+
+    const unsubscribe = subscribeSystemErrors(payload => {
+      received.push(payload)
+    })
+
+    expect(received).toEqual([
+      expect.objectContaining({
+        message: 'Falha ao salvar',
+      }),
+    ])
+
+    unsubscribe()
+  })
+
+  it('deduplicates the same transient error inside the shared time window', () => {
+    const nowSpy = jest.spyOn(Date, 'now')
+    nowSpy.mockReturnValue(1000)
+
+    const received = []
+    const unsubscribe = subscribeSystemErrors(payload => {
+      received.push(payload.message)
+    })
+
+    expect(publishSystemError('Erro de sincronizacao')).toBe(true)
+    expect(publishSystemError('Erro de sincronizacao')).toBe(false)
+
+    nowSpy.mockReturnValue(1000 + DEFAULT_SYSTEM_ERROR_DEDUPE_WINDOW_MS + 1)
+
+    expect(publishSystemError('Erro de sincronizacao')).toBe(true)
+    expect(received).toEqual([
+      'Erro de sincronizacao',
+      'Erro de sincronizacao',
+    ])
+
+    unsubscribe()
+  })
+})

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

@@ -0,0 +1,59 @@
+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')
+  })
+})

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

@@ -0,0 +1,75 @@
+const {describe, expect, it} = global
+
+const {
+  TOAST_ERROR_STYLES,
+  TOAST_WARNING_STYLES,
+  mergeToastStyles,
+  withErrorToastStyles,
+  withWarningToastStyles,
+} = require('../../../react/utils/toastPresentation')
+
+describe('toastPresentation', () => {
+  it('keeps the shared error toast on a light, high-contrast panel', () => {
+    expect(TOAST_ERROR_STYLES.pressable).toMatchObject({
+      backgroundColor: '#FFF7F7',
+      borderColor: '#FECACA',
+      borderWidth: 1,
+    })
+    expect(TOAST_ERROR_STYLES.indicator).toMatchObject({
+      backgroundColor: '#DC2626',
+    })
+  })
+
+  it('merges toast style groups without dropping prior sections', () => {
+    expect(
+      mergeToastStyles(
+        {
+          pressable: {backgroundColor: '#FFFFFF'},
+          indicator: {backgroundColor: '#000000'},
+        },
+        {
+          pressable: {borderWidth: 2},
+          text: {color: '#111827'},
+        },
+      ),
+    ).toEqual({
+      pressable: {
+        backgroundColor: '#FFFFFF',
+        borderWidth: 2,
+      },
+      indicator: {
+        backgroundColor: '#000000',
+      },
+      text: {
+        color: '#111827',
+      },
+    })
+  })
+
+  it('decorates error and warning toast options with the shared styles', () => {
+    expect(withErrorToastStyles({styles: {pressable: {paddingHorizontal: 8}}})).toEqual({
+      styles: {
+        pressable: {
+          backgroundColor: '#FFF7F7',
+          borderColor: '#FECACA',
+          borderWidth: 1,
+          paddingHorizontal: 8,
+        },
+        indicator: {
+          backgroundColor: '#DC2626',
+        },
+      },
+    })
+
+    expect(withWarningToastStyles({styles: {text: {fontWeight: '700'}}})).toEqual({
+      styles: {
+        indicator: {
+          backgroundColor: TOAST_WARNING_STYLES.indicator.backgroundColor,
+        },
+        text: {
+          fontWeight: '700',
+        },
+      },
+    })
+  })
+})