@controleonline/ui-default 1.0.269 → 1.0.272

package/src/tests/react/components/upload/DefaultUpload.test.js

@@ -0,0 +1,353 @@
+const mockReact = require('react');
+const renderer = require('react-test-renderer');
+
+const {describe, expect, it, beforeEach} = global;
+
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+const mockFileActions = {
+  getItems: jest.fn(),
+};
+
+const mockRelationActions = {
+  save: jest.fn(),
+  remove: jest.fn(),
+};
+
+jest.mock('@env', () => ({
+  env: {
+    API_ENTRYPOINT: 'https://api.controleonline.com',
+    DOMAIN: 'manager.controleonline.com',
+  },
+}), {virtual: true});
+
+jest.mock('@store', () => ({
+  useStore: jest.fn(name => {
+    if (name === 'file') {
+      return {
+        actions: mockFileActions,
+        getters: {},
+      };
+    }
+
+    if (name === 'product_file' || name === 'category_file') {
+      return {
+        actions: mockRelationActions,
+        getters: {},
+      };
+    }
+
+    return {
+      actions: {},
+      getters: {},
+    };
+  }),
+}), {virtual: true});
+
+jest.mock(
+  '@expo/vector-icons',
+  () => ({
+    MaterialCommunityIcons: props =>
+      mockReact.createElement('icon', props, props.children),
+  }),
+  {virtual: true},
+);
+
+jest.mock('react-native-vector-icons/Feather', () => props =>
+  mockReact.createElement('feathericon', props, props.children),
+  {virtual: true},
+);
+
+jest.mock('@controleonline/ui-common/src/react/components/AnimatedModal', () => {
+  return props => (props.visible ? mockReact.createElement('modal', props, props.children) : null);
+}, {virtual: true});
+
+jest.mock('@controleonline/ui-default/src/react/components/files/DefaultFile', () => {
+  return props => mockReact.createElement('defaultfile', props, props.children);
+}, {virtual: true});
+
+jest.mock('../../../../react/components/upload/fileUpload', () => ({
+  selectFile: jest.fn(),
+  uploadFileToApi: jest.fn(),
+  toFileIri: jest.fn(),
+  extractFileId: value => value?.id || value,
+}), {virtual: true});
+
+jest.mock('react-native', () => ({
+  ActivityIndicator: props => mockReact.createElement('activityindicator', props, props.children),
+  Platform: {OS: 'web'},
+  ScrollView: props => mockReact.createElement('scrollview', props, props.children),
+  Text: props => mockReact.createElement('text', props, props.children),
+  TextInput: props => mockReact.createElement('textinput', props, props.children),
+  TouchableOpacity: props => mockReact.createElement('touchableopacity', props, props.children),
+  View: props => mockReact.createElement('view', props, props.children),
+}), {virtual: true});
+
+const {selectFile, uploadFileToApi, toFileIri} = require('../../../../react/components/upload/fileUpload');
+const DefaultUpload = require('../../../../react/components/upload/DefaultUpload').default;
+
+const flush = () => new Promise(resolve => setImmediate(resolve));
+
+const collectText = node =>
+  node
+    .findAllByType('text')
+    .map(textNode => {
+      const children = textNode.props.children;
+      if (Array.isArray(children)) {
+        return children.flat(Infinity).join('');
+      }
+      return children || '';
+    })
+    .join('');
+
+const findButtonByLabel = (root, label) =>
+  root.findAllByType('touchableopacity').find(button => collectText(button).includes(label));
+
+const findButtonByAccessibilityLabel = (root, label) =>
+  root.findAllByType('touchableopacity').find(button => button.props.accessibilityLabel === label);
+
+describe('DefaultUpload', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('abre a biblioteca, carrega arquivos e envia um arquivo pelo helper centralizado', async () => {
+    mockFileActions.getItems.mockResolvedValue({
+      member: [
+        {id: 10, fileName: 'Biblioteca 1', context: 'products', fileType: 'image'},
+      ],
+    });
+    mockRelationActions.save.mockResolvedValue({id: 42});
+    selectFile.mockResolvedValue({
+      name: 'nova-imagem.png',
+      uri: 'file:///nova-imagem.png',
+      mimeType: 'image/png',
+    });
+    uploadFileToApi.mockResolvedValue({id: 77, fileName: 'nova-imagem.png'});
+    toFileIri.mockReturnValue('/files/77');
+
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        mockReact.createElement(DefaultUpload, {
+          relationStoreName: 'product_file',
+          relationField: 'product',
+          relationResource: 'products',
+          entityId: 12,
+          companyId: 3,
+          attachments: [{id: 1, file: {id: 1, fileName: 'Anexa'}}],
+          context: 'products',
+          title: 'Imagens anexas',
+          triggerLabel: 'Gerenciar imagens',
+          managerTitle: 'Gerenciador de imagens',
+          searchPlaceholder: 'Buscar imagem',
+          uploadButtonLabel: 'Enviar nova',
+        }),
+      );
+    });
+
+    await renderer.act(async () => {
+      findButtonByLabel(tree.root, 'Gerenciar imagens').props.onPress();
+      await flush();
+    });
+
+    expect(mockFileActions.getItems).toHaveBeenCalled();
+
+    const uploadButton = findButtonByLabel(tree.root, 'Enviar nova');
+    expect(uploadButton).toBeTruthy();
+
+    await renderer.act(async () => {
+      await uploadButton.props.onPress();
+      await flush();
+    });
+
+    expect(selectFile).toHaveBeenCalledWith('image/*');
+    expect(uploadFileToApi).toHaveBeenCalledWith({
+      file: expect.objectContaining({name: 'nova-imagem.png'}),
+      context: 'products',
+      peopleId: 3,
+      entityId: 12,
+    });
+    expect(mockRelationActions.save).toHaveBeenCalledWith({
+      product: '/products/12',
+      file: '/files/77',
+    });
+  });
+
+  it('permite que o pai gerencie upload anexado e remocao por contexto customizado', async () => {
+    const onChanged = jest.fn();
+    const onUploadFile = jest.fn().mockResolvedValue({id: 8, file: {id: 88}});
+    const onRemoveAttachment = jest.fn().mockResolvedValue({});
+
+    mockFileActions.getItems.mockResolvedValue({member: []});
+    selectFile.mockResolvedValue({
+      name: 'avatar.png',
+      type: 'image/png',
+    });
+
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        mockReact.createElement(DefaultUpload, {
+          relationStoreName: 'people',
+          relationField: 'people',
+          relationResource: 'people',
+          entityId: 30,
+          companyId: 30,
+          attachments: [{file: {id: 91, fileName: 'avatar.png'}}],
+          context: 'people_media',
+          libraryContexts: ['people_media'],
+          title: 'avatar',
+          triggerLabel: 'Gerenciar avatar',
+          uploadButtonLabel: 'Enviar nova',
+          onChanged,
+          onUploadFile,
+          onRemoveAttachment,
+          uploadResultAlreadyAttached: true,
+        }),
+      );
+    });
+
+    await renderer.act(async () => {
+      findButtonByLabel(tree.root, 'Gerenciar avatar').props.onPress();
+      await flush();
+    });
+
+    await renderer.act(async () => {
+      await findButtonByLabel(tree.root, 'Enviar nova').props.onPress();
+      await flush();
+    });
+
+    expect(onUploadFile).toHaveBeenCalledWith(
+      expect.objectContaining({
+        context: 'people_media',
+        entityId: 30,
+        file: expect.objectContaining({name: 'avatar.png'}),
+      }),
+    );
+    expect(mockRelationActions.save).not.toHaveBeenCalled();
+    expect(onChanged).toHaveBeenCalled();
+
+    const removeButton = findButtonByAccessibilityLabel(tree.root, 'Remover');
+    expect(removeButton).toBeTruthy();
+
+    await renderer.act(async () => {
+      await removeButton.props.onPress();
+      await flush();
+    });
+
+    expect(onRemoveAttachment).toHaveBeenCalledWith(
+      expect.objectContaining({file: expect.objectContaining({id: 91})}),
+    );
+    expect(mockRelationActions.remove).not.toHaveBeenCalled();
+  });
+
+  it('normaliza o identificador da relacao antes da remocao customizada', async () => {
+    const onRemoveAttachment = jest.fn().mockResolvedValue({});
+
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        mockReact.createElement(DefaultUpload, {
+          relationStoreName: 'people',
+          relationField: 'people',
+          relationResource: 'people',
+          entityId: 30,
+          companyId: 30,
+          attachments: [{mediaId: '/people_media/44', file: {id: 91, fileName: 'avatar.png'}}],
+          context: 'people_media',
+          title: 'avatar',
+          triggerLabel: 'Gerenciar avatar',
+          onRemoveAttachment,
+        }),
+      );
+    });
+
+    await renderer.act(async () => {
+      await findButtonByAccessibilityLabel(tree.root, 'Remover').props.onPress();
+      await flush();
+    });
+
+    expect(onRemoveAttachment).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: '44',
+        mediaId: '/people_media/44',
+        file: expect.objectContaining({id: 91}),
+      }),
+    );
+  });
+
+  it('renderiza apenas o gatilho customizado quando o conteudo inline fica desativado', async () => {
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        mockReact.createElement(DefaultUpload, {
+          relationStoreName: 'people',
+          relationField: 'people',
+          relationResource: 'people',
+          entityId: 30,
+          companyId: 30,
+          attachments: [{file: {id: 91, fileName: 'avatar.png'}}],
+          context: 'people_media',
+          title: 'avatar',
+          showInlineContent: false,
+          renderTrigger: ({openManager}) =>
+            mockReact.createElement(
+              'touchableopacity',
+              {onPress: openManager},
+              mockReact.createElement('text', null, 'Abrir gerenciador customizado'),
+            ),
+        }),
+      );
+    });
+
+    expect(collectText(tree.root)).toContain('Abrir gerenciador customizado');
+    expect(collectText(tree.root)).not.toContain('avatar.png');
+
+    await renderer.act(async () => {
+      findButtonByLabel(tree.root, 'Abrir gerenciador customizado').props.onPress();
+      await flush();
+    });
+
+    expect(mockFileActions.getItems).toHaveBeenCalled();
+  });
+
+  it('nao recarrega a biblioteca quando arrays equivalentes sao recriados', async () => {
+    mockFileActions.getItems.mockResolvedValue({member: []});
+    let tree;
+    const renderProps = () => ({
+      relationStoreName: 'people',
+      relationField: 'people',
+      relationResource: 'people',
+      entityId: 30,
+      companyId: 30,
+      context: 'company_certificate',
+      libraryContexts: ['company_certificate'],
+      knownFileIds: [],
+      showInlineContent: false,
+      renderTrigger: ({openManager}) =>
+        mockReact.createElement('touchableopacity', {onPress: openManager}, 'Abrir'),
+    });
+
+    await renderer.act(async () => {
+      tree = renderer.create(mockReact.createElement(DefaultUpload, renderProps()));
+    });
+
+    await renderer.act(async () => {
+      tree.root.findByType('touchableopacity').props.onPress();
+      await flush();
+    });
+
+    await renderer.act(async () => {
+      tree.update(mockReact.createElement(DefaultUpload, renderProps()));
+      tree.update(mockReact.createElement(DefaultUpload, renderProps()));
+      await flush();
+    });
+
+    expect(mockFileActions.getItems).toHaveBeenCalledTimes(1);
+  });
+});

