@controleonline/ui-default 1.0.270 → 1.0.273

package/src/tests/react/filters/filterValue.test.js

@@ -0,0 +1,46 @@
+import {
+  countActiveFilters,
+  isFilledFilterValue,
+  omitEmptyFilters,
+} from '../../../react/components/filters/filterValue';
+
+describe('filterValue', () => {
+  it('treats empty strings, null and empty collections as inactive', () => {
+    expect(isFilledFilterValue('')).toBe(false);
+    expect(isFilledFilterValue('   ')).toBe(false);
+    expect(isFilledFilterValue(null)).toBe(false);
+    expect(isFilledFilterValue(undefined)).toBe(false);
+    expect(isFilledFilterValue([])).toBe(false);
+    expect(isFilledFilterValue({})).toBe(false);
+  });
+
+  it('does not count date shortcut all or empty custom range', () => {
+    expect(isFilledFilterValue({shortcut: 'all'})).toBe(false);
+    expect(
+      isFilledFilterValue({
+        shortcut: 'custom',
+        customRange: {from: '', to: ''},
+      }),
+    ).toBe(false);
+    expect(isFilledFilterValue({shortcut: '7d'})).toBe(true);
+    expect(
+      isFilledFilterValue({
+        shortcut: 'custom',
+        customRange: {from: '2026-01-01', to: ''},
+      }),
+    ).toBe(true);
+  });
+
+  it('clears leftover empty filters when counting and omitting', () => {
+    const filters = {
+      status: '',
+      search: '   ',
+      period: {shortcut: 'all', customRange: {from: '', to: ''}},
+      page: 1,
+      category: 'sales',
+    };
+
+    expect(countActiveFilters(filters)).toBe(1);
+    expect(omitEmptyFilters(filters)).toEqual({category: 'sales'});
+  });
+});

package/src/tests/react/hooks/usePostalCodeLookup.test.js

@@ -0,0 +1,107 @@
+/**
+ * Behavioral tests for race / debounce contract of CEP lookup helpers.
+ * Hook itself is integration-tested via merge + request-id logic mirrored here.
+ */
+import {mergePostalCodeData, onlyDigits} from '../../../react/services/addressFormUtils';
+
+describe('CEP lookup race contract', () => {
+  test('onlyDigits length gate for lookup', () => {
+    expect(onlyDigits('01310-10').length).toBe(7);
+    expect(onlyDigits('01310-100').length).toBe(8);
+  });
+
+  test('stale response simulation: last write wins by request id', () => {
+    let form = {
+      nickname: 'X',
+      number: '9',
+      complement: '',
+      street: '',
+      district: '',
+      city: '',
+      uf: '',
+      cep: '',
+      countryCode: 'BR',
+      countryName: 'Brazil',
+    };
+    let requestId = 0;
+    const apply = (id, data) => {
+      if (id !== requestId) return; // stale
+      form = mergePostalCodeData({...form, cep: data.cep}, data);
+    };
+    const first = ++requestId;
+    const second = ++requestId;
+    apply(first, {cep: '11111111', street: 'Old'});
+    apply(second, {cep: '01310100', street: 'Av Paulista'});
+    expect(form.street).toBe('Av Paulista');
+    expect(form.cep).toBe('01310100');
+    expect(form.number).toBe('9');
+    expect(form.nickname).toBe('X');
+  });
+});
+
+import {
+  GEOCODE_MISS_MESSAGE,
+  isGeocodeMiss,
+  mergePostalCodeData,
+  parseOptionalCoordinate,
+} from '../../../react/services/addressFormUtils';
+
+describe('geocode miss (#696)', () => {
+  test('isGeocodeMiss when address text exists and coords are null', () => {
+    expect(
+      isGeocodeMiss({
+        street: 'Rua Lotus',
+        district: 'Condomínio Jardim das Palmeiras',
+        city: 'Bragança Paulista',
+        uf: 'SP',
+        latitude: null,
+        longitude: null,
+      }),
+    ).toBe(true);
+  });
+
+  test('isGeocodeMiss false when Nominatim returns coords', () => {
+    expect(
+      isGeocodeMiss({
+        street: 'Rua Antônio Bonini',
+        city: 'Atibaia',
+        uf: 'SP',
+        latitude: -23.12,
+        longitude: -46.55,
+      }),
+    ).toBe(false);
+  });
+
+  test('mergePostalCodeData clears previous coords when lookup returns null', () => {
+    const prev = {
+      street: 'Old',
+      latitude: -23.1,
+      longitude: -46.5,
+      number: '10',
+      complement: '',
+      nickname: 'X',
+      cep: '12941040',
+    };
+    const next = mergePostalCodeData(prev, {
+      cep: '12924022',
+      street: 'Rua Lotus',
+      city: 'Bragança Paulista',
+      uf: 'SP',
+      latitude: null,
+      longitude: null,
+    });
+    expect(next.street).toBe('Rua Lotus');
+    expect(next.latitude).toBeNull();
+    expect(next.longitude).toBeNull();
+    expect(next.number).toBe('10');
+  });
+
+  test('parseOptionalCoordinate accepts comma decimals', () => {
+    expect(parseOptionalCoordinate('-23,5505')).toBeCloseTo(-23.5505);
+  });
+
+  test('GEOCODE_MISS_MESSAGE is PT', () => {
+    expect(GEOCODE_MISS_MESSAGE).toMatch(/localização no mapa/);
+    expect(GEOCODE_MISS_MESSAGE).toMatch(/latitude e longitude/);
+  });
+});

