@controleonline/ui-customers 1.0.81

package/src/tests/react/components/tabs/salesmanTabHelpers.test.js

@@ -0,0 +1,142 @@
+/**
+ * Unit tests for SalesmanTab commission helpers (override precedence + permissions).
+ */
+const {
+  isCommissionFilled,
+  toCommissionNumber,
+  resolveEffectiveCommission,
+  formatCommissionPercent,
+  formatCommissionSubtitle,
+  canEditSalesmanCommission,
+  shouldDisplayCommission,
+  indexDefaultSalesmanLinksByPeopleId,
+  buildCommissionSavePayload,
+} = require('../../../../react/components/tabs/salesmanTabHelpers');
+
+describe('salesmanTabHelpers', () => {
+  describe('isCommissionFilled / toCommissionNumber', () => {
+    it('treats null/undefined/empty as not filled', () => {
+      expect(isCommissionFilled(null)).toBe(false);
+      expect(isCommissionFilled(undefined)).toBe(false);
+      expect(isCommissionFilled('')).toBe(false);
+      expect(isCommissionFilled('  ')).toBe(false);
+      expect(toCommissionNumber(null)).toBe(null);
+    });
+
+    it('treats 0 as filled', () => {
+      expect(isCommissionFilled(0)).toBe(true);
+      expect(toCommissionNumber(0)).toBe(0);
+      expect(toCommissionNumber('12.5')).toBe(12.5);
+    });
+  });
+
+  describe('resolveEffectiveCommission', () => {
+    it('uses client link commission when filled (override)', () => {
+      const result = resolveEffectiveCommission(
+        { comission: 15, minimum_comission: 5 },
+        { comission: 10, minimum_comission: 2 },
+      );
+      expect(result).toEqual({
+        comission: 15,
+        minimumComission: 5,
+        isOverride: true,
+        source: 'client',
+      });
+    });
+
+    it('falls back to salesman-company default when client commission is empty', () => {
+      const result = resolveEffectiveCommission(
+        { comission: null, minimum_comission: null },
+        { comission: 10, minimum_comission: 2 },
+      );
+      expect(result).toEqual({
+        comission: 10,
+        minimumComission: 2,
+        isOverride: false,
+        source: 'default',
+      });
+    });
+
+    it('returns none when neither client nor default is filled', () => {
+      expect(resolveEffectiveCommission({}, null)).toEqual({
+        comission: null,
+        minimumComission: null,
+        isOverride: false,
+        source: 'none',
+      });
+    });
+
+    it('overrides only the filled field and keeps default for the other', () => {
+      const result = resolveEffectiveCommission(
+        { comission: 20, minimum_comission: null },
+        { comission: 10, minimum_comission: 3 },
+      );
+      expect(result.comission).toBe(20);
+      expect(result.minimumComission).toBe(3);
+      expect(result.isOverride).toBe(true);
+      expect(result.source).toBe('client');
+    });
+  });
+
+  describe('formatCommissionPercent / formatCommissionSubtitle', () => {
+    it('formats percent and subtitle with override/default tags', () => {
+      expect(formatCommissionPercent(10)).toBe('10%');
+      expect(formatCommissionPercent(null)).toBe('—');
+      expect(
+        formatCommissionSubtitle({
+          comission: 15,
+          minimumComission: 5,
+          isOverride: true,
+          source: 'client',
+        }),
+      ).toContain('override');
+      expect(
+        formatCommissionSubtitle({
+          comission: 10,
+          minimumComission: null,
+          isOverride: false,
+          source: 'default',
+        }),
+      ).toContain('padrão');
+    });
+  });
+
+  describe('canEditSalesmanCommission / shouldDisplayCommission', () => {
+    it('allows ROLE_SUPER and ROLE_OWNER only', () => {
+      expect(canEditSalesmanCommission({ roles: ['ROLE_SUPER'] })).toBe(true);
+      expect(canEditSalesmanCommission({ roles: ['ROLE_OWNER'] })).toBe(true);
+      expect(canEditSalesmanCommission({ roles: ['ROLE_EMPLOYEE'] })).toBe(false);
+      expect(canEditSalesmanCommission(null)).toBe(false);
+    });
+
+    it('shows commission only for MANAGER/ADMIN app types', () => {
+      expect(shouldDisplayCommission('MANAGER')).toBe(true);
+      expect(shouldDisplayCommission('ADMIN')).toBe(true);
+      expect(shouldDisplayCommission('CRM')).toBe(false);
+      expect(shouldDisplayCommission('POS')).toBe(false);
+    });
+  });
+
+  describe('indexDefaultSalesmanLinksByPeopleId / buildCommissionSavePayload', () => {
+    it('indexes default salesman links by people id', () => {
+      const map = indexDefaultSalesmanLinksByPeopleId([
+        { id: 1, people: { id: 50 }, comission: 10 },
+        { id: 2, people: '/people/51', comission: 8 },
+      ]);
+      expect(map['50'].comission).toBe(10);
+      expect(map['51'].comission).toBe(8);
+    });
+
+    it('builds save payload with numeric commissions', () => {
+      expect(
+        buildCommissionSavePayload(
+          { id: 101 },
+          { comission: '15', minimumComission: '5' },
+        ),
+      ).toEqual({ id: '101', comission: 15, minimum_comission: 5 });
+      expect(buildCommissionSavePayload({}, { comission: 1, minimumComission: 0 })).toBe(
+        null,
+      );
+    });
+  });
+});

