@controleonline/ui-common 1.2.87 → 1.2.88

package/src/tests/browser/manager/runtime-footer-rotation.spec.js

@@ -0,0 +1,397 @@
+/**
+ * fluxo: outros
+ * Justificativa: jornada visual do RuntimeInfoFooter (rotação 1 linha ↔
+ * device/versão em 4s), fora dos fluxos de negócio do catálogo canônico.
+ * Issue: app-community#384
+ *
+ * Passos / prints:
+ * 1. 1 linha configurada — frame da linha isolada
+ * 2. após ~4s — frame do primaryText (device + versão)
+ * 3. 0 linhas — somente primaryText
+ * 4. 2+ linhas — primeira linha, depois próxima entrada
+ */
+const {expect, test} = require('playwright/test');
+const packageJson = require('../../../../../../../package.json');
+const {API_ORIGIN} = require('../../../../../../../src/tests/browser/apiOrigin');
+const {writeManifest} = require('../../../../../../../modules/controleonline/ui-tests/src/tests/helpers/smokeEvidence');
+const API_ORIGINS = [API_ORIGIN, 'https://api.controleonline.com'].filter(
+  (origin, index, origins) => origins.indexOf(origin) === index,
+);
+
+const APP_VERSION = packageJson?.version || '1.0.0';
+const LINE_ONE = 'Linha isolada do rodapé';
+const LINE_TWO = 'Segunda linha do rodapé';
+const PRIMARY_HINT = /Browser Manager|web-manager|web\s*•\s*ADMIN|1\./i;
+
+const CORS_HEADERS = {
+  'access-control-allow-origin': '*',
+  'access-control-allow-headers':
+    'API-TOKEN, APP-DOMAIN, DEVICE, ACCEPT, CONTENT-TYPE, X-Requested-With',
+  'access-control-allow-methods': 'GET,POST,PUT,PATCH,DELETE,OPTIONS',
+};
+
+const jsonHeaders = () => ({
+  ...CORS_HEADERS,
+  'content-type': 'application/ld+json; charset=utf-8',
+});
+
+const textHeaders = () => ({
+  ...CORS_HEADERS,
+  'content-type': 'text/css; charset=utf-8',
+});
+
+const collection = member => ({
+  member,
+  'hydra:member': member,
+  totalItems: member.length,
+  'hydra:totalItems': member.length,
+  summary: {},
+});
+
+const createCompany = footerText => ({
+  id: 3,
+  name: 'Controle Online',
+  alias: 'CONTROLE ONLINE',
+  panel_enabled: true,
+  enabled: true,
+  commercial_enabled: true,
+  theme: {
+    colors: {
+      primary: '#0EA5E9',
+      footerBackground: '#0F172A',
+      footerBorder: '#1E293B',
+      footerText: '#E2E8F0',
+      footerLink: '#38BDF8',
+      success: '#22C55E',
+      warning: '#F59E0B',
+      error: '#EF4444',
+    },
+  },
+  configs: footerText
+    ? {'device-runtime-footer-text': footerText}
+    : {},
+});
+
+const mockApi = async (page, footerText) => {
+  const company = createCompany(footerText);
+
+  for (const apiOrigin of API_ORIGINS) {
+    await page.route(`${apiOrigin}/**`, async route => {
+    const request = route.request();
+    const url = new URL(request.url());
+    const pathname = url.pathname.replace(/^\/+/, '');
+    const method = request.method().toUpperCase();
+
+    if (method === 'OPTIONS') {
+      return route.fulfill({status: 204, headers: CORS_HEADERS, body: ''});
+    }
+
+    if (pathname === 'themes-colors.css') {
+      return route.fulfill({
+        status: 200,
+        headers: textHeaders(),
+        body: ':root { --primary: #0ea5e9; --footer-text: #e2e8f0; }',
+      });
+    }
+
+    if (pathname === 'runtime/ip') {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify({ip: '127.0.0.1'}),
+      });
+    }
+
+    if (pathname === 'menus-people') {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify({modules: {}}),
+      });
+    }
+
+    if (
+      pathname === 'people/company/default' ||
+      pathname === 'people/companies/my'
+    ) {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify(
+          pathname === 'people/company/default' ? company : collection([company]),
+        ),
+      });
+    }
+
+    if (
+      pathname === 'people' ||
+      pathname === 'devices' ||
+      pathname === 'device_configs'
+    ) {
+      return route.fulfill({
+        status: 200,
+        headers: jsonHeaders(),
+        body: JSON.stringify(collection([])),
+      });
+    }
+
+    return route.fulfill({
+      status: 200,
+      headers: jsonHeaders(),
+      body: JSON.stringify(collection([])),
+    });
+    });
+  }
+
+  await page.addInitScript(
+    ({appVersion}) => {
+      window.localStorage.setItem(
+        'session',
+        JSON.stringify({
+          id: 7,
+          people: '/people/7',
+          api_key: 'test-api-key',
+          active: 1,
+          mycompany: 3,
+          roles: ['ROLE_SUPER'],
+          phone: '(11) 97114-0832',
+          email: 'qa@controleonline.com',
+        }),
+      );
+      window.localStorage.setItem('config', JSON.stringify({language: 'pt-br'}));
+      window.localStorage.setItem('app-type', 'MANAGER');
+      window.localStorage.setItem(
+        'device',
+        JSON.stringify({
+          id: 'web-manager',
+          device: 'web-manager',
+          type: 'WEB',
+          appName: 'Browser Manager',
+          appVersion,
+          buildNumber: appVersion,
+          systemName: 'web',
+          systemVersion: 'web',
+          deviceType: 'web',
+          metadata: {},
+        }),
+      );
+    },
+    {appVersion: APP_VERSION},
+  );
+};
+
+async function openFooter(page, footerText) {
+  await mockApi(page, footerText);
+  await page.goto('/devices-index?store=device_config');
+  const footer = page.getByTestId('runtime-info-footer');
+  await expect(footer).toBeVisible({timeout: 15000});
+  const label = page.getByTestId('runtime-footer-primary-text');
+  await expect(label.first()).toBeVisible({timeout: 15000});
+  return {footer, label: label.first()};
+}
+
+async function openAuthenticatedFooter(page, testInfo) {
+  const sessionJson = String(process.env.PLAYWRIGHT_SESSION_JSON || '').trim();
+  if (!sessionJson) {
+    test.skip(true, 'PLAYWRIGHT_SESSION_JSON is required for the live staging journey.');
+  }
+
+  const consoleErrors = [];
+  const requestFailures = [];
+  page.on('console', message => {
+    if (message.type() === 'error') {
+      consoleErrors.push(message.text());
+    }
+  });
+  page.on('requestfailed', request => {
+    requestFailures.push(`${request.method()} ${request.url()}: ${request.failure()?.errorText || 'failed'}`);
+  });
+
+  await page.addInitScript(({session}) => {
+    localStorage.setItem('session', session);
+    localStorage.setItem('config', JSON.stringify({language: 'pt-br'}));
+    // Staging publishes the authenticated web bundle as ADMIN.
+    localStorage.setItem('app-type', 'ADMIN');
+  }, {session: sessionJson});
+
+  await page.goto('/devices-index?store=device_config');
+  const footer = page.getByTestId('runtime-info-footer');
+  const label = page.getByTestId('runtime-footer-primary-text').first();
+  await expect(footer).toBeVisible({timeout: 30000});
+  await expect(label).toBeVisible({timeout: 30000});
+
+  return {footer, label, consoleErrors, requestFailures, evidenceDir: testInfo.outputDir};
+}
+
+test.describe('runtime footer rotation (#384) — fluxo: outros', () => {
+  test('1 line: isolated line then device/version without concat', async (
+    {page},
+    testInfo,
+  ) => {
+    const {footer, label} = await openFooter(page, LINE_ONE);
+    await page.waitForTimeout(800);
+
+    const firstText = (await label.innerText()).trim();
+    expect(firstText).toContain(LINE_ONE);
+    expect(firstText).not.toMatch(/ • /);
+
+    await footer.screenshot({
+      path: testInfo.outputPath('01-one-line-isolated.png'),
+    });
+    await page.screenshot({
+      path: testInfo.outputPath('01-one-line-isolated-full.png'),
+      fullPage: true,
+    });
+
+    await expect
+      .poll(async () => (await label.innerText()).trim(), {
+        timeout: 7000,
+        intervals: [400, 800, 1200],
+      })
+      .not.toBe(firstText);
+
+    const secondText = (await label.innerText()).trim();
+    expect(secondText).not.toContain(LINE_ONE);
+    expect(secondText).not.toContain(`${LINE_ONE}  • `);
+    expect(secondText).toMatch(PRIMARY_HINT);
+
+    await footer.screenshot({
+      path: testInfo.outputPath('02-device-version.png'),
+    });
+    await page.screenshot({
+      path: testInfo.outputPath('02-device-version-full.png'),
+      fullPage: true,
+    });
+  });
+
+  test('0 lines: only primaryText', async ({page}, testInfo) => {
+    const {footer, label} = await openFooter(page, '');
+    await page.waitForTimeout(800);
+
+    const text = (await label.innerText()).trim();
+    expect(text.length).toBeGreaterThan(0);
+    expect(text).not.toContain(LINE_ONE);
+    expect(text).toMatch(PRIMARY_HINT);
+
+    await footer.screenshot({
+      path: testInfo.outputPath('03-zero-lines-primary.png'),
+    });
+    await page.screenshot({
+      path: testInfo.outputPath('03-zero-lines-primary-full.png'),
+      fullPage: true,
+    });
+  });
+
+  test('2+ lines: rotates between configured lines and primary', async (
+    {page},
+    testInfo,
+  ) => {
+    const {footer, label} = await openFooter(
+      page,
+      `${LINE_ONE}\n${LINE_TWO}`,
+    );
+    await page.waitForTimeout(800);
+
+    const firstText = (await label.innerText()).trim();
+    expect([LINE_ONE, LINE_TWO].some(line => firstText.includes(line))).toBe(
+      true,
+    );
+    expect(firstText).not.toMatch(/ • /);
+
+    await footer.screenshot({
+      path: testInfo.outputPath('04-two-lines-first.png'),
+    });
+
+    await expect
+      .poll(async () => (await label.innerText()).trim(), {
+        timeout: 7000,
+        intervals: [400, 800, 1200],
+      })
+      .not.toBe(firstText);
+
+    const secondText = (await label.innerText()).trim();
+    expect(secondText).not.toContain(`${LINE_ONE}  • `);
+    expect(secondText).not.toContain(`${LINE_TWO}  • `);
+    expect(secondText.length).toBeGreaterThan(0);
+
+    await footer.screenshot({
+      path: testInfo.outputPath('05-two-lines-next.png'),
+    });
+    await page.screenshot({
+      path: testInfo.outputPath('05-two-lines-next-full.png'),
+      fullPage: true,
+    });
+  });
+
+  test('authenticated staging journey: captures the real runtime footer cycle', async ({
+    page,
+  }, testInfo) => {
+    testInfo.annotations.push({
+      type: 'fluxo',
+      description: 'outros',
+    });
+
+    const {footer, label, consoleErrors, requestFailures, evidenceDir} =
+      await openAuthenticatedFooter(page, testInfo);
+    const observedTexts = [];
+
+    const captureAuthenticatedStep = async stepName => {
+      const text = (await label.innerText()).trim();
+      expect(text).not.toBe('');
+      expect(text).not.toMatch(/ • /);
+      observedTexts.push(text);
+      await footer.screenshot({path: testInfo.outputPath(`${stepName}.png`)});
+      await page.screenshot({
+        path: testInfo.outputPath(`${stepName}-full.png`),
+        fullPage: true,
+      });
+    };
+
+    await page.waitForTimeout(800);
+    await captureAuthenticatedStep('01-authenticated-footer-initial');
+    await expect
+      .poll(async () => (await label.innerText()).trim(), {
+        timeout: 7000,
+        intervals: [400, 800, 1200],
+      })
+      .not.toBe(observedTexts[0]);
+    await captureAuthenticatedStep('02-authenticated-footer-after-rotation');
+
+    for (const stepName of [
+      '03-authenticated-footer-next',
+      '04-authenticated-footer-next',
+      '05-authenticated-footer-next',
+    ]) {
+      await page.waitForTimeout(4200);
+      await captureAuthenticatedStep(stepName);
+    }
+
+    expect(new Set(observedTexts).size).toBeGreaterThan(1);
+    expect(consoleErrors).toEqual([]);
+    expect(requestFailures).toEqual([]);
+    writeManifest(evidenceDir, {
+      flowchartIds: [],
+      fluxo: 'outros',
+      steps: [
+        '01-authenticated-footer-initial',
+        '02-authenticated-footer-after-rotation',
+        '03-authenticated-footer-next',
+        '04-authenticated-footer-next',
+        '05-authenticated-footer-next',
+      ],
+      prints: [
+        '01-authenticated-footer-initial',
+        '02-authenticated-footer-after-rotation',
+        '03-authenticated-footer-next',
+        '04-authenticated-footer-next',
+        '05-authenticated-footer-next',
+      ],
+      missingPrints: [],
+      authenticated: true,
+      rotationIntervalMs: 4000,
+      observedTexts,
+      consoleErrors,
+      requestFailures,
+    });
+  });
+});

