@controleonline/ui-common 1.2.79 → 1.2.81

package/src/tests/react/config/deviceConfigBootstrap.test.js

@@ -1,10 +1,10 @@
-const {jest} = require('@jest/globals')
-
-jest.mock('../../../react/utils/screenMetrics', () => ({
-  appendScreenMetrics: configs => configs,
-  hasScreenMetricsChanges: () => false,
-}))
-
+const {jest} = require('@jest/globals')
+
+jest.mock('../../../react/utils/screenMetrics', () => ({
+  appendScreenMetrics: configs => configs,
+  hasScreenMetricsChanges: () => false,
+}))
+
 const {
   buildProviderManagedDeviceConfigs,
   DEVICE_ANDROID_KIOSK_ENABLED_CONFIG_KEY,
@@ -36,22 +36,24 @@ const {
   resolvePosCashManagementMode,
   resolvePosOperationMode,
   resolvePosPrintMode,
+  POS_LOCAL_CHARGE_ENABLED_CONFIG_KEY,
+  isPosLocalChargeEnabled,
   resolvePosCheckOrderType,
   shouldEnableAndroidKioskMode,
   shouldEnableAndroidLauncherMode,
   shouldUsePosCashRegisterLifecycle,
   isPosTotemMode,
 } = require('../../../react/config/deviceConfigBootstrap')
-
-const {describe, expect, it} = global
-
-describe('deviceConfigBootstrap POS operation helpers', () => {
+
+const {describe, expect, it} = global
+
+describe('deviceConfigBootstrap POS operation helpers', () => {
   it('normalizes balcão as counter and treats counter as self service', () => {
     const configs = {
       [POS_OPERATION_MODE_CONFIG_KEY]: 'balcao',
     }
-
-    expect(resolvePosOperationMode(configs)).toBe('counter')
+
+    expect(resolvePosOperationMode(configs)).toBe('counter')
     expect(isPosCounterMode(configs)).toBe(true)
     expect(isPosSelfServiceMode(configs)).toBe(true)
   })
@@ -65,52 +67,52 @@ describe('deviceConfigBootstrap POS operation helpers', () => {
     expect(isPosSingleItemMode(configs)).toBe(true)
     expect(isPosSelfServiceMode(configs)).toBe(false)
   })
-
-  it('keeps counter auto print disabled by default and allows explicit enablement', () => {
-    const counterConfigs = {
-      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
-    }
-
-    expect(isPosAutoPrintEnabled(counterConfigs)).toBe(false)
-
-    expect(
-      isPosAutoPrintEnabled({
-        ...counterConfigs,
-        [POS_AUTO_PRINT_ENABLED_CONFIG_KEY]: '1',
-      }),
-    ).toBe(true)
-  })
-
-  it('defaults non-counter modes to auto print enabled', () => {
-    expect(
-      isPosAutoPrintEnabled({
-        [POS_OPERATION_MODE_CONFIG_KEY]: 'cashier',
-      }),
-    ).toBe(true)
-  })
-
-  it('resolves counter daily close mode and skips cash register lifecycle', () => {
-    const configs = {
-      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
-      [POS_CASH_MANAGEMENT_MODE_CONFIG_KEY]: 'daily',
-    }
-
-    expect(resolvePosCashManagementMode(configs)).toBe('daily')
-    expect(shouldUsePosCashRegisterLifecycle(configs)).toBe(false)
-    expect(isPosCashRegisterOpen(configs)).toBe(true)
-    expect(isPosCashRegisterClosed(configs)).toBe(false)
-  })
-
+
+  it('keeps counter auto print disabled by default and allows explicit enablement', () => {
+    const counterConfigs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+    }
+
+    expect(isPosAutoPrintEnabled(counterConfigs)).toBe(false)
+
+    expect(
+      isPosAutoPrintEnabled({
+        ...counterConfigs,
+        [POS_AUTO_PRINT_ENABLED_CONFIG_KEY]: '1',
+      }),
+    ).toBe(true)
+  })
+
+  it('defaults non-counter modes to auto print enabled', () => {
+    expect(
+      isPosAutoPrintEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'cashier',
+      }),
+    ).toBe(true)
+  })
+
+  it('resolves counter daily close mode and skips cash register lifecycle', () => {
+    const configs = {
+      [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
+      [POS_CASH_MANAGEMENT_MODE_CONFIG_KEY]: 'daily',
+    }
+
+    expect(resolvePosCashManagementMode(configs)).toBe('daily')
+    expect(shouldUsePosCashRegisterLifecycle(configs)).toBe(false)
+    expect(isPosCashRegisterOpen(configs)).toBe(true)
+    expect(isPosCashRegisterClosed(configs)).toBe(false)
+  })
+
   it('requires cash register lifecycle for counter with open/close policy', () => {
     const closedConfigs = {
       [POS_OPERATION_MODE_CONFIG_KEY]: 'counter',
       [POS_CASH_MANAGEMENT_MODE_CONFIG_KEY]: 'cash-register',
       'cash-wallet-closed-id': 1,
     }
-
-    expect(shouldUsePosCashRegisterLifecycle(closedConfigs)).toBe(true)
-    expect(isPosCashRegisterClosed(closedConfigs)).toBe(true)
-
+
+    expect(shouldUsePosCashRegisterLifecycle(closedConfigs)).toBe(true)
+    expect(isPosCashRegisterClosed(closedConfigs)).toBe(true)
+
     expect(
       isPosCashRegisterOpen({
         ...closedConfigs,
@@ -369,16 +371,52 @@ describe('deviceConfigBootstrap POS operation helpers', () => {
   })
 
   it('keeps delivery enabled by default and respects explicit disablement', () => {
-    expect(isPosDeliveryEnabled({})).toBe(true)
-    expect(
-      isPosDeliveryEnabled({
-        [POS_DELIVERY_ENABLED_CONFIG_KEY]: '0',
-      }),
-    ).toBe(false)
-    expect(
-      isPosDeliveryEnabled({
-        [POS_DELIVERY_ENABLED_CONFIG_KEY]: '1',
-      }),
-    ).toBe(true)
-  })
-})
+    expect(isPosDeliveryEnabled({})).toBe(true)
+    expect(
+      isPosDeliveryEnabled({
+        [POS_DELIVERY_ENABLED_CONFIG_KEY]: '0',
+      }),
+    ).toBe(false)
+    expect(
+      isPosDeliveryEnabled({
+        [POS_DELIVERY_ENABLED_CONFIG_KEY]: '1',
+      }),
+    ).toBe(true)
+  })
+})
+
+describe('deviceConfigBootstrap local charge capability', () => {
+  it('defaults waiter to blocked and other modes to allowed when config missing', () => {
+    expect(
+      isPosLocalChargeEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'waiter',
+      }),
+    ).toBe(false)
+    expect(
+      isPosLocalChargeEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'cashier',
+      }),
+    ).toBe(true)
+    expect(
+      isPosLocalChargeEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'single-item',
+      }),
+    ).toBe(true)
+  })
+
+  it('honors explicit pos-local-charge-enabled over mode default', () => {
+    expect(
+      isPosLocalChargeEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'waiter',
+        [POS_LOCAL_CHARGE_ENABLED_CONFIG_KEY]: '1',
+      }),
+    ).toBe(true)
+    expect(
+      isPosLocalChargeEnabled({
+        [POS_OPERATION_MODE_CONFIG_KEY]: 'cashier',
+        [POS_LOCAL_CHARGE_ENABLED_CONFIG_KEY]: '0',
+      }),
+    ).toBe(false)
+  })
+})
+

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