package/src/tests/react/components/tabs/salesmanTabHelpers.test.mjs

@@ -0,0 +1,92 @@
+/**
+ * Unit tests for SalesmanTab commission helpers (override precedence + permissions).
+ * Node native test runner.
+ */
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  isCommissionFilled,
+  toCommissionNumber,
+  resolveEffectiveCommission,
+  canEditSalesmanCommission,
+  shouldDisplayCommission,
+  buildCommissionSavePayload,
+} from '../../../../react/components/tabs/salesmanTabHelpers.js';
+
+describe('salesmanTabHelpers', () => {
+  describe('isCommissionFilled / toCommissionNumber', () => {
+    it('treats null/undefined/empty as not filled', () => {
+      assert.equal(isCommissionFilled(null), false);
+      assert.equal(isCommissionFilled(undefined), false);
+      assert.equal(isCommissionFilled(''), false);
+      assert.equal(isCommissionFilled('  '), false);
+      assert.equal(toCommissionNumber(null), null);
+    });
+
+    it('treats 0 as filled', () => {
+      assert.equal(isCommissionFilled(0), true);
+      assert.equal(toCommissionNumber(0), 0);
+      assert.equal(toCommissionNumber('12.5'), 12.5);
+    });
+  });
+
+  describe('resolveEffectiveCommission', () => {
+    it('prefers client override when filled', () => {
+      const result = resolveEffectiveCommission(
+        { comission: 10, minimum_comission: 5 },
+        { comission: 20, minimum_comission: 8 },
+      );
+      assert.equal(result.comission, 10);
+      assert.equal(result.minimumComission, 5);
+      assert.equal(result.isOverride, true);
+      assert.equal(result.source, 'client');
+    });
+
+    it('falls back to default when client empty', () => {
+      const result = resolveEffectiveCommission(
+        { comission: null, minimum_comission: null },
+        { comission: 15, minimum_comission: 3 },
+      );
+      assert.equal(result.comission, 15);
+      assert.equal(result.minimumComission, 3);
+      assert.equal(result.isOverride, false);
+      assert.equal(result.source, 'default');
+    });
+  });
+
+  describe('canEditSalesmanCommission', () => {
+    it('allows ROLE_SUPER and ROLE_OWNER', () => {
+      assert.equal(canEditSalesmanCommission({ roles: ['ROLE_SUPER'] }), true);
+      assert.equal(canEditSalesmanCommission({ roles: ['ROLE_OWNER'] }), true);
+      assert.equal(canEditSalesmanCommission({ roles: ['ROLE_ADMIN'] }), false);
+      assert.equal(
+        canEditSalesmanCommission(
+          { roles: ['ROLE_ADMIN'] },
+          { user: { owner_enabled: true } },
+        ),
+        true,
+      );
+      assert.equal(canEditSalesmanCommission({}), false);
+    });
+  });
+
+  describe('shouldDisplayCommission', () => {
+    it('shows for MANAGER and ADMIN only', () => {
+      assert.equal(shouldDisplayCommission('MANAGER'), true);
+      assert.equal(shouldDisplayCommission('ADMIN'), true);
+      assert.equal(shouldDisplayCommission('CRM'), false);
+    });
+  });
+
+  describe('buildCommissionSavePayload', () => {
+    it('builds numeric payload with link id', () => {
+      const payload = buildCommissionSavePayload(
+        { id: 42 },
+        { comission: '12.5', minimumComission: '1' },
+      );
+      assert.equal(payload.id, '42');
+      assert.equal(payload.comission, 12.5);
+      assert.equal(payload.minimum_comission, 1);
+    });
+  });
+});

package/src/tests/react/components/tabs/usersTabHelpers.test.js

