@react-native-harness/platform-android 1.1.0-rc.4 → 1.1.0

package/src/__tests__/adb.test.ts

@@ -17,6 +17,7 @@ import {
 } from '../adb.js';
 import * as tools from '@react-native-harness/tools';
 import * as environment from '../environment.js';
+import * as avdConfig from '../avd-config.js';
 
 const createAbortError = () =>
   new DOMException('The operation was aborted', 'AbortError');
@@ -48,7 +49,7 @@ describe('getStartAppArgs', () => {
           user_id: 42,
           mode: 'debug',
         },
-      })
+      }),
     ).toEqual([
       'shell',
       'am',
@@ -77,7 +78,7 @@ describe('getStartAppArgs', () => {
         extras: {
           count: Number.MAX_SAFE_INTEGER + 1,
         },
-      })
+      }),
     ).toThrow('must be a safe integer');
   });
 
@@ -88,7 +89,7 @@ describe('getStartAppArgs', () => {
     } as Awaited<ReturnType<typeof tools.spawn>>);
 
     await expect(getAppUid('emulator-5554', 'com.example.app')).resolves.toBe(
-      10234
+      10234,
     );
 
     expect(spawnSpy).toHaveBeenCalledWith(expect.stringMatching(/adb$/), [
@@ -108,7 +109,7 @@ describe('getStartAppArgs', () => {
     } as Awaited<ReturnType<typeof tools.spawn>>);
 
     await expect(getLogcatTimestamp('emulator-5554')).resolves.toBe(
-      '03-12 11:35:08.000'
+      '03-12 11:35:08.000',
     );
 
     expect(spawnSpy).toHaveBeenCalledWith(expect.stringMatching(/adb$/), [
@@ -146,14 +147,19 @@ describe('getStartAppArgs', () => {
   });
 
   it('creates an AVD and appends config overrides', async () => {
+    vi.spyOn(avdConfig, 'readAvdConfig').mockResolvedValue({});
     const spawnSpy = vi
       .spyOn(tools, 'spawn')
-      .mockResolvedValue({} as Awaited<ReturnType<typeof tools.spawn>>);
+      .mockResolvedValue({} as Awaited<ReturnType<typeof tools.spawn>>)
+      .mockResolvedValueOnce({
+        stdout:
+          'id: 0 or "pixel_8"\n    Name: Pixel 8\nid: 1 or "pixel_6"\n    Name: Pixel 6\n',
+      } as Awaited<ReturnType<typeof tools.spawn>>);
     const verifyAndroidEmulatorSdk = vi
       .spyOn(environment, 'ensureAndroidSdkPackages')
       .mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(environment, 'getHostAndroidSystemImageArch').mockReturnValue(
-      'x86_64'
+      'x86_64',
     );
 
     await createAvd({
@@ -170,29 +176,128 @@ describe('getStartAppArgs', () => {
       'platforms;android-35',
       'system-images;android-35;default;x86_64',
     ]);
-    expect(spawnSpy).toHaveBeenNthCalledWith(1, 'bash', [
+    expect(spawnSpy).toHaveBeenNthCalledWith(
+      1,
+      expect.stringMatching(/avdmanager$/),
+      ['list', 'device'],
+    );
+    expect(spawnSpy).toHaveBeenNthCalledWith(2, 'bash', [
       '-lc',
       expect.stringContaining(
-        'create avd --force --name "Pixel_8_API_35" --package "system-images;android-35;default;x86_64" --device "pixel_8"'
+        'create avd --force --name "Pixel_8_API_35" --package "system-images;android-35;default;x86_64" --device "pixel_8" -p ',
       ),
     ]);
-    expect(spawnSpy).toHaveBeenNthCalledWith(2, 'bash', [
+    expect(spawnSpy).toHaveBeenNthCalledWith(3, 'bash', [
+      '-lc',
+      expect.stringContaining(`'avd.ini.encoding=UTF-8' 'path=`),
+    ]);
+    expect(spawnSpy).toHaveBeenNthCalledWith(4, 'bash', [
       '-lc',
       expect.stringContaining(
-        `'disk.dataPartition.size=1G' 'vm.heapSize=1G' >> `
+        `'disk.dataPartition.size=1G' 'vm.heapSize=1G' >> `,
       ),
     ]);
   });
 
-  it('creates an AVD with arm64 system image packages on arm64 hosts', async () => {
-    vi.spyOn(tools, 'spawn').mockResolvedValue(
-      {} as Awaited<ReturnType<typeof tools.spawn>>
+  it('recreates the companion ini file when avdmanager leaves it missing', async () => {
+    vi.spyOn(avdConfig, 'readAvdConfig').mockResolvedValue({});
+    const spawnSpy = vi
+      .spyOn(tools, 'spawn')
+      .mockResolvedValue({} as Awaited<ReturnType<typeof tools.spawn>>)
+      .mockResolvedValueOnce({
+        stdout: 'id: 0 or "pixel_6"\n    Name: Pixel 6\n',
+      } as Awaited<ReturnType<typeof tools.spawn>>);
+    vi.spyOn(environment, 'ensureAndroidSdkPackages').mockResolvedValue(
+      '/tmp/android-sdk',
+    );
+    vi.spyOn(environment, 'getHostAndroidSystemImageArch').mockReturnValue(
+      'x86_64',
     );
+
+    await createAvd({
+      name: 'Pixel_6_API_35',
+      apiLevel: 35,
+      profile: 'pixel_6',
+      diskSize: '1G',
+      heapSize: '1G',
+    });
+
+    expect(spawnSpy).toHaveBeenNthCalledWith(3, 'bash', [
+      '-lc',
+      expect.stringContaining(`'avd.ini.encoding=UTF-8' 'path=`),
+    ]);
+    expect(spawnSpy).toHaveBeenNthCalledWith(4, 'bash', [
+      '-lc',
+      expect.stringContaining(
+        `'disk.dataPartition.size=1G' 'vm.heapSize=1G' >> `,
+      ),
+    ]);
+  });
+
+  it('throws an actionable error when the requested AVD profile is unavailable', async () => {
+    vi.spyOn(tools, 'spawn').mockResolvedValueOnce({
+      stdout:
+        'id: 0 or "pixel_8"\n    Name: Pixel 8\nid: 1 or "pixel_6"\n    Name: Pixel 6\n',
+    } as Awaited<ReturnType<typeof tools.spawn>>);
+    vi.spyOn(environment, 'ensureAndroidSdkPackages').mockResolvedValue(
+      '/tmp/android-sdk',
+    );
+    vi.spyOn(environment, 'getHostAndroidSystemImageArch').mockReturnValue(
+      'x86_64',
+    );
+
+    await expect(
+      createAvd({
+        name: 'Pixel_8_Pro_API_35',
+        apiLevel: 35,
+        profile: 'pixel_8_pro',
+        diskSize: '1G',
+        heapSize: '1G',
+      }),
+    ).rejects.toThrow(
+      'Android AVD profile "pixel_8_pro" is not available on this machine. Available profiles: pixel_8, pixel_6',
+    );
+  });
+
+  it('throws a clear error when avdmanager does not create config.ini', async () => {
+    vi.spyOn(avdConfig, 'readAvdConfig').mockResolvedValue(null);
+    vi.spyOn(tools, 'spawn')
+      .mockResolvedValue({} as Awaited<ReturnType<typeof tools.spawn>>)
+      .mockResolvedValueOnce({
+        stdout: 'id: 0 or "pixel_6"\n    Name: Pixel 6\n',
+      } as Awaited<ReturnType<typeof tools.spawn>>);
+    vi.spyOn(environment, 'ensureAndroidSdkPackages').mockResolvedValue(
+      '/tmp/android-sdk',
+    );
+    vi.spyOn(environment, 'getHostAndroidSystemImageArch').mockReturnValue(
+      'x86_64',
+    );
+
+    await expect(
+      createAvd({
+        name: 'Pixel_6_API_35',
+        apiLevel: 35,
+        profile: 'pixel_6',
+        diskSize: '1G',
+        heapSize: '1G',
+      }),
+    ).rejects.toThrow(
+      'Android AVD "Pixel_6_API_35" was created, but config.ini was not found at ',
+    );
+  });
+
+  it('creates an AVD with arm64 system image packages on arm64 hosts', async () => {
+    vi.spyOn(avdConfig, 'readAvdConfig').mockResolvedValue({});
+    vi.spyOn(tools, 'spawn')
+      .mockResolvedValue({} as Awaited<ReturnType<typeof tools.spawn>>)
+      .mockResolvedValueOnce({
+        stdout: 'id: 0 or "pixel_8"\n    Name: Pixel 8\n',
+      } as Awaited<ReturnType<typeof tools.spawn>>);
     const ensureAndroidSdkPackages = vi
       .spyOn(environment, 'ensureAndroidSdkPackages')
       .mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(environment, 'getHostAndroidSystemImageArch').mockReturnValue(
-      'arm64-v8a'
+      'arm64-v8a',
     );
 
     await createAvd({
@@ -241,7 +346,7 @@ describe('getStartAppArgs', () => {
     child.emit('close', 1, null);
 
     await expect(startPromise).rejects.toThrow(
-      'Unknown AVD name [Pixel_8_API_35]'
+      'Unknown AVD name [Pixel_8_API_35]',
     );
   });
 
@@ -271,7 +376,7 @@ describe('getStartAppArgs', () => {
     child.emit('close', 1, null);
 
     await expect(startPromise).rejects.toThrow(
-      'emulator: panic: broken config'
+      'emulator: panic: broken config',
     );
   });
 
@@ -291,7 +396,7 @@ describe('getStartAppArgs', () => {
     vi.spyOn(emulatorProcess, 'startDetachedProcess').mockReturnValue(
       child as unknown as ReturnType<
         typeof emulatorProcess.startDetachedProcess
-      >
+      >,
     );
 
     const startPromise = startEmulator('Pixel_8_API_35');
@@ -317,7 +422,7 @@ describe('getStartAppArgs', () => {
       .mockReturnValue(
         child as unknown as ReturnType<
           typeof emulatorProcess.startDetachedProcess
-        >
+        >,
       );
 
     const startPromise = startEmulator('Pixel_8_API_35');
@@ -326,7 +431,7 @@ describe('getStartAppArgs', () => {
 
     expect(startDetachedProcess).toHaveBeenCalledWith(
       expect.stringMatching(/emulator$/),
-      expect.arrayContaining(['-no-snapshot-load', '-no-snapshot-save'])
+      expect.arrayContaining(['-no-snapshot-load', '-no-snapshot-save']),
     );
   });
 
@@ -345,22 +450,22 @@ describe('getStartAppArgs', () => {
       .mockReturnValue(
         child as unknown as ReturnType<
           typeof emulatorProcess.startDetachedProcess
-        >
+        >,
       );
 
     const startPromise = startEmulator(
       'Pixel_8_API_35',
-      'clean-snapshot-generation'
+      'clean-snapshot-generation',
     );
     await vi.runAllTimersAsync();
     await startPromise;
 
     expect(startDetachedProcess).toHaveBeenCalledWith(
       expect.stringMatching(/emulator$/),
-      expect.arrayContaining(['-no-snapshot-load'])
+      expect.arrayContaining(['-no-snapshot-load']),
     );
     expect(startDetachedProcess.mock.calls[0]?.[1]).not.toContain(
-      '-no-snapshot-save'
+      '-no-snapshot-save',
     );
   });
 
@@ -379,7 +484,7 @@ describe('getStartAppArgs', () => {
       .mockReturnValue(
         child as unknown as ReturnType<
           typeof emulatorProcess.startDetachedProcess
-        >
+        >,
       );
 
     const startPromise = startEmulator('Pixel_8_API_35', 'snapshot-reuse');
@@ -388,10 +493,10 @@ describe('getStartAppArgs', () => {
 
     expect(startDetachedProcess).toHaveBeenCalledWith(
       expect.stringMatching(/emulator$/),
-      expect.arrayContaining(['-no-snapshot-save'])
+      expect.arrayContaining(['-no-snapshot-save']),
     );
     expect(startDetachedProcess.mock.calls[0]?.[1]).not.toContain(
-      '-no-snapshot-load'
+      '-no-snapshot-load',
     );
   });
 
@@ -459,7 +564,7 @@ describe('getStartAppArgs', () => {
 
     const waitPromise = waitForBoot(
       'Pixel_8_API_35',
-      new AbortController().signal
+      new AbortController().signal,
     );
 
     await vi.advanceTimersByTimeAsync(1000);
@@ -482,7 +587,7 @@ describe('getStartAppArgs', () => {
 
     const waitPromise = waitForEmulatorDisconnect(
       'emulator-5554',
-      new AbortController().signal
+      new AbortController().signal,
     );
 
     await vi.advanceTimersByTimeAsync(1000);

package/src/adb.ts

@@ -4,6 +4,11 @@ import { spawn as nodeSpawn } from 'node:child_process';
 import type { ChildProcessByStdio } from 'node:child_process';
 import { access, rm } from 'node:fs/promises';
 import type { Readable } from 'node:stream';
+import {
+  getAvdConfigPath,
+  getAvdDirectory,
+  readAvdConfig,
+} from './avd-config.js';
 import {
   ensureAndroidEmulatorAvailable,
   ensureAndroidSdkPackages,
@@ -52,11 +57,6 @@ const waitWithSignal = async (
   await Promise.race([wait(ms), waitForAbort(signal)]);
 };
 
-const getAvdConfigPath = (name: string): string =>
-  `${
-    process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`
-  }/${name}.avd/config.ini`;
-
 const EMULATOR_STARTUP_OBSERVATION_TIMEOUT_MS = 5000;
 const EMULATOR_OUTPUT_BUFFER_LIMIT = 16 * 1024;
 
@@ -160,6 +160,68 @@ export const verifyAndroidEmulatorSdk = async (
   await ensureAndroidSdkPackages(getRequiredEmulatorPackages(apiLevel));
 };
 
+const listAvdProfiles = async (): Promise<string[]> => {
+  const { stdout } = await spawn(getAvdManagerBinaryPath(), ['list', 'device']);
+
+  return stdout
+    .split('\n')
+    .map((line) => line.match(/^id:\s+\d+\s+or\s+"([^"]+)"/i)?.[1]?.trim())
+    .filter((profile): profile is string => profile != null && profile !== '');
+};
+
+const ensureAvdProfileAvailable = async (profile: string): Promise<void> => {
+  const availableProfiles = await listAvdProfiles();
+
+  if (availableProfiles.includes(profile)) {
+    return;
+  }
+
+  const availableProfilesList =
+    availableProfiles.length > 0
+      ? availableProfiles.join(', ')
+      : 'None reported by avdmanager.';
+
+  throw new Error(
+    `Android AVD profile "${profile}" is not available on this machine. Available profiles: ${availableProfilesList}`,
+  );
+};
+
+const ensureAvdConfigExists = async (name: string): Promise<string> => {
+  const configPath = getAvdConfigPath(name);
+
+  if ((await readAvdConfig(name)) == null) {
+    throw new Error(
+      `Android AVD "${name}" was created, but config.ini was not found at ${configPath}.`,
+    );
+  }
+
+  return configPath;
+};
+
+const getAvdIniPath = (name: string): string => {
+  const avdHome =
+    process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`;
+  return `${avdHome}/${name}.ini`;
+};
+
+const ensureAvdIniExists = async ({
+  name,
+  apiLevel,
+}: {
+  name: string;
+  apiLevel: number;
+}): Promise<string> => {
+  const iniPath = getAvdIniPath(name);
+
+  const avdDirectory = getAvdDirectory(name);
+  await spawn('bash', [
+    '-lc',
+    `printf '%s\n%s\n%s\n%s\n' 'avd.ini.encoding=UTF-8' 'path=${avdDirectory}' 'path.rel=avd/${name}.avd' 'target=android-${apiLevel}' > "${iniPath}"`,
+  ]);
+
+  return iniPath;
+};
+
 export const getStartAppArgs = (
   bundleId: string,
   activityName: string,
@@ -354,15 +416,16 @@ export const createAvd = async ({
   );
 
   await verifyAndroidEmulatorSdk(apiLevel);
+  await ensureAvdProfileAvailable(profile);
   await spawn('bash', [
     '-lc',
-    `printf 'no\n' | "${getAvdManagerBinaryPath()}" create avd --force --name "${name}" --package "${systemImagePackage}" --device "${profile}"`,
+    `printf 'no\n' | "${getAvdManagerBinaryPath()}" create avd --force --name "${name}" --package "${systemImagePackage}" --device "${profile}" -p "${getAvdDirectory(name)}"`,
   ]);
+  await ensureAvdIniExists({ name, apiLevel });
+  const configPath = await ensureAvdConfigExists(name);
   await spawn('bash', [
     '-lc',
-    `printf '%s\n%s\n' 'disk.dataPartition.size=${diskSize}' 'vm.heapSize=${heapSize}' >> "${getAvdConfigPath(
-      name,
-    )}"`,
+    `printf '%s\n%s\n' 'disk.dataPartition.size=${diskSize}' 'vm.heapSize=${heapSize}' >> "${configPath}"`,
   ]);
 };
 

package/dist/assertions.d.ts

@@ -1,5 +0,0 @@
-import { Config, NativeTestRunnerConfig } from './types.js';
-export declare function assertNativeRunner(config: Config): asserts config is Config & {
-    runner: NativeTestRunnerConfig;
-};
-//# sourceMappingURL=assertions.d.ts.map

package/dist/assertions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../src/assertions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAE5D,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,IAAI,MAAM,GAAG;IAAE,MAAM,EAAE,sBAAsB,CAAA;CAAE,CAO/D"}

package/dist/assertions.js

@@ -1,6 +0,0 @@
-export function assertNativeRunner(config) {
-    if (config.runner.platform !== 'ios' &&
-        config.runner.platform !== 'android') {
-        throw new Error('Runner is not a native runner');
-    }
-}

package/dist/emulator.d.ts

@@ -1,6 +0,0 @@
-export type AndroidEmulator = {
-    adbId: string;
-    stop: () => Promise<void>;
-};
-export declare const runEmulator: (avdName: string) => Promise<AndroidEmulator>;
-//# sourceMappingURL=emulator.d.ts.map

package/dist/emulator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emulator.d.ts","sourceRoot":"","sources":["../src/emulator.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,SAAS,MAAM,KACd,OAAO,CAAC,eAAe,CA8BzB,CAAC"}

package/dist/emulator.js

@@ -1,27 +0,0 @@
-import { spawn } from '@react-native-harness/tools';
-import * as adb from './adb.js';
-export const runEmulator = async (avdName) => {
-    const process = spawn('emulator', ['-avd', avdName]);
-    await process.nodeChildProcess;
-    const adbId = await adb.getEmulatorName(avdName);
-    if (!adbId) {
-        throw new Error('Emulator not found');
-    }
-    // Poll for emulator status until it's fully running
-    const checkStatus = async () => {
-        const status = await adb.isBootCompleted(adbId);
-        if (!status) {
-            await new Promise((resolve) => setTimeout(resolve, 2000));
-            await checkStatus();
-        }
-    };
-    // Start checking status after a brief delay to allow emulator to start
-    await new Promise((resolve) => setTimeout(resolve, 3000));
-    await checkStatus();
-    return {
-        adbId,
-        stop: async () => {
-            await adb.stopEmulator(adbId);
-        },
-    };
-};

package/dist/reader.d.ts

@@ -1,6 +0,0 @@
-import { Config } from './types.js';
-export declare const getConfig: (dir: string) => Promise<{
-    config: Config;
-    projectRoot: string;
-}>;
-//# sourceMappingURL=reader.d.ts.map

package/dist/reader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../src/reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgB,MAAM,YAAY,CAAC;AAsElD,eAAO,MAAM,SAAS,GACpB,KAAK,MAAM,KACV,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAUjD,CAAC"}

package/dist/reader.js

@@ -1,57 +0,0 @@
-import { ConfigSchema } from './types.js';
-import { ConfigValidationError, ConfigNotFoundError, ConfigLoadError, } from './errors.js';
-import path from 'node:path';
-import fs from 'node:fs';
-import { createRequire } from 'node:module';
-import { ZodError } from 'zod';
-const extensions = ['.js', '.mjs', '.cjs', '.json'];
-const importUp = async (dir, name) => {
-    const filePath = path.join(dir, name);
-    for (const ext of extensions) {
-        const filePathWithExt = `${filePath}${ext}`;
-        if (fs.existsSync(filePathWithExt)) {
-            let rawConfig;
-            try {
-                if (ext === '.mjs') {
-                    rawConfig = await import(filePathWithExt).then((module) => module.default);
-                }
-                else {
-                    const require = createRequire(import.meta.url);
-                    rawConfig = require(filePathWithExt);
-                }
-            }
-            catch (error) {
-                throw new ConfigLoadError(filePathWithExt, error instanceof Error ? error : undefined);
-            }
-            try {
-                const config = ConfigSchema.parse(rawConfig);
-                return { config, filePathWithExt, configDir: dir };
-            }
-            catch (error) {
-                if (error instanceof ZodError) {
-                    const validationErrors = error.errors.map((err) => {
-                        const path = err.path.length > 0 ? ` at "${err.path.join('.')}"` : '';
-                        return `${err.message}${path}`;
-                    });
-                    throw new ConfigValidationError(filePathWithExt, validationErrors);
-                }
-                throw error;
-            }
-        }
-    }
-    const parentDir = path.dirname(dir);
-    if (parentDir === dir) {
-        throw new ConfigNotFoundError(dir);
-    }
-    return importUp(parentDir, name);
-};
-export const getConfig = async (dir) => {
-    const { config, configDir } = await importUp(dir, 'rn-harness.config');
-    return {
-        config: {
-            ...config,
-            reporter: config.reporter,
-        },
-        projectRoot: configDir,
-    };
-};