test: move managed automation scenarios to integration lane

Author: thymikee

src/platform-runtime-gateway.fixtures.ts

@@ -85,7 +85,7 @@ export function gatewayFixture(registrations: readonly PlatformRuntimeProviderRe
   });
 }
 
-export const MANAGED_RETAINED_OPERATION = 'setSetting';
+export const REVIEWED_MANAGED_OPERATION = 'setSetting';
 
 export type LocalFamilyRuntimeFixture = Readonly<{
   module: PlatformRuntimeModule;

src/platform-runtime-gateway.test.ts

@@ -32,7 +32,7 @@ import {
   LIFECYCLE_FACETS,
   limrunTestDependencies,
   localFamilyRuntimeFixture,
-  MANAGED_RETAINED_OPERATION,
+  REVIEWED_MANAGED_OPERATION,
   managedGatewayScope,
   providerLifecycleOwnerFixture as providerLifecycleOwner,
   providerRuntimeFixture as providerRuntime,
@@ -660,7 +660,7 @@ describe('managed local owner registration', () => {
       available: false,
       reason: 'owner-capability-missing',
     });
-    expect(binding.facts.operations[MANAGED_RETAINED_OPERATION]).toEqual({ available: true });
+    expect(binding.facts.operations[REVIEWED_MANAGED_OPERATION]).toEqual({ available: true });
   });
 
   test('leaves ordinary selection on the local family owner while a managed owner is registered', async () => {

src/platform-runtime-managed-owner.test.ts

@@ -16,180 +16,23 @@ import {
   type PlatformRuntimeHost,
 } from '@agent-device/contracts/platform-runtime-operations';
 import { deployAppUse } from '@agent-device/contracts/app-deployment-runtime-plan';
-import { describe, expect, test, vi } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import { runCmd } from '@agent-device/host-kit/command';
-import { sleep } from '@agent-device/host-kit/retry';
-import { withAppleToolProvider } from '@agent-device/platform-apple/tool-provider';
-import { createRecordingAppleToolProvider } from '../test/integration/provider-scenarios/providers.ts';
-import { createDemoIosApp } from '../test/integration/provider-scenarios/fixtures.ts';
-import {
-  AUTOMATION_APP_ID,
-  AUTOMATION_PNG,
-  managedAutomationBinding,
-  managedAutomationApk,
-  withManagedAdbFixture,
-} from './platform-runtime-managed-owner.fixtures.ts';
+import { describe, expect, test } from 'vitest';
 import { createManagedLocalRuntimeOwner } from './platform-runtime-managed-owner.ts';
 import {
   gatewayFixtureDevice as device,
   gatewayFixtureScope as ordinaryScope,
   managedGatewayScope,
   localFamilyRuntimeFixture,
-  MANAGED_RETAINED_OPERATION,
+  REVIEWED_MANAGED_OPERATION,
 } from './platform-runtime-gateway.fixtures.ts';
 
-vi.mock('@agent-device/host-kit/retry', async (importOriginal) => ({
-  ...(await importOriginal<typeof import('@agent-device/host-kit/retry')>()),
-  sleep: vi.fn(async () => {}),
-}));
-
 const managed = managedLocalRuntimeOwner('sim-a');
 const fence = managedBindingFence({
   requesterId: 'requester-a',
   requestGeneration: 1,
   identityIncarnationId: 'incarnation-a',
 });
 
-test('managed iOS delegates deployment and system operations without local readiness or runner startup', async () => {
-  const app = createDemoIosApp('managed-ios-automation-');
-  let biometricAttempts = 0;
-  const native = createRecordingAppleToolProvider({
-    plist: {
-      readJson: async () => ({ CFBundleIdentifier: AUTOMATION_APP_ID, CFBundleName: 'Demo' }),
-    },
-    simctl: async (args) => {
-      expect(args.slice(0, 2)).toEqual(['--set', '/managed/set']);
-      const command = args[2];
-      if (command === 'list')
-        return {
-          stdout: JSON.stringify({
-            devices: { ios: [{ udid: 'managed-ios', state: 'Shutdown' }] },
-          }),
-          stderr: '',
-          exitCode: 0,
-        };
-      expect(['install', 'uninstall', 'pbpaste', 'pbcopy', 'ui', 'biometric', 'push']).toContain(
-        command,
-      );
-      if (command === 'biometric' && ++biometricAttempts === 1)
-        return { stdout: '', stderr: 'unknown command', exitCode: 1 };
-      return {
-        stdout: command === 'pbpaste' ? 'managed clipboard\n' : '',
-        stderr: '',
-        exitCode: 0,
-      };
-    },
-  });
-  try {
-    await withAppleToolProvider(native.provider, async () => {
-      const { binding, allocator, admission } = await managedAutomationBinding('ios');
-      expect(allocator.calls.map(({ method }) => method)).toEqual(['requestLease']);
-      const ops = binding.operations;
-      await ops.ensureReady!({});
-      await ops.deployApp!({
-        app: AUTOMATION_APP_ID,
-        appPath: app.appPath,
-        replaceExisting: false,
-      });
-      await ops.deployApp!({ app: AUTOMATION_APP_ID, appPath: app.appPath, replaceExisting: true });
-      const artifact = await ops.materializeAppSource!({
-        source: { kind: 'path', path: app.appPath },
-      });
-      try {
-        await ops.deployMaterializedApp!({ artifact });
-      } finally {
-        await artifact.cleanup();
-      }
-      await ops.sendPushNotification!({ appId: AUTOMATION_APP_ID, payload: {} });
-      expect(await ops.readClipboard!({})).toBe('managed clipboard');
-      await ops.writeClipboard!({ text: 'managed' });
-      await ops.setSetting!({ setting: 'appearance', state: 'dark' });
-      await ops.setSetting!({ setting: 'faceid', state: 'match' });
-      expect(biometricAttempts).toBe(2);
-      expect(native.calls.filter((call) => call[3] === 'install')).toHaveLength(3);
-      expect(
-        native.calls.some((call) => ['list', 'boot', 'bootstatus', 'shutdown'].includes(call[3]!)),
-      ).toBe(false);
-      expect(allocator.calls.map(({ method }) => method)).toEqual(['requestLease', 'renewLease']);
-      const before = native.calls.length;
-      admission.fenceBinding('replaced');
-      await expect(ops.readClipboard!({})).rejects.toMatchObject({
-        details: { reason: 'teardown-required' },
-      });
-      await binding[Symbol.asyncDispose]();
-      expect(native.calls).toHaveLength(before);
-    });
-  } finally {
-    fs.rmSync(app.tempRoot, { recursive: true, force: true });
-  }
-});
-
-test.skipIf(process.platform === 'win32')(
-  'managed Android contains bind probes, APK deployment, settings, clipboard and screenshot',
-  async () => {
-    await withManagedAdbFixture(async (native) => {
-      const { binding, host, allocator, admission } = await managedAutomationBinding('android');
-      expect(native.calls()).toHaveLength(1);
-      expect(allocator.calls.map(({ method }) => method)).toEqual(['requestLease']);
-      const ops = binding.operations;
-      const apkPath = await managedAutomationApk(native.root);
-      await ops.ensureReady!({});
-      await ops.deployApp!({ app: AUTOMATION_APP_ID, appPath: apkPath, replaceExisting: false });
-      await ops.deployApp!({ app: AUTOMATION_APP_ID, appPath: apkPath, replaceExisting: true });
-      const artifact = await ops.materializeAppSource!({ source: { kind: 'path', path: apkPath } });
-      try {
-        await ops.deployMaterializedApp!({ artifact });
-      } finally {
-        await artifact.cleanup();
-      }
-      await ops.sendPushNotification!({ appId: AUTOMATION_APP_ID, payload: {} });
-      expect(await ops.readClipboard!({})).toBe('managed clipboard');
-      await ops.writeClipboard!({ text: 'managed' });
-      await ops.setSetting!({ setting: 'fingerprint', state: 'match' });
-      await ops.setSetting!({
-        setting: 'clear-app-state',
-        state: 'clear',
-        appBundleId: AUTOMATION_APP_ID,
-      });
-      const outPath = path.join(native.root, 'capture.png');
-      await ops.captureScreenshot!({ outPath, options: { stabilize: false } });
-      expect(fs.readFileSync(outPath)).toEqual(AUTOMATION_PNG);
-      const calls = native.calls();
-      expect(calls.filter((args) => args[4] === 'install')).toHaveLength(3);
-      expect(calls.some((args) => args.slice(4).join(' ') === 'emu finger touch 1')).toBe(true);
-      for (const args of calls)
-        expect(args.slice(0, 4)).toEqual(['-P', '15037', '-s', 'emulator-15037']);
-      const bundle = path.join(native.root, 'App.aab');
-      fs.writeFileSync(bundle, 'bundle');
-      const archive = path.join(native.root, 'bundle.zip');
-      await runCmd('zip', ['-q', archive, 'App.aab'], { cwd: native.root });
-      const commands = vi.spyOn(host.commands, 'run');
-      for (const replaceExisting of [false, true]) {
-        await expect(
-          ops.deployApp!({ app: AUTOMATION_APP_ID, appPath: bundle, replaceExisting }),
-        ).rejects.toMatchObject({ details: { reason: 'managed-bundle-install-unavailable' } });
-      }
-      await expect(
-        ops.deployApp!({ app: AUTOMATION_APP_ID, appPath: archive, replaceExisting: true }),
-      ).rejects.toMatchObject({ details: { reason: 'managed-bundle-install-unavailable' } });
-      await expect(
-        ops.deployMaterializedApp!({
-          artifact: { installablePath: bundle, cleanup: async () => {} },
-        }),
-      ).rejects.toMatchObject({ details: { reason: 'managed-bundle-install-unavailable' } });
-      expect(commands).not.toHaveBeenCalled();
-      expect(native.calls()).toEqual(calls);
-      admission.fenceBinding('released');
-      await expect(ops.readClipboard!({})).rejects.toMatchObject({
-        details: { reason: 'teardown-required' },
-      });
-      await binding[Symbol.asyncDispose]();
-      expect(native.calls()).toEqual(calls);
-    });
-  },
-);
 const scope = managedGatewayScope(device, managed, fence);
 
 function exactly(
@@ -217,28 +60,6 @@ function thrownBy(run: () => unknown): unknown {
   throw new Error('expected the runtime use to be refused');
 }
 
-test.skipIf(process.platform === 'win32')(
-  'managed screenshot failure keeps demo-mode cleanup on its private transport',
-  async () => {
-    await withManagedAdbFixture(async (native) => {
-      const { binding } = await managedAutomationBinding('android');
-      vi.mocked(sleep).mockClear();
-      fs.writeFileSync(path.join(native.root, 'corrupt-screenshot'), '');
-      await expect(
-        binding.operations.captureScreenshot!({ outPath: path.join(native.root, 'bad.png') }),
-      ).rejects.toThrow('valid PNG header');
-      expect(sleep).toHaveBeenCalledOnce();
-      const calls = native.calls();
-      expect(calls.at(-1)?.at(-1)).toBe(
-        'am broadcast -a com.android.systemui.demo -e command exit',
-      );
-      for (const args of calls)
-        expect(args.slice(0, 4)).toEqual(['-P', '15037', '-s', 'emulator-15037']);
-      await binding[Symbol.asyncDispose]();
-    });
-  },
-);
-
 describe('managed local runtime owner', () => {
   test('dispatches the real operation inside admission before authority can be fenced', async () => {
     const events: string[] = [];
@@ -322,8 +143,8 @@ describe('managed local runtime owner', () => {
       });
       expect(binding.operations[key]).toBeUndefined();
     }
-    expect(binding.facts.operations[MANAGED_RETAINED_OPERATION]).toEqual({ available: true });
-    expect(binding.operations[MANAGED_RETAINED_OPERATION]).toBeTypeOf('function');
+    expect(binding.facts.operations[REVIEWED_MANAGED_OPERATION]).toEqual({ available: true });
+    expect(binding.operations[REVIEWED_MANAGED_OPERATION]).toBeTypeOf('function');
   });
 
   // The exclusion covers binding cells; request-runtime binding owns the separate pre-binding
@@ -391,7 +212,7 @@ describe('managed local runtime owner', () => {
     expect(binding.owner).toEqual(managed);
   });
 
-  test('never claims a device and projects the same withholding onto inspected facts', async () => {
+  test('never claims a device and leaves unbound inspection entirely unavailable', async () => {
     const { owner } = managedOwnerFixture();
 
     expect(owner.ownsDevice(device)).toBe(false);
@@ -400,7 +221,7 @@ describe('managed local runtime owner', () => {
       available: false,
       reason: 'owner-capability-missing',
     });
-    expect(facts.operations[MANAGED_RETAINED_OPERATION].available).toBe(false);
+    expect(facts.operations[REVIEWED_MANAGED_OPERATION].available).toBe(false);
   });
 
   test('reports the family owner provider mode it was given, unlaundered', async () => {

…atform-runtime-managed-owner.fixtures.ts …s/managed-runtime-automation.fixtures.tssrc/platform-runtime-managed-owner.fixtures.ts renamed to test/integration/provider-scenarios/managed-runtime-automation.fixtures.ts src/platform-runtime-managed-owner.fixtures.ts renamed to test/integration/provider-scenarios/managed-runtime-automation.fixtures.ts

@@ -7,20 +7,20 @@ import type {
   ManagedLease,
   ManagedLeasePlatform,
 } from '@agent-device/contracts/managed-device-allocation';
-import { createManagedLeaseReachability } from './managed-device-reachability.ts';
-import { createManagedLeaseAdmission } from './daemon/managed-device-allocation/lease-admission.ts';
-import { createScriptedManagedDeviceAllocator } from './__tests__/test-utils/managed-device-allocator.fixtures.ts';
+import { createManagedLeaseReachability } from '../../../src/managed-device-reachability.ts';
+import { createManagedLeaseAdmission } from '../../../src/daemon/managed-device-allocation/lease-admission.ts';
+import { createScriptedManagedDeviceAllocator } from '../../../src/__tests__/test-utils/managed-device-allocator.fixtures.ts';
 import {
   ALLOCATION_GRANTED_STATUS,
   ALLOCATION_LEASE,
   ALLOCATION_REQUEST,
-} from './daemon/managed-device-allocation/__tests__/fixtures.ts';
-import { managedGatewayScope } from './platform-runtime-gateway.fixtures.ts';
-import { createComposedPlatformRuntimeGateway } from './platform-runtime-gateway.ts';
-import { platformRuntimeModules } from './platform-runtime.ts';
-import { createPlatformRuntimeHost } from './platform-runtime-operation-host.ts';
-import { mkdtempForTestSync } from './__tests__/test-utils/tmp-dir.ts';
-import './platform-runtime-android-adb-host.ts';
+} from '../../../src/daemon/managed-device-allocation/__tests__/fixtures.ts';
+import { managedGatewayScope } from '../../../src/platform-runtime-gateway.fixtures.ts';
+import { createComposedPlatformRuntimeGateway } from '../../../src/platform-runtime-gateway.ts';
+import { platformRuntimeModules } from '../../../src/platform-runtime.ts';
+import { createPlatformRuntimeHost } from '../../../src/platform-runtime-operation-host.ts';
+import { mkdtempForTestSync } from '../../../src/__tests__/test-utils/tmp-dir.ts';
+import '../../../src/platform-runtime-android-adb-host.ts';
 
 export const AUTOMATION_APP_ID = 'com.example.demo';
 export const AUTOMATION_PNG = Buffer.from('89504e470d0a1a0a0000000049454e44ae426082', 'hex');