@@ -0,0 +1,59 @@
+const {
+  extractId,
+  toPeopleIri,
+  normalizeUserItem,
+  toTimezoneIri,
+  toTimezoneItem,
+  extractCollectionItems,
+  extractErrorMessage,
+} = require('../../../../react/components/tabs/usersTabHelpers');
+
+describe('usersTabHelpers', () => {
+  test('extractId strips non-digits', () => {
+    expect(extractId('/timezones/42')).toBe('42');
+    expect(extractId(7)).toBe('7');
+  });
+
+  test('toTimezoneIri builds IRI', () => {
+    expect(toTimezoneIri(3)).toBe('/timezones/3');
+    expect(toTimezoneIri('/timezones/9')).toBe('/timezones/9');
+    expect(toTimezoneIri('')).toBe(null);
+  });
+
+  test('toPeopleIri builds API Platform IRI', () => {
+    expect(toPeopleIri(106218)).toBe('/people/106218');
+    expect(toPeopleIri('/people/9')).toBe('/people/9');
+    expect(toPeopleIri('')).toBe('');
+  });
+
+  test('extractErrorMessage maps Authentication required', () => {
+    expect(extractErrorMessage({message: 'Authentication required'})).toMatch(/Autenticação necessária/);
+    expect(
+      extractErrorMessage({response: {status: 401, data: {message: 'Authentication required'}}}),
+    ).toMatch(/Autenticação necessária/);
+  });
+
+  test('toTimezoneItem maps entry', () => {
+    expect(toTimezoneItem({id: 1, name: 'America/Sao_Paulo'})).toEqual({
+      id: '1',
+      name: 'America/Sao_Paulo',
+      displayName: 'America/Sao_Paulo',
+    });
+  });
+
+  test('normalizeUserItem keeps timezoneId', () => {
+    const item = normalizeUserItem({
+      id: 10,
+      username: 'alice',
+      timezone: '/timezones/5',
+    });
+    expect(item.timezoneId).toBe('5');
+    expect(item.username).toBe('alice');
+  });
+
+  test('extractCollectionItems supports hydra and member', () => {
+    expect(extractCollectionItems({'hydra:member': [{id: 1}]}).length).toBe(1);
+    expect(extractCollectionItems({member: [{id: 2}]}).length).toBe(1);
+    expect(extractCollectionItems([{id: 3}]).length).toBe(1);
+  });
+});

package/src/tests/react/domain/productSupplierFlow.test.mjs

@@ -0,0 +1,55 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  buildCreateProductParams,
+  buildInitialProviderPayload,
+  extractId,
+} from '../../../react/domain/productSupplierFlow.js';
+
+test('extractId normalizes numeric ids and hydra ids', () => {
+  assert.equal(extractId(42), '42');
+  assert.equal(extractId('/people/17'), '17');
+  assert.equal(extractId({ '@id': '/people/81' }), '81');
+});
+
+test('buildInitialProviderPayload keeps provider identity when only id is available', () => {
+  const payload = buildInitialProviderPayload({
+    id: 15,
+    alias: 'Fornecedor XPTO',
+    name: 'Fornecedor XPTO LTDA',
+    peopleType: 'provider',
+  });
+
+  assert.deepEqual(payload, {
+    id: '15',
+    '@id': '/people/15',
+    alias: 'Fornecedor XPTO',
+    name: 'Fornecedor XPTO LTDA',
+    peopleType: 'provider',
+  });
+});
+
+test('buildCreateProductParams returns null when provider has no valid id', () => {
+  assert.equal(buildCreateProductParams({ alias: 'Sem id' }), null);
+});
+
+test('buildCreateProductParams forwards supplier context to ProductDetails', () => {
+  const params = buildCreateProductParams({
+    '@id': '/people/33',
+    alias: 'Fornecedor Central',
+    name: 'Fornecedor Central SA',
+    peopleType: 'provider',
+  });
+
+  assert.deepEqual(params, {
+    context: 'products',
+    initialProvider: {
+      id: '33',
+      '@id': '/people/33',
+      alias: 'Fornecedor Central',
+      name: 'Fornecedor Central SA',
+      peopleType: 'provider',
+    },
+  });
+});

package/src/tests/react/pages/clientDetailsHelpers.test.js