@@ -0,0 +1,78 @@
+/**
+ * Unit coverage for device-detail delete confirmation flow (app-community#383).
+ */
+
+describe('device-detail delete confirmation (task-383)', () => {
+  const buildDeleteFlow = ({ remove, onSuccess, onError }) => {
+    let confirmed = false;
+    const confirm = (msg, cb) => ({
+      confirmNow: () => {
+        confirmed = true;
+        return Promise.resolve().then(() => cb());
+      },
+      cancel: () => {
+        confirmed = false;
+      },
+      wasConfirmed: () => confirmed,
+      message: msg,
+    });
+
+    const deleteDevice = async ({ deviceId, alias, deviceString }) => {
+      if (!deviceId) return { aborted: true };
+      const label = String(alias || deviceString || deviceId).trim();
+      const message = `Excluir o device "${label}"? Esta ação não pode ser desfeita.`;
+      return confirm(message, async () => {
+        try {
+          await remove(deviceId);
+          onSuccess?.();
+        } catch (e) {
+          onError?.(e);
+        }
+      });
+    };
+
+    return { deleteDevice };
+  };
+
+  test('does not call remove when confirmation is cancelled', async () => {
+    const remove = jest.fn();
+    const onSuccess = jest.fn();
+    const { deleteDevice } = buildDeleteFlow({ remove, onSuccess });
+    const gate = await deleteDevice({ deviceId: '42', alias: 'PDV 1' });
+    expect(gate.message).toContain('PDV 1');
+    gate.cancel();
+    expect(remove).not.toHaveBeenCalled();
+    expect(onSuccess).not.toHaveBeenCalled();
+    expect(gate.wasConfirmed()).toBe(false);
+  });
+
+  test('calls remove with deviceId after confirmation', async () => {
+    const remove = jest.fn().mockResolvedValue(undefined);
+    const onSuccess = jest.fn();
+    const { deleteDevice } = buildDeleteFlow({ remove, onSuccess });
+    const gate = await deleteDevice({ deviceId: '99', alias: 'Kiosk' });
+    await gate.confirmNow();
+    expect(remove).toHaveBeenCalledWith('99');
+    expect(onSuccess).toHaveBeenCalled();
+  });
+
+  test('surfaces error without success when remove rejects', async () => {
+    const remove = jest.fn().mockRejectedValue(new Error('fail'));
+    const onSuccess = jest.fn();
+    const onError = jest.fn();
+    const { deleteDevice } = buildDeleteFlow({ remove, onSuccess, onError });
+    const gate = await deleteDevice({ deviceId: '7', deviceString: 'dev-7' });
+    await gate.confirmNow();
+    expect(remove).toHaveBeenCalledWith('7');
+    expect(onSuccess).not.toHaveBeenCalled();
+    expect(onError).toHaveBeenCalled();
+  });
+
+  test('aborts when deviceId is missing', async () => {
+    const remove = jest.fn();
+    const { deleteDevice } = buildDeleteFlow({ remove });
+    const result = await deleteDevice({ deviceId: null, alias: 'x' });
+    expect(result).toEqual({ aborted: true });
+    expect(remove).not.toHaveBeenCalled();
+  });
+});