package/src/tests/react/components/upload/defaultUploadLibrary.test.js

@@ -0,0 +1,82 @@
+/** @jest-environment node */
+
+/** app-community#433 — library lists all people_media files for the person */
+const {
+  fetchLibraryFiles,
+  filesFromPeopleMediaRelations,
+} = require('../../../../react/components/upload/defaultUploadLibrary');
+
+describe('filesFromPeopleMediaRelations', () => {
+  it('extracts embedded file objects with id', () => {
+    const relations = [
+      {id: 1, file: {id: 10, fileName: 'a.png', '@id': '/files/10'}},
+      {id: 2, file: {id: 20, fileName: 'b.png'}},
+      {id: 3, file: null},
+      {id: 4},
+    ];
+    const files = filesFromPeopleMediaRelations(relations);
+    expect(files).toHaveLength(2);
+    expect(files.map(f => f.id)).toEqual([10, 20]);
+  });
+});
+
+describe('fetchLibraryFiles', () => {
+  it('returns empty when getItems is missing', async () => {
+    const result = await fetchLibraryFiles({fileActions: {}});
+    expect(result).toEqual([]);
+  });
+
+  it('sends itemsPerPage and merges people_media relations', async () => {
+    const getItems = jest.fn().mockResolvedValue({
+      member: [{id: 10, fileName: 'from-files.png', context: 'people_media'}],
+    });
+    const getPeopleMedia = jest.fn().mockResolvedValue({
+      member: [
+        {id: 1, file: {id: 10, fileName: 'from-files.png'}},
+        {id: 2, file: {id: 11, fileName: 'only-relation.png'}},
+      ],
+    });
+
+    const files = await fetchLibraryFiles({
+      fileActions: {getItems},
+      companyId: 103446,
+      fileType: 'image',
+      libraryContexts: ['people_media'],
+      peopleActions: {getPeopleMedia},
+    });
+
+    expect(getItems).toHaveBeenCalledWith(
+      expect.objectContaining({
+        context: 'people_media',
+        people: '/people/103446',
+        itemsPerPage: 500,
+        page: 1,
+      }),
+    );
+    expect(getPeopleMedia).toHaveBeenCalledWith(
+      expect.objectContaining({
+        people: '/people/103446',
+        itemsPerPage: 100,
+      }),
+    );
+    const ids = files.map(f => String(f.id)).sort();
+    expect(ids).toEqual(['10', '11']);
+  });
+
+  it('still returns /files results if people_media fetch fails', async () => {
+    const getItems = jest.fn().mockResolvedValue({
+      member: [{id: 5, fileName: 'ok.png'}],
+    });
+    const getPeopleMedia = jest.fn().mockRejectedValue(new Error('network'));
+
+    const files = await fetchLibraryFiles({
+      fileActions: {getItems},
+      companyId: 1,
+      libraryContexts: ['people_media'],
+      peopleActions: {getPeopleMedia},
+    });
+
+    expect(files).toHaveLength(1);
+    expect(files[0].id).toBe(5);
+  });
+});