@@ -0,0 +1,98 @@
+/**
+ * Unit tests for ClientDetails pure helpers (app-community#297 modularization).
+ */
+import {
+  resolveContextKey,
+  normalizeCollection,
+  buildClientTabDefs,
+  resolveInitialTabIndex,
+  extractId,
+  resolveRouteClientId,
+  resolveRouteClientSeed,
+} from '../../../react/pages/clientDetailsHelpers';
+
+describe('clientDetailsHelpers', () => {
+  it('resolveContextKey normalizes string and object context', () => {
+    expect(resolveContextKey(' Provider ')).toBe('provider');
+    expect(resolveContextKey({ context: 'Contacts' })).toBe('contacts');
+    expect(resolveContextKey(null)).toBe('');
+  });
+
+  it('normalizeCollection handles hydra and plain arrays', () => {
+    expect(normalizeCollection([{ id: 1 }])).toEqual([{ id: 1 }]);
+    expect(normalizeCollection({ 'hydra:member': [{ id: 2 }] })).toEqual([{ id: 2 }]);
+    expect(normalizeCollection(null)).toEqual([]);
+  });
+
+  it('extractId strips non-digits', () => {
+    expect(extractId('/people/42')).toBe('42');
+    expect(extractId(7)).toBe('7');
+  });
+
+  it('resolves client id and seed from CRM navigation params', () => {
+    const client = {
+      '@id': '/people/9',
+      id: 9,
+      name: 'Cliente Teste',
+    };
+
+    expect(resolveRouteClientSeed({ client })).toBe(client);
+    expect(resolveRouteClientId({ client })).toBe('9');
+    expect(resolveRouteClientId({ clientId: '11', client })).toBe('11');
+    expect(resolveRouteClientId({ companyId: '12', client })).toBe('12');
+  });
+
+  it('buildClientTabDefs includes media and contacts for PJ', () => {
+    const tabs = buildClientTabDefs({
+      isPessoaJuridica: true,
+      isProviderContext: false,
+      t: { t: (_ns, _k, key) => key },
+    });
+    expect(tabs.map(t => t.key)).toEqual([
+      'general',
+      'media',
+      'sellers',
+      'contacts',
+      'contracts',
+    ]);
+  });
+
+  it('does not expose Categories for a person or resolve it by deep link', () => {
+    const tabs = buildClientTabDefs({
+      isPessoaJuridica: false,
+      isProviderContext: false,
+      t: { t: (_ns, _k, key) => key },
+    });
+
+    expect(tabs.map(t => t.key)).toEqual([
+      'general',
+      'media',
+      'users',
+      'contracts',
+    ]);
+    expect(
+      resolveInitialTabIndex({
+        requestedInitialTab: 'categories',
+        nextClient: { peopleType: 'F' },
+        detailContext: 'employee',
+      }),
+    ).toBe(0);
+  });
+
+  it('resolveInitialTabIndex respects requested tab and defaults to 0', () => {
+    expect(
+      resolveInitialTabIndex({
+        requestedInitialTab: 'media',
+        nextClient: { peopleType: 'J' },
+        detailContext: '',
+      }),
+    ).toBe(1);
+    expect(
+      resolveInitialTabIndex({
+        requestedInitialTab: '',
+        nextClient: { peopleType: 'F' },
+        detailContext: '',
+      }),
+    ).toBe(0);
+  });
+});

package/src/tests/react/pages/employees.test.js

@@ -0,0 +1,44 @@
+/* global jest */
+
+const {describe, expect, it, beforeEach, afterEach} = global
+
+jest.mock('@controleonline/ui-people/src/react/pages/People', () => 'People')
+
+const {
+  buildEmployeesContext,
+} = require('../../../react/pages/employees')
+
+describe('employees page context', () => {
+  const originalTranslator = global.t
+
+  beforeEach(() => {
+    global.t = {
+      t: (scope, group, key) => `${scope}.${group}.${key}`,
+    }
+  })
+
+  afterEach(() => {
+    global.t = originalTranslator
+  })
+
+  it('exposes courier alongside the default employee roles', () => {
+    const context = buildEmployeesContext({})
+
+    expect(context.context).toEqual(['all', 'employee', 'owner', 'courier'])
+    expect(context.defaultContext).toBe('all')
+    expect(context.selectedContext).toBe('all')
+    expect(context.defaultPeopleType).toBe('J')
+    expect(context.modalTitleByType.courier).toBe('Cadastro de Entregador')
+  })
+
+  it('keeps courier as the default physical-person role when selected directly', () => {
+    const context = buildEmployeesContext({
+      selectedContext: 'courier',
+    })
+
+    expect(context.context).toEqual(['courier'])
+    expect(context.defaultContext).toBe('courier')
+    expect(context.selectedContext).toBe('courier')
+    expect(context.defaultPeopleType).toBe('F')
+  })
+})