package/src/tests/react/pages/receitaFederalIntegrationContract.test.mjs

@@ -0,0 +1,48 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import test from 'node:test';
+
+const catalog = fs.readFileSync(new URL('../../../react/pages/integrationsCatalog.js', import.meta.url), 'utf8');
+const page = fs.readFileSync(new URL('../../../react/pages/IntegrationConfigPage.js', import.meta.url), 'utf8');
+const fields = fs.readFileSync(new URL('../../../react/pages/IntegrationConfigFields.js', import.meta.url), 'utf8');
+const utils = fs.readFileSync(new URL('../../../react/pages/IntegrationConfigPage.utils.js', import.meta.url), 'utf8');
+
+test('Receita Federal catalog exposes company fiscal configuration', () => {
+  assert.match(catalog, /key: 'receita-federal'/);
+  assert.match(catalog, /label: 'Receita Federal'/);
+  assert.match(catalog, /receita-federal-tax-regime/);
+  assert.match(catalog, /receita-federal-ibge-code/);
+  assert.match(catalog, /receita-federal-certificate-file/);
+  assert.match(catalog, /receita-federal-certificate-password/);
+  assert.match(catalog, /secureTextEntry: true/);
+  assert.match(catalog, /\.pfx,\.p12,application\/x-pkcs12/);
+});
+
+test('Receita Federal route resolves without relying only on route params', () => {
+  assert.match(utils, /ReceitaFederalIntegrationPage: 'receita-federal'/);
+  assert.match(page, /ROUTE_PROVIDER_MAP\[route\?\.name\]/);
+});
+
+test('embedded fiscal configuration keeps reads and writes on the company being edited', () => {
+  assert.match(utils, /route\?\.params\?\.companyId/);
+  assert.match(utils, /resolveProviderId/);
+  assert.match(utils, /resolveFallbackConfigs/);
+  assert.match(page, /resolveProviderId\(\{ route, currentCompany \}\)/);
+  assert.match(page, /api\.fetch\('\/configs', \{ params: \{ people: providerIri \} \}\)/);
+  assert.match(page, /addManyConfigs\(\{ configs, people: providerIri/);
+  assert.match(page, /syncConfigValues\(fallbackConfigs\)/);
+});
+
+test('certificate picker remains scoped to the active company', () => {
+  assert.match(fields, /companyId=\{providerId\}/);
+  assert.match(fields, /entityId=\{providerId\}/);
+  assert.match(fields, /peopleId: companyId \|\| providerId/);
+  assert.match(fields, /company_certificate/);
+});
+
+test('IntegrationConfigPage delegates field rendering to a focused component', () => {
+  assert.match(page, /<IntegrationConfigFields/);
+  assert.ok(page.split('\n').length <= 500, `IntegrationConfigPage.js has ${page.split('\n').length} lines`);
+  assert.ok(fields.split('\n').length <= 500, `IntegrationConfigFields.js has ${fields.split('\n').length} lines`);
+  assert.ok(utils.split('\n').length <= 500, `IntegrationConfigPage.utils.js has ${utils.split('\n').length} lines`);
+});

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

@@ -0,0 +1,222 @@
+const assert = require('node:assert/strict')
+const {test} = require('node:test')
+
+const {
+  SAFE_TOOLBAR_FALLBACK_ROUTES,
+  buildSafeToolbarFallbackMenus,
+  mapRuntimeMenusToNavItems,
+  resolveToolbarRuntimeMenus,
+} = require('../../../react/utils/bottomNavigationToolbar')
+
+const managerPreset = {
+  items: [
+    {
+      route: 'HomePage',
+      icon: 'home',
+      label: {store: 'configs', type: 'toolbar', key: 'home', fallback: 'Início'},
+    },
+    {
+      route: 'CrmIndex',
+      icon: 'dollar-sign',
+      label: {
+        store: 'configs',
+        type: 'toolbar',
+        key: 'opportunities',
+        fallback: 'Oportunidades',
+      },
+    },
+    {
+      route: 'ClientsIndex',
+      icon: 'users',
+      label: {
+        store: 'configs',
+        type: 'toolbar',
+        key: 'customers',
+        fallback: 'Clientes',
+      },
+    },
+    {
+      route: 'ProfilePage',
+      icon: 'user',
+      label: {
+        store: 'configs',
+        type: 'toolbar',
+        key: 'profile',
+        fallback: 'Perfil',
+      },
+    },
+  ],
+  routeAliases: {
+    ClientDetails: 'ClientsIndex',
+    ProfilePage: 'ProfilePage',
+    SettingsPage: 'ProfilePage',
+  },
+}
+
+test('exposes only HomePage and ProfilePage as safe fallback routes', () => {
+  assert.deepEqual(SAFE_TOOLBAR_FALLBACK_ROUTES, ['HomePage', 'ProfilePage'])
+})
+
+test('builds safe fallback from managerToolbar without business routes', () => {
+  const menus = buildSafeToolbarFallbackMenus(
+    managerPreset,
+    'toolbar',
+    null,
+    'managerToolbar',
+  )
+
+  assert.equal(menus.length, 1)
+  const routes = menus[0].menus.map(item => item.route)
+  assert.deepEqual(routes, ['HomePage', 'ProfilePage'])
+  assert.equal(routes.includes('ClientsIndex'), false)
+  assert.equal(routes.includes('CrmIndex'), false)
+  assert.deepEqual(
+    menus[0].menus.map(item => item.label),
+    ['Início', 'Perfil'],
+  )
+})
+
+test('returns empty safe fallback when preset has no safe routes', () => {
+  const menus = buildSafeToolbarFallbackMenus(
+    {items: [{route: 'ClientsIndex', icon: 'users', label: 'Clientes'}]},
+    'toolbar',
+  )
+  assert.deepEqual(menus, [])
+})
+
+test('prefers API toolbar menus over preset when authorized items exist', () => {
+  const apiMenus = [
+    {
+      id: 'toolbar-mod',
+      label: 'Toolbar',
+      menus: [
+        {
+          id: 1,
+          route: 'HomePage',
+          icon: 'home',
+          label: 'Início',
+          menuType: 'toolbar',
+          sortOrder: 10,
+        },
+        {
+          id: 2,
+          route: 'ClientsIndex',
+          icon: 'users',
+          label: 'Clientes',
+          menuType: 'toolbar',
+          sortOrder: 20,
+        },
+      ],
+    },
+  ]
+
+  const resolved = resolveToolbarRuntimeMenus({
+    apiMenus,
+    preset: managerPreset,
+    presetKey: 'managerToolbar',
+    menuType: 'toolbar',
+  })
+
+  const routes = resolved.flatMap(m => m.menus.map(i => i.route))
+  assert.deepEqual(routes, ['HomePage', 'ClientsIndex'])
+  assert.equal(routes.includes('ProfilePage'), false)
+})
+
+test('falls back to safe routes when API menus are empty', () => {
+  const resolved = resolveToolbarRuntimeMenus({
+    apiMenus: [],
+    preset: managerPreset,
+    presetKey: 'managerToolbar',
+    menuType: 'toolbar',
+  })
+
+  const routes = resolved.flatMap(m => m.menus.map(i => i.route))
+  assert.deepEqual(routes, ['HomePage', 'ProfilePage'])
+  assert.equal(routes.includes('ClientsIndex'), false)
+  assert.equal(routes.includes('CrmIndex'), false)
+})
+
+test('falls back to safe routes when API only has non-toolbar menus', () => {
+  const apiMenus = [
+    {
+      id: 'home-mod',
+      menus: [
+        {
+          route: 'ProductsPage',
+          label: 'Produtos',
+          menuType: 'home',
+          sortOrder: 1,
+        },
+      ],
+    },
+  ]
+
+  const resolved = resolveToolbarRuntimeMenus({
+    apiMenus,
+    preset: managerPreset,
+    menuType: 'toolbar',
+  })
+
+  const routes = resolved.flatMap(m => m.menus.map(i => i.route))
+  assert.deepEqual(routes, ['HomePage', 'ProfilePage'])
+})
+
+test('returns empty when API empty and no preset (no bypass)', () => {
+  const resolved = resolveToolbarRuntimeMenus({
+    apiMenus: [],
+    preset: null,
+    menuType: 'toolbar',
+  })
+  assert.deepEqual(resolved, [])
+})
+
+test('maps runtime menus to nav items sorted by sortOrder', () => {
+  const runtimeMenus = [
+    {
+      id: 'm1',
+      menus: [
+        {
+          route: 'ClientsIndex',
+          icon: 'users',
+          label: 'Clientes',
+          menuKey: 'clients',
+          menuType: 'toolbar',
+          sortOrder: 30,
+        },
+        {
+          route: 'HomePage',
+          icon: 'home',
+          label: 'Início',
+          menuKey: 'home',
+          menuType: 'toolbar',
+          sortOrder: 10,
+        },
+      ],
+    },
+  ]
+
+  const items = mapRuntimeMenusToNavItems(runtimeMenus, 'toolbar')
+  assert.deepEqual(
+    items.map(i => i.route),
+    ['HomePage', 'ClientsIndex'],
+  )
+  assert.equal(items[0].menuKey, 'home')
+})
+
+test('ignores items without route when mapping', () => {
+  const items = mapRuntimeMenusToNavItems(
+    [
+      {
+        menus: [
+          {route: '', label: 'Empty', menuType: 'toolbar'},
+          {route: 'HomePage', label: 'Início', menuType: 'toolbar', sortOrder: 1},
+        ],
+      },
+    ],
+    'toolbar',
+  )
+  assert.deepEqual(
+    items.map(i => i.route),
+    ['HomePage'],
+  )
+})

package/src/tests/react/utils/copyDeviceConfigs.test.mjs

@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  buildCopyPayloads,
+  buildSourceDeviceOptions,
+  executeCopyDeviceConfigs,
+  listCopyableConfigKeys,
+} from '../../../react/utils/copyDeviceConfigs.js';
+
+const companyId = '42';
+const peopleIri = '/people/42';
+
+const sourceRows = [
+  {
+    id: 1,
+    type: 'PDV',
+    people: {id: 42},
+    device: {id: 10, device: 'src-hash-1', alias: 'Caixa 1'},
+    configs: {
+      'pos-operation-mode': 'cashier',
+      'pos-gateway': 'cielo',
+      'printer-enabled': '1',
+    },
+  },
+  {
+    id: 2,
+    type: 'PRINT',
+    people: {id: 42},
+    device: {id: 10, device: 'src-hash-1', alias: 'Caixa 1'},
+    configs: {'print-network-port': '9100'},
+  },
+  {
+    id: 3,
+    type: 'PDV',
+    people: {id: 99},
+    device: {id: 20, device: 'other-co', alias: 'Outra empresa'},
+    configs: {'pos-gateway': 'infinite-pay'},
+  },
+  {
+    id: 4,
+    type: 'PDV',
+    people: {id: 42},
+    device: {id: 30, device: 'dest-hash', alias: 'Destino'},
+    configs: {'pos-operation-mode': 'waiter'},
+  },
+];
+
+test('listCopyableConfigKeys sorts keys from object or JSON string', () => {
+  assert.deepEqual(listCopyableConfigKeys({'b-key': '1', 'a-key': '2'}), [
+    'a-key',
+    'b-key',
+  ]);
+  assert.deepEqual(
+    listCopyableConfigKeys(JSON.stringify({'pos-gateway': 'cielo'})),
+    ['pos-gateway'],
+  );
+});
+
+test('buildSourceDeviceOptions excludes destination and other tenants', () => {
+  const options = buildSourceDeviceOptions({
+    companyDeviceConfigs: sourceRows,
+    companyId,
+    destinationDeviceString: 'dest-hash',
+  });
+  assert.equal(options.length, 1);
+  assert.equal(options[0].deviceString, 'src-hash-1');
+  assert.equal(options[0].configs.length, 2);
+});
+
+test('buildCopyPayloads keeps destination identity and source config keys', () => {
+  const payloads = buildCopyPayloads({
+    sourceConfigs: sourceRows.filter(r => r.device.device === 'src-hash-1'),
+    destinationDeviceString: 'dest-hash',
+    peopleIri,
+  });
+  assert.equal(payloads.length, 2);
+  const pdv = payloads.find(p => p.type === 'PDV');
+  const print = payloads.find(p => p.type === 'PRINT');
+  assert.equal(pdv.device, 'dest-hash');
+  assert.equal(pdv.people, peopleIri);
+  assert.equal(JSON.parse(pdv.configs)['pos-gateway'], 'cielo');
+  assert.deepEqual(pdv.keys, [
+    'pos-gateway',
+    'pos-operation-mode',
+    'printer-enabled',
+  ]);
+  assert.deepEqual(print.keys, ['print-network-port']);
+});
+
+test('executeCopyDeviceConfigs posts one payload per type', async () => {
+  const calls = [];
+  const addDeviceConfigs = async params => {
+    calls.push(params);
+    return {ok: true, type: params.type};
+  };
+  const summary = await executeCopyDeviceConfigs({
+    addDeviceConfigs,
+    sourceConfigs: sourceRows.filter(r => r.device.device === 'src-hash-1'),
+    destinationDeviceString: 'dest-hash',
+    peopleIri,
+  });
+  assert.equal(calls.length, 2);
+  assert.ok(calls.every(c => c.device === 'dest-hash'));
+  assert.ok(calls.every(c => c.people === peopleIri));
+  assert.deepEqual(summary.types.sort(), ['PDV', 'PRINT']);
+  assert.ok(summary.keys.includes('pos-gateway'));
+  assert.ok(summary.keys.includes('print-network-port'));
+});
+
+test('buildCopyPayloads returns empty without dest or people', () => {
+  assert.deepEqual(
+    buildCopyPayloads({
+      sourceConfigs: sourceRows,
+      destinationDeviceString: '',
+      peopleIri,
+    }),
+    [],
+  );
+  assert.deepEqual(
+    buildCopyPayloads({
+      sourceConfigs: sourceRows,
+      destinationDeviceString: 'dest-hash',
+      peopleIri: '',
+    }),
+    [],
+  );
+});