package/src/tests/react/components/upload/peopleMediaLibraryPreview.test.mjs

@@ -0,0 +1,57 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '../../../../../');
+const require = createRequire(import.meta.url);
+const lib = require(join(root, 'src/react/components/upload/defaultUploadLibrary.js'));
+
+test('people_media path never requires peopleIri to avoid GET /files', async () => {
+  const source = readFileSync(
+    join(root, 'src/react/components/upload/defaultUploadLibrary.js'),
+    'utf8',
+  );
+  assert.match(source, /if \(includesPeopleMedia\)/);
+  assert.doesNotMatch(
+    source,
+    /if \(includesPeopleMedia && peopleIri\)/,
+  );
+  // Without peopleIri still returns stubs only
+  const files = await lib.fetchLibraryFiles({
+    fileActions: {
+      getItems: async () => {
+        throw new Error('should not call getItems');
+      },
+      get: async () => {
+        throw new Error('should not call get');
+      },
+    },
+    companyId: null,
+    fileType: 'image',
+    libraryContexts: ['people_media'],
+    peopleActions: null,
+    knownFileIds: [8469],
+  });
+  assert.equal(files.length, 1);
+  assert.equal(files[0].id, 8469);
+});
+
+test('inline attachments list can hide star/trash', () => {
+  const source = readFileSync(
+    join(root, 'src/react/components/upload/DefaultUploadAttachmentsList.js'),
+    'utf8',
+  );
+  assert.match(source, /showAttachmentActions/);
+});
+
+test('manager shows remove for attached library items', () => {
+  const source = readFileSync(
+    join(root, 'src/react/components/upload/DefaultUploadManagerModal.js'),
+    'utf8',
+  );
+  assert.match(source, /trash-can-outline/);
+  assert.match(source, /handleRemove/);
+});

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

@@ -0,0 +1,40 @@
+/**
+ * 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');
+  });
+});

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`).