@controleonline/ui-default 1.0.270 → 1.0.272

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

@@ -0,0 +1,176 @@
+import {
+  mergePostalCodeData,
+  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('100');
+    expect(next.complement).toBe('Apto 1');
+    expect(next.nickname).toBe('Casa');
+    expect(next.countryCode).toBe('BR');
+  });
+
+  test('mergePostalCodeData never clears number/complement/nickname', () => {
+    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('42');
+    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);
+  });
+
+  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('—');
+  });
+});

package/src/tests/react/services/smoke-637/index.html

@@ -0,0 +1,132 @@
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+  <meta charset="utf-8" />
+  <title>Smoke #637 — address-cep-hydrate</title>
+  <link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />
+  <style>
+    body { font-family: system-ui, sans-serif; margin: 16px; background: #f6f7f9; }
+    h1 { font-size: 18px; }
+    label { display: block; font-size: 12px; color: #555; margin-top: 8px; }
+    input { width: 100%; max-width: 420px; padding: 8px; font-size: 14px; }
+    #map { height: 320px; width: 100%; max-width: 720px; margin-top: 12px; border: 1px solid #ccc; }
+    .row { display: flex; gap: 12px; flex-wrap: wrap; }
+    .col { flex: 1; min-width: 200px; }
+    #status { margin-top: 8px; font-size: 13px; }
+    .ok { color: #0a7; }
+    .err { color: #c00; }
+  </style>
+</head>
+<body>
+  <h1>DefaultAddress smoke — CEP hydrate (#637)</h1>
+  <p>fluxo: address-cep-hydrate · CEP 12941040 · pin ui-default lookupPostalCode</p>
+  <div class="row">
+    <div class="col">
+      <label>CEP</label>
+      <input id="address-cep-input" data-testid="address-cep-input" value="12941040" />
+      <label>Rua</label>
+      <input id="address-street-input" data-testid="address-street-input" />
+      <label>Bairro</label>
+      <input id="address-district-input" data-testid="address-district-input" />
+      <label>Cidade</label>
+      <input id="address-city-input" data-testid="address-city-input" />
+      <label>UF</label>
+      <input id="address-uf-input" data-testid="address-uf-input" />
+    </div>
+    <div class="col">
+      <label>Latitude</label>
+      <input id="address-latitude-input" data-testid="address-latitude-input" value="—" />
+      <label>Longitude</label>
+      <input id="address-longitude-input" data-testid="address-longitude-input" value="—" />
+      <label>Provider</label>
+      <input id="address-provider-input" />
+    </div>
+  </div>
+  <div id="status">aguardando lookup…</div>
+  <div id="map"></div>
+  <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"></script>
+  <script>
+    const TOKEN = '4a073f4bf39f4a2ed19818baf44c4b3d';
+    const API = 'https://api.controleonline.com';
+    const onlyDigits = v => String(v || '').replace(/\D+/g, '');
+    const hasText = v => String(v || '').trim().length > 0;
+    const isValidCoord = v => {
+      if (v === null || v === undefined || v === '' || v === '—') return false;
+      const n = Number(v);
+      return Number.isFinite(n) && Math.abs(n) > 0.000001;
+    };
+    function merge(base, extra, suffix) {
+      const next = { ...(base || {}) };
+      const fill = (k, val) => { if (!hasText(next[k]) && hasText(val)) next[k] = val; };
+      fill('street', extra.street);
+      fill('district', extra.district);
+      fill('city', extra.city);
+      fill('state', extra.state || extra.uf);
+      fill('uf', extra.uf || extra.state);
+      if (!isValidCoord(next.latitude) && isValidCoord(extra.latitude)) next.latitude = Number(extra.latitude);
+      if (!isValidCoord(next.longitude) && isValidCoord(extra.longitude)) next.longitude = Number(extra.longitude);
+      if (suffix) next.provider = next.provider ? next.provider + '+' + suffix : suffix;
+      return next;
+    }
+    async function lookupPostalCode(cep) {
+      const digits = onlyDigits(cep);
+      let payload = { cep: digits };
+      try {
+        const r = await fetch(API + '/postal-codes/' + digits, {
+          headers: {
+            accept: 'application/ld+json',
+            'api-token': TOKEN,
+            'app-domain': 'admin.controleonline.com',
+            device: 'web-7',
+            'device-type': 'ADMIN'
+          }
+        });
+        if (r.ok) {
+          const apiData = await r.json();
+          payload = { ...payload, ...apiData, cep: digits };
+        }
+      } catch (e) {}
+      if (!hasText(payload.street) || !hasText(payload.city)) {
+        const vr = await fetch('https://viacep.com.br/ws/' + digits + '/json/');
+        const json = await vr.json();
+        payload = merge(payload, {
+          street: json.logradouro, district: json.bairro, city: json.localidade, uf: json.uf, state: json.uf
+        }, 'viacep-client');
+      }
+      if (!isValidCoord(payload.latitude) || !isValidCoord(payload.longitude)) {
+        const q = encodeURIComponent([payload.street, payload.district, payload.city, payload.uf, 'Brasil'].filter(Boolean).join(', '));
+        const nr = await fetch('https://nominatim.openstreetmap.org/search?format=json&limit=1&q=' + q, {
+          headers: { 'Accept-Language': 'pt-BR' }
+        });
+        const arr = await nr.json();
+        if (arr[0]) payload = merge(payload, { latitude: arr[0].lat, longitude: arr[0].lon }, 'nominatim-client');
+      }
+      return payload;
+    }
+    const map = L.map('map').setView([0, 0], 2);
+    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', { attribution: '© OSM' }).addTo(map);
+    lookupPostalCode('12941040').then(p => {
+      document.getElementById('address-street-input').value = p.street || '';
+      document.getElementById('address-district-input').value = p.district || '';
+      document.getElementById('address-city-input').value = p.city || '';
+      document.getElementById('address-uf-input').value = p.uf || p.state || '';
+      document.getElementById('address-latitude-input').value = p.latitude;
+      document.getElementById('address-longitude-input').value = p.longitude;
+      document.getElementById('address-provider-input').value = p.provider || '';
+      const lat = Number(p.latitude), lon = Number(p.longitude);
+      map.setView([lat, lon], 16);
+      L.marker([lat, lon]).addTo(map);
+      const ok = p.city === 'Atibaia' && Math.abs(lat + 23.11) < 0.05;
+      const st = document.getElementById('status');
+      st.className = ok ? 'ok' : 'err';
+      st.textContent = ok
+        ? 'OK: rua=' + p.street + ' cidade=' + p.city + ' UF=' + (p.uf||p.state) + ' lat/lon preenchidos mapa Atibaia'
+        : 'FAIL payload=' + JSON.stringify(p);
+      window.__SMOKE637__ = p;
+    }).catch(e => {
+      document.getElementById('status').className = 'err';
+      document.getElementById('status').textContent = String(e);
+    });
+  </script>
+</body>
+</html>