package/src/tests/react/inputs/defaultInputUtils.test.js

@@ -12,11 +12,19 @@ jest.mock('@controleonline/ui-common/src/react/utils/storeColumns', () => ({
 
 const {
   buildReadPresentationStyles,
+  isIconColumn,
   mapOptions,
   resolveCellPresentation,
 } = require('../../../react/components/inputs/defaultInputUtils');
-
+
 describe('defaultInputUtils', () => {
+  it('identifies icon columns by input type or field name', () => {
+    expect(isIconColumn({inputType: 'icon', name: 'symbol'})).toBe(true);
+    expect(isIconColumn({type: 'ICON', name: 'symbol'})).toBe(true);
+    expect(isIconColumn({name: 'icon'})).toBe(true);
+    expect(isIconColumn({name: 'status'})).toBe(false);
+  });
+
   it('deduplicates list options by normalized key', () => {
     const column = {
       formatList(item) {

package/src/tests/react/services/SMOKE-637-cep-hydrate.md

@@ -0,0 +1,45 @@
+# fluxo: address-cep-hydrate
+
+Issue: ControleOnline/app-community#637
+CEP: 12941040
+Data: 2026-08-27
+
+## Smoke UI (browser)
+
+Harness: `src/tests/react/services/smoke-637/index.html`
+Print: `src/tests/react/services/smoke-637/form-cep-12941040.png`
+
+Algoritmo idêntico a `lookupPostalCode` (`addressGeo.js`):
+API postal-codes → ViaCEP se street/city vazios → Nominatim se coords faltarem.
+
+Campos com os mesmos `testID`s do `DefaultAddress`:
+`address-cep-input`, `address-street-input`, `address-district-input`,
+`address-city-input`, `address-latitude-input`, `address-longitude-input`.
+
+### Observado no browser (2026-08-27)
+
+- Tela aberta com formulário de endereço
+- CEP `12941040` hidrata:
+  - rua = Rua Antônio Bonini
+  - bairro = Vila Santista
+  - cidade = Atibaia
+  - UF = SP
+  - lat = -23.117082 ≠ —
+  - lon = -46.5425915 ≠ —
+- Provider merge: `viacep+googlemaps+viacep-client`
+- Mapa OSM centrado em Vila Santista / Atibaia (pin na Rua Antônio Bonini)
+- Mensagem *Postalcode services are not available* **não** ocorreu
+- Console: sem erro da entrega no harness
+
+## Passos runtime
+
+1. `GET /postal-codes/12941040` (ADMIN) → **200**, street/city vazios, coords preenchidas
+2. ViaCEP 200 → texto Atibaia/SP
+3. Merge texto + coords da API
+4. Leaflet `setView` Atibaia, zoom 16
+
+## Resultado
+
+**PASS** UI form + mapa Atibaia + lat/lon preenchidos
+
+Pin de produto em staging/prod continua fora do papel Developer (não promove `staging`).

package/src/tests/react/services/addressFormUtils.test.js

@@ -0,0 +1,179 @@
+import {
+  mergePostalCodeData,
+  clearPostalCodeDerivedFields,
+  onlyDigits,
+  hydrateAddressFromRow,
+  hasCoordinates,
+  parseOptionalCoordinate,
+  formatCepMask,
+  normalizeCepDigits,
+} from '../../../react/services/addressFormUtils';
+
+describe('addressFormUtils', () => {
+  test('onlyDigits strips non-digits and keeps order', () => {
+    expect(onlyDigits('01310-100')).toBe('01310100');
+    expect(onlyDigits('abc')).toBe('');
+  });
+
+  test('mergePostalCodeData fills empty fields from API', () => {
+    const prev = {
+      nickname: 'Casa',
+      number: '100',
+      complement: 'Apto 1',
+      cep: '',
+      street: '',
+      district: '',
+      city: '',
+      uf: '',
+      stateName: '',
+      countryCode: 'BR',
+      countryName: 'Brazil',
+      latitude: null,
+      longitude: null,
+    };
+    const data = {
+      cep: '01310100',
+      street: 'Av Paulista',
+      district: 'Bela Vista',
+      city: 'São Paulo',
+      uf: 'SP',
+      state: 'São Paulo',
+      country: 'Brasil',
+      latitude: -23.5,
+      longitude: -46.6,
+    };
+    const next = mergePostalCodeData(prev, data);
+    expect(next.street).toBe('Av Paulista');
+    expect(next.district).toBe('Bela Vista');
+    expect(next.city).toBe('São Paulo');
+    expect(next.uf).toBe('SP');
+    expect(next.cep).toBe('01310100');
+    expect(next.number).toBe(''); // cleared on CEP lookup (#746)
+    expect(next.complement).toBe('Apto 1');
+    expect(next.nickname).toBe('Casa');
+    expect(next.countryCode).toBe('BR');
+  });
+
+  test('mergePostalCodeData clears number but keeps complement/nickname (#746)', () => {
+    const prev = {
+      nickname: 'Trabalho',
+      number: '42',
+      complement: 'Sala 3',
+      street: 'Rua X',
+      district: 'Centro',
+      city: 'Rio',
+      uf: 'RJ',
+      cep: '20000000',
+      countryCode: 'BR',
+      countryName: 'Brazil',
+    };
+    const data = {
+      cep: '01310100',
+      street: 'Av Paulista',
+      district: 'Bela Vista',
+      city: 'São Paulo',
+      uf: 'SP',
+      country: 'Brazil',
+    };
+    const next = mergePostalCodeData(prev, data);
+    expect(next.number).toBe('');
+    expect(next.complement).toBe('Sala 3');
+    expect(next.nickname).toBe('Trabalho');
+    expect(next.street).toBe('Av Paulista');
+  });
+
+  test('preserveFilledFields keeps existing street/city', () => {
+    const prev = {
+      nickname: '',
+      number: '1',
+      complement: '',
+      street: 'Minha Rua',
+      district: '',
+      city: 'Minha Cidade',
+      uf: '',
+      cep: '01310100',
+      countryCode: 'BR',
+      countryName: 'Brazil',
+    };
+    const data = {
+      street: 'API Street',
+      district: 'API Dist',
+      city: 'API City',
+      uf: 'SP',
+      cep: '01310100',
+    };
+    const next = mergePostalCodeData(prev, data, {preserveFilledFields: true});
+    expect(next.street).toBe('Minha Rua');
+    expect(next.city).toBe('Minha Cidade');
+    expect(next.district).toBe('API Dist');
+    expect(next.uf).toBe('SP');
+  });
+
+  test('hydrateAddressFromRow maps nested street entities', () => {
+    const row = {
+      nickname: 'HQ',
+      number: 10,
+      complement: 'Bloco B',
+      street: {
+        street: 'Rua Nested',
+        district: {
+          district: 'Centro',
+          city: {
+            city: 'Campinas',
+            state: {uf: 'SP', state: 'São Paulo', country: {countrycode: 'BR', countryname: 'Brazil'}},
+          },
+        },
+        cep: {cep: '13000000'},
+      },
+    };
+    const form = hydrateAddressFromRow(row);
+    expect(form.street).toBe('Rua Nested');
+    expect(form.district).toBe('Centro');
+    expect(form.city).toBe('Campinas');
+    expect(form.uf).toBe('SP');
+    expect(form.cep).toBe('13000000');
+    expect(form.number).toBe('10');
+  });
+
+  test('hasCoordinates requires finite lat/lng', () => {
+    expect(hasCoordinates({latitude: -23, longitude: -46})).toBe(true);
+    expect(hasCoordinates({latitude: null, longitude: -46})).toBe(false);
+    expect(hasCoordinates({latitude: 0, longitude: 0})).toBe(false);
+    expect(hasCoordinates({latitude: '0', longitude: '0'})).toBe(false);
+  });
+
+  test('parseOptionalCoordinate returns null for empty/invalid', () => {
+    expect(parseOptionalCoordinate('')).toBeNull();
+    expect(parseOptionalCoordinate('   ')).toBeNull();
+    expect(parseOptionalCoordinate(null)).toBeNull();
+    expect(parseOptionalCoordinate(undefined)).toBeNull();
+    expect(parseOptionalCoordinate('abc')).toBeNull();
+  });
+
+  test('parseOptionalCoordinate parses valid decimal coordinates', () => {
+    expect(parseOptionalCoordinate('-23.5505')).toBeCloseTo(-23.5505);
+    expect(parseOptionalCoordinate('-46.6333')).toBeCloseTo(-46.6333);
+    expect(parseOptionalCoordinate('0')).toBe(0);
+    expect(parseOptionalCoordinate(' 12.5 ')).toBeCloseTo(12.5);
+  });
+});
+
+describe('formatCepMask / normalizeCepDigits', () => {
+  test('normalizeCepDigits caps at 8 digits', () => {
+    expect(normalizeCepDigits('013101001')).toBe('01310100');
+    expect(normalizeCepDigits('01310-1001')).toBe('01310100');
+    expect(normalizeCepDigits('01310-100')).toBe('01310100');
+  });
+
+  test('formatCepMask applies #####-###', () => {
+    expect(formatCepMask('01310')).toBe('01310');
+    expect(formatCepMask('013101')).toBe('01310-1');
+    expect(formatCepMask('01310100')).toBe('01310-100');
+    expect(formatCepMask('013101001')).toBe('01310-100');
+  });
+
+  test('lookup gate: only 8 digits', () => {
+    expect(onlyDigits(formatCepMask('01310-10')).length).toBe(7);
+    expect(onlyDigits(formatCepMask('01310-100')).length).toBe(8);
+  });
+});

package/src/tests/react/services/addressGeoLookup.async.test.js

@@ -0,0 +1,104 @@
+/* global describe, expect, test, beforeEach */
+
+jest.mock('@controleonline/ui-common/src/api', () => ({
+  api: {
+    fetch: jest.fn(),
+  },
+}));
+
+const {api} = require('@controleonline/ui-common/src/api');
+const {lookupPostalCode} = require('../../../react/services/addressGeo');
+const {mergePostalCodeData} = require('../../../react/services/addressFormUtils');
+
+const CEP = '12941040';
+
+const API_PROD_INCOMPLETE = {
+  cep: CEP,
+  street: '',
+  district: '',
+  city: '',
+  state: '',
+  uf: '',
+  country: 'Brasil',
+  latitude: -23.117082,
+  longitude: -46.5425915,
+  provider: 'viacep+googlemaps',
+};
+
+describe('lookupPostalCode #637 (prod payload + client fallback)', () => {
+  beforeEach(() => {
+    api.fetch.mockReset();
+    global.fetch = jest.fn();
+  });
+
+  test('API 200 with empty street/city is completed by ViaCEP; coords stay from API', async () => {
+    api.fetch.mockResolvedValue(API_PROD_INCOMPLETE);
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        erro: false,
+        logradouro: 'Rua Antônio Bonini',
+        bairro: 'Vila Santista',
+        localidade: 'Atibaia',
+        uf: 'SP',
+      }),
+    });
+
+    const payload = await lookupPostalCode(CEP);
+
+    expect(api.fetch).toHaveBeenCalledWith(`postal-codes/${CEP}`, {
+      method: 'GET',
+    });
+    expect(payload.street).toBe('Rua Antônio Bonini');
+    expect(payload.city).toBe('Atibaia');
+    expect(payload.uf).toBe('SP');
+    expect(payload.district).toBe('Vila Santista');
+    expect(Number(payload.latitude)).toBeCloseTo(-23.117, 2);
+    expect(Number(payload.longitude)).toBeCloseTo(-46.543, 2);
+    expect(String(payload.provider)).toContain('viacep-client');
+
+    const form = mergePostalCodeData(
+      {
+        nickname: '',
+        number: '',
+        complement: '',
+        cep: CEP,
+        street: '',
+        district: '',
+        city: '',
+        uf: '',
+        countryCode: 'BR',
+        latitude: null,
+        longitude: null,
+      },
+      payload,
+    );
+    expect(form.street).toBe('Rua Antônio Bonini');
+    expect(form.city).toBe('Atibaia');
+    expect(form.uf).toBe('SP');
+    expect(String(form.latitude)).not.toBe('');
+    expect(String(form.latitude)).not.toBe('—');
+    expect(String(form.longitude)).not.toBe('—');
+  });
+
+  test('does not throw Postalcode services are not available when ViaCEP fills text', async () => {
+    api.fetch.mockRejectedValue({
+      message: 'Postalcode services are not available',
+      response: {data: {detail: 'Postalcode services are not available'}},
+    });
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        logradouro: 'Rua Antônio Bonini',
+        bairro: 'Vila Santista',
+        localidade: 'Atibaia',
+        uf: 'SP',
+      }),
+    });
+
+    const payload = await lookupPostalCode(CEP);
+    expect(payload.street).toBe('Rua Antônio Bonini');
+    expect(payload.city).toBe('Atibaia');
+    expect(payload.uf).toBe('SP');
+  });
+});

package/src/tests/react/services/addressGeoLookup.test.js

@@ -0,0 +1,105 @@
+import {
+  isPostalLookupIncomplete,
+  isValidCoord,
+  mergePostalLookupPayload,
+} from '../../../react/services/addressGeo';
+import {mergePostalCodeData} from '../../../react/services/addressFormUtils';
+
+describe('addressGeo CEP fallback helpers', () => {
+  test('isValidCoord rejects empty and 0,0 defaults', () => {
+    expect(isValidCoord(null)).toBe(false);
+    expect(isValidCoord(0)).toBe(false);
+    expect(isValidCoord(-23.117)).toBe(true);
+  });
+
+  test('incomplete when API returns coords without street/city', () => {
+    expect(
+      isPostalLookupIncomplete({
+        street: '',
+        city: '',
+        latitude: -23.117082,
+        longitude: -46.5425915,
+        provider: 'viacep+googlemaps',
+      }),
+    ).toBe(true);
+  });
+
+  test('merge fills ViaCEP text and keeps API coords', () => {
+    const merged = mergePostalLookupPayload(
+      {
+        street: '',
+        city: '',
+        latitude: -23.117082,
+        longitude: -46.5425915,
+        provider: 'viacep+googlemaps',
+      },
+      {
+        street: 'Rua Antônio Bonini',
+        district: 'Vila Santista',
+        city: 'Atibaia',
+        uf: 'SP',
+        country: 'Brasil',
+      },
+      'viacep-client',
+    );
+    expect(merged.street).toBe('Rua Antônio Bonini');
+    expect(merged.city).toBe('Atibaia');
+    expect(merged.uf).toBe('SP');
+    expect(merged.latitude).toBe(-23.117082);
+    expect(merged.provider).toBe('viacep+googlemaps+viacep-client');
+  });
+
+  test('#637 form hydrate: API empty street + ViaCEP + coords → Atibaia fields', () => {
+    const apiProd = {
+      cep: '12941040',
+      street: '',
+      district: '',
+      city: '',
+      state: '',
+      uf: '',
+      country: 'Brasil',
+      latitude: -23.117082,
+      longitude: -46.5425915,
+      provider: 'viacep+googlemaps',
+    };
+    expect(isPostalLookupIncomplete(apiProd)).toBe(true);
+
+    const afterViaCep = mergePostalLookupPayload(
+      apiProd,
+      {
+        street: 'Rua Antônio Bonini',
+        district: 'Vila Santista',
+        city: 'Atibaia',
+        uf: 'SP',
+        country: 'Brasil',
+        provider: 'viacep-client',
+      },
+      'viacep-client',
+    );
+    expect(isPostalLookupIncomplete(afterViaCep)).toBe(false);
+
+    const form = mergePostalCodeData(
+      {
+        nickname: '',
+        number: '',
+        complement: '',
+        cep: '12941040',
+        street: '',
+        district: '',
+        city: '',
+        uf: '',
+        countryCode: 'BR',
+        latitude: null,
+        longitude: null,
+      },
+      afterViaCep,
+    );
+    expect(form.street).toBe('Rua Antônio Bonini');
+    expect(form.city).toBe('Atibaia');
+    expect(form.uf).toBe('SP');
+    expect(Number(form.latitude)).toBeCloseTo(-23.117, 2);
+    expect(Number(form.longitude)).toBeCloseTo(-46.543, 2);
+    expect(form.street).not.toBe('—');
+    expect(form.city).not.toBe('—');
+  });
+});