package/src/tests/react/components/DefaultProviderAuthority.test.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import {describe, expect, it} from '@jest/globals';
+
+const providerFiles = [
+  'DefaultProvider.web.js',
+  'DefaultProvider.native.js',
+];
+
+describe('DefaultProvider company authority guard', () => {
+  it.each(providerFiles)(
+    'uses the shared authority helper in %s',
+    providerFile => {
+      const source = fs.readFileSync(
+        path.resolve(__dirname, '../../../react/components', providerFile),
+        'utf8',
+      );
+
+      expect(source).not.toContain('isTenantAdministrativeAuthority');
+      expect(source).toMatch(
+        /import\s*\{\s*canAdministerCompany\s*\}\s*from\s*['"]@controleonline\/ui-common\/src\/react\/utils\/companyAuthority['"]/,
+      );
+      expect(source).toMatch(
+        /canAdministerCompany\(\{\s*company:\s*currentCompany,\s*mainCompany,\s*user\s*\}\)/,
+      );
+    },
+  );
+});

package/src/tests/react/components/RuntimeFooterMarqueeText.build.test.js

@@ -0,0 +1,29 @@
+const assert = require('node:assert/strict');
+const {test} = require('node:test');
+const fs = require('node:fs');
+const path = require('node:path');
+const babel = require('@babel/core');
+
+// Run with the host app's Expo dependencies, just like the production build.
+const filename = path.resolve(__dirname, '../../../react/components/RuntimeFooterMarqueeText.js');
+const source = fs.readFileSync(filename, 'utf8');
+
+for (const platform of ['web', 'android', 'ios']) {
+  test(`runtime footer compiles with the production Expo preset (${platform})`, () => {
+    const result = babel.transformSync(source, {
+      filename,
+      babelrc: false,
+      configFile: false,
+      presets: [require.resolve('babel-preset-expo')],
+      envName: 'production',
+      caller: {
+        name: 'metro', bundler: 'metro', platform,
+        isDev: false, isServer: false, supportsStaticESM: true,
+      },
+    });
+    assert.ok(result.code.length > 0);
+    if (platform === 'web') {
+      assert.match(result.code, /react-native-web/);
+    }
+  });
+}

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

@@ -6,6 +6,7 @@ jest.mock('../../../react/utils/screenMetrics', () => ({
 }))
 
 const {
+  buildDefaultDeviceConfigs,
   buildProviderManagedDeviceConfigs,
   DEVICE_ANDROID_KIOSK_ENABLED_CONFIG_KEY,
   DEVICE_ANDROID_LAUNCHER_ENABLED_CONFIG_KEY,
@@ -18,6 +19,7 @@ const {
   POS_CASH_MANAGEMENT_MODE_CONFIG_KEY,
   POS_DELIVERY_ENABLED_CONFIG_KEY,
   POS_OPERATION_MODE_CONFIG_KEY,
+  POS_OPERATION_MODE_DEFAULT,
   POS_CHECK_ORDER_TYPE_CONFIG_KEY,
   POS_CHECK_ORDER_TYPE_STAMP,
   isPosSingleItemMode,
@@ -48,6 +50,28 @@ const {
 const {describe, expect, it} = global
 
 describe('deviceConfigBootstrap POS operation helpers', () => {
+  it('builds new device configs with the counter operation mode by default', () => {
+    const {nextConfigs, needsUpdate} = buildDefaultDeviceConfigs({
+      configs: {},
+      appVersion: '1.3.74',
+      deviceInfo: {manufacturer: 'Google', isEmulator: true},
+    })
+
+    expect(POS_OPERATION_MODE_DEFAULT).toBe('counter')
+    expect(nextConfigs[POS_OPERATION_MODE_CONFIG_KEY]).toBe('counter')
+    expect(needsUpdate).toBe(true)
+  })
+
+  it('preserves an explicitly configured operation mode', () => {
+    const {nextConfigs} = buildDefaultDeviceConfigs({
+      configs: {[POS_OPERATION_MODE_CONFIG_KEY]: 'waiter'},
+      appVersion: '1.3.74',
+      deviceInfo: {manufacturer: 'Google', isEmulator: true},
+    })
+
+    expect(nextConfigs[POS_OPERATION_MODE_CONFIG_KEY]).toBe('waiter')
+  })
+
   it('normalizes balcão as counter and treats counter as self service', () => {
     const configs = {
       [POS_OPERATION_MODE_CONFIG_KEY]: 'balcao',
@@ -419,4 +443,3 @@ describe('deviceConfigBootstrap local charge capability', () => {
     ).toBe(false)
   })
 })
-

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

@@ -0,0 +1,85 @@
+/**
+ * Unit coverage for DeviceDetail applyCurrentDeviceConfig (app-community#706).
+ */
+const { describe, test } = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const loaderPath = path.resolve(
+  __dirname,
+  '../../../react/pages/Devices/detail/useDeviceDetailLoaders.js',
+);
+
+const normalizeEntityId = value => {
+  if (value == null || value === '') return '';
+  const raw = String(value);
+  const parts = raw.split('/');
+  return parts[parts.length - 1];
+};
+
+const findCurrentDeviceConfig = (scopedItems, context = {}) => {
+  const currentDeviceString = String(context.deviceString || '').trim();
+  const currentDeviceType = String(context.deviceType || '')
+    .trim()
+    .toUpperCase();
+  const currentDeviceConfigId = normalizeEntityId(context.deviceId);
+  return (scopedItems || []).find(d => {
+    const currentConfigType = String(d?.type || d?.device?.type || '')
+      .trim()
+      .toUpperCase();
+    const nextDeviceId = normalizeEntityId(
+      d?.device?.id ||
+        d?.device?.['@id'] ||
+        d?.deviceId ||
+        d?.device?.deviceId,
+    );
+    if (currentDeviceConfigId && nextDeviceId === currentDeviceConfigId) {
+      return true;
+    }
+    return (
+      d?.device?.device === currentDeviceString &&
+      currentConfigType === currentDeviceType
+    );
+  });
+};
+
+describe('applyCurrentDeviceConfig contract (task-706)', () => {
+  test('production loader parses without duplicate bindings', () => {
+    const result = spawnSync(process.execPath, ['--check', loaderPath], {
+      encoding: 'utf8',
+    });
+
+    assert.equal(result.status, 0, result.stderr || result.stdout);
+  });
+
+  test('selects config by device id even when type/string differ', () => {
+    const items = [
+      { type: 'DISPLAY', device: { id: '1', device: 'aaa' } },
+      { type: 'PDV', device: { id: '/devices/403', device: 'other' } },
+    ];
+    const found = findCurrentDeviceConfig(items, {
+      deviceId: '403',
+      deviceString: 'pdv-x',
+      deviceType: 'PDV',
+    });
+    assert.equal(found?.device?.id, '/devices/403');
+  });
+
+  test('falls back to device string + type when id is missing', () => {
+    const items = [
+      { type: 'PDV', device: { device: 'device:403' } },
+      { type: 'DISPLAY', device: { device: 'device:403' } },
+    ];
+    const found = findCurrentDeviceConfig(items, {
+      deviceString: 'device:403',
+      deviceType: 'PDV',
+    });
+    assert.equal(found?.type, 'PDV');
+  });
+
+  test('returns undefined when no match so loader resets local state', () => {
+    const found = findCurrentDeviceConfig([], { deviceId: '403' });
+    assert.equal(found, undefined);
+  });
+});

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

@@ -0,0 +1,65 @@
+const fs = require('fs');
+const path = require('path');
+const {Linter} = require('eslint');
+const parser = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+const createContext = require('../../../react/pages/Devices/detail/createDeviceDetailContext').default;
+
+const directory = path.resolve(__dirname, '../../../react/pages/Devices/detail');
+const files = fs.readdirSync(directory).filter(file => file.endsWith('.js'));
+
+describe('DeviceDetail composition regression (app-community#706)', () => {
+  test.each(files)('%s parses and has no unbound runtime or JSX references', file => {
+    const source = fs.readFileSync(path.join(directory, file), 'utf8');
+    const messages = new Linter().verify(source, {
+      parserOptions: {ecmaVersion: 2022, sourceType: 'module', ecmaFeatures: {jsx: true}},
+      env: {browser: true, node: true, es2022: true},
+      rules: {'no-undef': 'error'},
+    });
+    expect(messages.map(message => `${message.line}: ${message.message}`)).toEqual([]);
+    const unbound = [];
+    traverse(parser.parse(source, {sourceType: 'module', plugins: ['jsx']}), {
+      JSXOpeningElement(element) {
+        const name = element.node.name;
+        if (name.type === 'JSXIdentifier' && /^[A-Z]/.test(name.name) &&
+            !element.scope.hasBinding(name.name)) unbound.push(name.name);
+      },
+    });
+    expect(unbound).toEqual([]);
+  });
+
+  test('section context retains actual values and callbacks instead of losing hook outputs', () => {
+    const setVisibility = jest.fn();
+    const setDelivery = jest.fn();
+    const saveDelivery = jest.fn();
+    const renderSwitchRow = jest.fn();
+    const state = {
+      currentCompany: {id: 7}, themeColors: {buttonText: '#fff'},
+      brandColors: {primary: '#000'}, runtimeDevice: {id: 403},
+      deviceOrderVisibility: 'company', setDeviceOrderVisibility: setVisibility,
+      deviceDeliveryEnabled: true, setDeviceDeliveryEnabled: setDelivery,
+      savingDeviceDeliverySettings: true, displayAutoPrintProductEnabled: true,
+      products: [{quantity: 2}], deviceRuntimeDebugInfoEnabled: true,
+    };
+    const context = createContext(state, {refreshCurrentConfig: jest.fn()}, {}, {
+      saveDeviceDeliverySettings: saveDelivery, renderSwitchRow, inflowTotal: 90,
+    });
+    expect(context.currentCompany).toBe(state.currentCompany);
+    expect(context.runtimeDevice).toBe(state.runtimeDevice);
+    expect(context.products).toBe(state.products);
+    expect(context.inflowTotal).toBe(90);
+    expect(context.palette).toBe(state.brandColors);
+    expect(context.orderVisibility).toBe('company');
+    expect(context.deliveryEnabled).toBe(true);
+    expect(context.savingDeliverySettings).toBe(true);
+    expect(context.displayAutoPrintProduct).toBe(true);
+    expect(context.runtimeDebugInfoEnabled).toBe(true);
+    context.setOrderVisibility('device');
+    context.setDeliveryEnabled(false);
+    context.saveDeviceDeliverySettings({deviceDeliveryEnabled: false});
+    expect(setVisibility).toHaveBeenCalledWith('device');
+    expect(setDelivery).toHaveBeenCalledWith(false);
+    expect(saveDelivery).toHaveBeenCalledWith({deviceDeliveryEnabled: false});
+    expect(context.renderSwitchRow).toBe(renderSwitchRow);
+  });
+});

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

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import {readFileSync} from 'node:fs';
+import test from 'node:test';
+
+const hookFiles = [
+  'useDeviceDetailActions.js',
+  'useDeviceDetailSaves.js',
+];
+
+for (const file of hookFiles) {
+  test(`${file} receives currentCompany from deps`, () => {
+    const source = readFileSync(
+      new URL(`../../../react/pages/Devices/detail/${file}`, import.meta.url),
+      'utf8',
+    );
+    const dependencies = source.match(
+      /export default function [^(]+\(deps\)[\s\S]*?const \{([\s\S]*?)\}\s*=\s*deps;/,
+    );
+
+    assert.ok(dependencies, `${file} dependency block not found`);
+    const block = dependencies[1];
+    const hits = block.match(/(?:^|,)\s*currentCompany\s*(?:,|$)/gm) || [];
+
+    assert.equal(
+      hits.length,
+      1,
+      `${file} must destructure currentCompany exactly once`,
+    );
+    assert.match(source, /currentCompany\?\.id/);
+  });
+}