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

package/README.md

@@ -32,7 +32,12 @@ const config = {
   runners: [
     androidPlatform({
       name: 'android',
-      device: androidEmulator('Pixel_8_API_35'),
+      device: androidEmulator('Pixel_8_API_35', {
+        apiLevel: 35,
+        profile: 'pixel_8',
+        diskSize: '1G',
+        heapSize: '1G',
+      }),
       bundleId: 'com.your.app',
     }),
     androidPlatform({
@@ -78,7 +83,9 @@ Creates a physical Android device configuration.
 
 ## Requirements
 
-- Android SDK installed
+- On macOS and Linux, Harness can resolve the SDK root from `ANDROID_HOME`, then `ANDROID_SDK_ROOT`, then the default SDK path (`~/Library/Android/sdk` on macOS or `~/Android/Sdk` on Linux)
+- For emulator runners with an `avd` config, Harness reads the runner config and automatically verifies or installs missing SDK packages, including `platform-tools`, `emulator`, `platforms;android-<apiLevel>`, and the matching system image for the host architecture
+- If the SDK root does not exist yet on macOS or Linux, Harness bootstraps Android command-line tools and accepts licenses for non-interactive installs
 - Android emulator or physical device connected
 - React Native project configured for Android
 

package/dist/__tests__/adb.test.js

@@ -1,6 +1,21 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getAppUid, getLogcatTimestamp, getStartAppArgs } from '../adb.js';
+import { EventEmitter } from 'node:events';
+import { PassThrough } from 'node:stream';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { SubprocessError } from '@react-native-harness/tools';
+import { createAvd, deleteAvd, emulatorProcess, getAppUid, getLogcatTimestamp, getStartAppArgs, hasAvd, installApp, startEmulator, waitForBoot, waitForEmulatorDisconnect, } from '../adb.js';
 import * as tools from '@react-native-harness/tools';
+import * as environment from '../environment.js';
+const createAbortError = () => new DOMException('The operation was aborted', 'AbortError');
+const createMockChildProcess = () => {
+    const process = new EventEmitter();
+    process.stdout = new PassThrough();
+    process.stderr = new PassThrough();
+    process.unref = vi.fn();
+    return process;
+};
+beforeEach(() => {
+    vi.restoreAllMocks();
+});
 describe('getStartAppArgs', () => {
     it('maps supported extras to adb am start flags', () => {
         expect(getStartAppArgs('com.example.app', '.MainActivity', {
@@ -38,13 +53,11 @@ describe('getStartAppArgs', () => {
         })).toThrow('must be a safe integer');
     });
     it('extracts app uid from pm list packages output', async () => {
-        const spawnSpy = vi
-            .spyOn(tools, 'spawn')
-            .mockResolvedValueOnce({
+        const spawnSpy = vi.spyOn(tools, 'spawn').mockResolvedValueOnce({
             stdout: 'package:com.other.app uid:10123\npackage:com.example.app uid:10234\n',
         });
         await expect(getAppUid('emulator-5554', 'com.example.app')).resolves.toBe(10234);
-        expect(spawnSpy).toHaveBeenCalledWith('adb', [
+        expect(spawnSpy).toHaveBeenCalledWith(expect.stringMatching(/adb$/), [
             '-s',
             'emulator-5554',
             'shell',
@@ -55,13 +68,11 @@ describe('getStartAppArgs', () => {
         ]);
     });
     it('reads the device timestamp in logcat format', async () => {
-        const spawnSpy = vi
-            .spyOn(tools, 'spawn')
-            .mockResolvedValueOnce({
+        const spawnSpy = vi.spyOn(tools, 'spawn').mockResolvedValueOnce({
             stdout: "'03-12 11:35:08.000'\n",
         });
         await expect(getLogcatTimestamp('emulator-5554')).resolves.toBe('03-12 11:35:08.000');
-        expect(spawnSpy).toHaveBeenCalledWith('adb', [
+        expect(spawnSpy).toHaveBeenCalledWith(expect.stringMatching(/adb$/), [
             '-s',
             'emulator-5554',
             'shell',
@@ -69,4 +80,266 @@ describe('getStartAppArgs', () => {
             "+'%m-%d %H:%M:%S.000'",
         ]);
     });
+    it('checks whether an AVD exists', async () => {
+        vi.spyOn(tools, 'spawn').mockResolvedValueOnce({
+            stdout: 'Pixel_6_API_33\nPixel_8_API_35\n',
+        });
+        await expect(hasAvd('Pixel_8_API_35')).resolves.toBe(true);
+        await expect(hasAvd('Missing_AVD')).resolves.toBe(false);
+    });
+    it('installs the app via adb', async () => {
+        const spawnSpy = vi
+            .spyOn(tools, 'spawn')
+            .mockResolvedValueOnce({});
+        await installApp('emulator-5554', '/tmp/app.apk');
+        expect(spawnSpy).toHaveBeenCalledWith(expect.stringMatching(/adb$/), [
+            '-s',
+            'emulator-5554',
+            'install',
+            '-r',
+            '/tmp/app.apk',
+        ]);
+    });
+    it('creates an AVD and appends config overrides', async () => {
+        const spawnSpy = vi
+            .spyOn(tools, 'spawn')
+            .mockResolvedValue({});
+        const verifyAndroidEmulatorSdk = vi
+            .spyOn(environment, 'ensureAndroidSdkPackages')
+            .mockResolvedValue('/tmp/android-sdk');
+        vi.spyOn(environment, 'getHostAndroidSystemImageArch').mockReturnValue('x86_64');
+        await createAvd({
+            name: 'Pixel_8_API_35',
+            apiLevel: 35,
+            profile: 'pixel_8',
+            diskSize: '1G',
+            heapSize: '1G',
+        });
+        expect(verifyAndroidEmulatorSdk).toHaveBeenCalledWith([
+            'platform-tools',
+            'emulator',
+            'platforms;android-35',
+            'system-images;android-35;default;x86_64',
+        ]);
+        expect(spawnSpy).toHaveBeenNthCalledWith(1, 'bash', [
+            '-lc',
+            expect.stringContaining('create avd --force --name "Pixel_8_API_35" --package "system-images;android-35;default;x86_64" --device "pixel_8"'),
+        ]);
+        expect(spawnSpy).toHaveBeenNthCalledWith(2, 'bash', [
+            '-lc',
+            expect.stringContaining(`'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({});
+        const ensureAndroidSdkPackages = vi
+            .spyOn(environment, 'ensureAndroidSdkPackages')
+            .mockResolvedValue('/tmp/android-sdk');
+        vi.spyOn(environment, 'getHostAndroidSystemImageArch').mockReturnValue('arm64-v8a');
+        await createAvd({
+            name: 'Pixel_8_API_35',
+            apiLevel: 35,
+            profile: 'pixel_8',
+            diskSize: '1G',
+            heapSize: '1G',
+        });
+        expect(ensureAndroidSdkPackages).toHaveBeenCalledWith([
+            'platform-tools',
+            'emulator',
+            'platforms;android-35',
+            'system-images;android-35;default;arm64-v8a',
+        ]);
+    });
+    it.skip('deletes both AVD directory and ini file', async () => {
+        await deleteAvd('Pixel_8_API_35');
+    });
+    it('surfaces emulator stdout when startup fails immediately', async () => {
+        const child = createMockChildProcess();
+        let launcherReadyResolve;
+        const launcherReady = new Promise((resolve) => {
+            launcherReadyResolve = resolve;
+        });
+        vi.spyOn(tools, 'spawn').mockResolvedValue({
+            stdout: 'List of devices attached\n\n',
+        });
+        vi.spyOn(emulatorProcess, 'startDetachedProcess').mockImplementation(() => {
+            launcherReadyResolve?.();
+            return child;
+        });
+        const startPromise = startEmulator('Pixel_8_API_35');
+        await launcherReady;
+        child.stdout.write('Unknown AVD name [Pixel_8_API_35]\n');
+        child.stdout.end();
+        child.stderr.end();
+        child.emit('close', 1, null);
+        await expect(startPromise).rejects.toThrow('Unknown AVD name [Pixel_8_API_35]');
+    });
+    it('surfaces emulator stderr when startup fails immediately', async () => {
+        const child = createMockChildProcess();
+        let launcherReadyResolve;
+        const launcherReady = new Promise((resolve) => {
+            launcherReadyResolve = resolve;
+        });
+        vi.spyOn(tools, 'spawn').mockResolvedValue({
+            stdout: 'List of devices attached\n\n',
+        });
+        vi.spyOn(emulatorProcess, 'startDetachedProcess').mockImplementation(() => {
+            launcherReadyResolve?.();
+            return child;
+        });
+        const startPromise = startEmulator('Pixel_8_API_35');
+        await launcherReady;
+        child.stderr.write('emulator: panic: broken config\n');
+        child.stdout.end();
+        child.stderr.end();
+        child.emit('close', 1, null);
+        await expect(startPromise).rejects.toThrow('emulator: panic: broken config');
+    });
+    it('returns after the emulator appears without waiting for process exit', async () => {
+        vi.useFakeTimers();
+        const child = createMockChildProcess();
+        const spawnSpy = vi.spyOn(tools, 'spawn');
+        spawnSpy
+            .mockResolvedValueOnce({
+            stdout: 'List of devices attached\nemulator-5554\tdevice\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: 'Pixel_8_API_35\n',
+        });
+        vi.spyOn(emulatorProcess, 'startDetachedProcess').mockReturnValue(child);
+        const startPromise = startEmulator('Pixel_8_API_35');
+        await vi.runAllTimersAsync();
+        await expect(startPromise).resolves.toBeUndefined();
+        expect(child.unref).toHaveBeenCalled();
+    });
+    it('passes default boot args to the emulator process', async () => {
+        vi.useFakeTimers();
+        const child = createMockChildProcess();
+        vi.spyOn(tools, 'spawn')
+            .mockResolvedValueOnce({
+            stdout: 'List of devices attached\nemulator-5554\tdevice\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: 'Pixel_8_API_35\n',
+        });
+        const startDetachedProcess = vi
+            .spyOn(emulatorProcess, 'startDetachedProcess')
+            .mockReturnValue(child);
+        const startPromise = startEmulator('Pixel_8_API_35');
+        await vi.runAllTimersAsync();
+        await startPromise;
+        expect(startDetachedProcess).toHaveBeenCalledWith(expect.stringMatching(/emulator$/), expect.arrayContaining(['-no-snapshot-load', '-no-snapshot-save']));
+    });
+    it('passes clean snapshot generation args to the emulator process', async () => {
+        vi.useFakeTimers();
+        const child = createMockChildProcess();
+        vi.spyOn(tools, 'spawn')
+            .mockResolvedValueOnce({
+            stdout: 'List of devices attached\nemulator-5554\tdevice\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: 'Pixel_8_API_35\n',
+        });
+        const startDetachedProcess = vi
+            .spyOn(emulatorProcess, 'startDetachedProcess')
+            .mockReturnValue(child);
+        const startPromise = startEmulator('Pixel_8_API_35', 'clean-snapshot-generation');
+        await vi.runAllTimersAsync();
+        await startPromise;
+        expect(startDetachedProcess).toHaveBeenCalledWith(expect.stringMatching(/emulator$/), expect.arrayContaining(['-no-snapshot-load']));
+        expect(startDetachedProcess.mock.calls[0]?.[1]).not.toContain('-no-snapshot-save');
+    });
+    it('passes snapshot reuse args to the emulator process', async () => {
+        vi.useFakeTimers();
+        const child = createMockChildProcess();
+        vi.spyOn(tools, 'spawn')
+            .mockResolvedValueOnce({
+            stdout: 'List of devices attached\nemulator-5554\tdevice\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: 'Pixel_8_API_35\n',
+        });
+        const startDetachedProcess = vi
+            .spyOn(emulatorProcess, 'startDetachedProcess')
+            .mockReturnValue(child);
+        const startPromise = startEmulator('Pixel_8_API_35', 'snapshot-reuse');
+        await vi.runAllTimersAsync();
+        await startPromise;
+        expect(startDetachedProcess).toHaveBeenCalledWith(expect.stringMatching(/emulator$/), expect.arrayContaining(['-no-snapshot-save']));
+        expect(startDetachedProcess.mock.calls[0]?.[1]).not.toContain('-no-snapshot-load');
+    });
+    it('aborts while waiting for an emulator to boot', async () => {
+        vi.useFakeTimers();
+        vi.spyOn(tools, 'spawn').mockResolvedValue({
+            stdout: 'List of devices attached\n\n',
+        });
+        const controller = new AbortController();
+        const waitPromise = waitForBoot('Pixel_8_API_35', controller.signal);
+        await vi.advanceTimersByTimeAsync(1000);
+        controller.abort(createAbortError());
+        await expect(waitPromise).rejects.toBeInstanceOf(DOMException);
+    });
+    it('aborts while waiting for boot completion', async () => {
+        vi.useFakeTimers();
+        const spawnSpy = vi.spyOn(tools, 'spawn');
+        spawnSpy
+            .mockResolvedValueOnce({
+            stdout: 'List of devices attached\nemulator-5554\tdevice\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: 'Pixel_8_API_35\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: '0\n',
+        });
+        const controller = new AbortController();
+        const waitPromise = waitForBoot('Pixel_8_API_35', controller.signal);
+        await vi.advanceTimersByTimeAsync(1000);
+        controller.abort(createAbortError());
+        await expect(waitPromise).rejects.toBeInstanceOf(DOMException);
+    });
+    it('treats transient adb shell failures as not-yet-booted', async () => {
+        vi.useFakeTimers();
+        const spawnSpy = vi.spyOn(tools, 'spawn');
+        const transientShellError = Object.assign(new Error('adb shell failed'), {
+            exitCode: 1,
+        });
+        Object.setPrototypeOf(transientShellError, SubprocessError.prototype);
+        spawnSpy
+            .mockResolvedValueOnce({
+            stdout: 'List of devices attached\nemulator-5554\tdevice\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: 'Pixel_8_API_35\n',
+        })
+            .mockRejectedValueOnce(transientShellError)
+            .mockResolvedValueOnce({
+            stdout: 'List of devices attached\nemulator-5554\tdevice\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: 'Pixel_8_API_35\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: '1\n',
+        });
+        const waitPromise = waitForBoot('Pixel_8_API_35', new AbortController().signal);
+        await vi.advanceTimersByTimeAsync(1000);
+        await expect(waitPromise).resolves.toBe('emulator-5554');
+        expect(spawnSpy).toHaveBeenCalledTimes(6);
+    });
+    it('waits for an emulator to disconnect from adb', async () => {
+        vi.useFakeTimers();
+        const spawnSpy = vi.spyOn(tools, 'spawn');
+        spawnSpy
+            .mockResolvedValueOnce({
+            stdout: 'List of devices attached\nemulator-5554\tdevice\n',
+        })
+            .mockResolvedValueOnce({
+            stdout: 'List of devices attached\n\n',
+        });
+        const waitPromise = waitForEmulatorDisconnect('emulator-5554', new AbortController().signal);
+        await vi.advanceTimersByTimeAsync(1000);
+        await expect(waitPromise).resolves.toBeUndefined();
+        expect(spawnSpy).toHaveBeenCalledTimes(2);
+    });
 });

package/dist/__tests__/avd-config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=avd-config.test.d.ts.map

package/dist/__tests__/avd-config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avd-config.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/avd-config.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/avd-config.test.js

@@ -0,0 +1,174 @@
+import { describe, expect, it } from 'vitest';
+import { getNormalizedAvdCacheConfig, isAvdCompatible, parseAvdConfig, resolveAvdCachingEnabled, } from '../avd-config.js';
+import { AndroidPlatformConfigSchema } from '../config.js';
+describe('AVD config helpers', () => {
+    it('parses snapshot config from Android schema', () => {
+        const config = AndroidPlatformConfigSchema.parse({
+            name: 'android',
+            bundleId: 'com.example.app',
+            device: {
+                type: 'emulator',
+                name: 'Pixel_8_API_35',
+                avd: {
+                    apiLevel: 35,
+                    profile: 'pixel_8',
+                    diskSize: '1G',
+                    heapSize: '512M',
+                    snapshot: {
+                        enabled: true,
+                    },
+                },
+            },
+        });
+        expect(config.device.type).toBe('emulator');
+        if (config.device.type === 'emulator') {
+            expect(config.device.avd?.snapshot?.enabled).toBe(true);
+        }
+    });
+    it('lets HARNESS_AVD_CACHING override config before interactive gating', () => {
+        expect(resolveAvdCachingEnabled({
+            avd: {
+                apiLevel: 35,
+                profile: 'pixel_8',
+                diskSize: '1G',
+                heapSize: '1G',
+                snapshot: { enabled: false },
+            },
+            isInteractive: false,
+            env: {
+                HARNESS_AVD_CACHING: 'true',
+            },
+        })).toBe(true);
+    });
+    it('disables caching for interactive sessions even when requested', () => {
+        expect(resolveAvdCachingEnabled({
+            avd: {
+                apiLevel: 35,
+                profile: 'pixel_8',
+                diskSize: '1G',
+                heapSize: '1G',
+                snapshot: { enabled: true },
+            },
+            isInteractive: true,
+        })).toBe(false);
+    });
+    it('parses config.ini and matches compatible AVD metadata', () => {
+        const avdConfig = parseAvdConfig(`
+image.sysdir.1=system-images/android-35/default/x86_64/
+abi.type=x86_64
+hw.device.name=pixel_8
+disk.dataPartition.size=1G
+vm.heapSize=512M
+`);
+        expect(isAvdCompatible({
+            emulator: {
+                type: 'emulator',
+                name: 'Pixel_8_API_35',
+                avd: {
+                    apiLevel: 35,
+                    profile: 'pixel_8',
+                    diskSize: '1G',
+                    heapSize: '512M',
+                },
+            },
+            avdConfig,
+            hostArch: 'x86_64',
+        })).toEqual({ compatible: true });
+    });
+    it('accepts disk partition sizes rewritten to bytes', () => {
+        const avdConfig = parseAvdConfig(`
+image.sysdir.1=system-images/android-35/default/x86_64/
+abi.type=x86_64
+hw.device.name=pixel_8
+disk.dataPartition.size=6442450944
+vm.heapSize=512M
+`);
+        expect(isAvdCompatible({
+            emulator: {
+                type: 'emulator',
+                name: 'Pixel_8_API_35',
+                avd: {
+                    apiLevel: 35,
+                    profile: 'pixel_8',
+                    diskSize: '1G',
+                    heapSize: '512M',
+                },
+            },
+            avdConfig,
+            hostArch: 'x86_64',
+        })).toEqual({ compatible: true });
+    });
+    it('rejects smaller disk partitions even when sizes are normalized', () => {
+        const avdConfig = parseAvdConfig(`
+image.sysdir.1=system-images/android-35/default/x86_64/
+abi.type=x86_64
+hw.device.name=pixel_8
+disk.dataPartition.size=536870912
+vm.heapSize=512M
+`);
+        expect(isAvdCompatible({
+            emulator: {
+                type: 'emulator',
+                name: 'Pixel_8_API_35',
+                avd: {
+                    apiLevel: 35,
+                    profile: 'pixel_8',
+                    diskSize: '1G',
+                    heapSize: '512M',
+                },
+            },
+            avdConfig,
+            hostArch: 'x86_64',
+        })).toMatchObject({
+            compatible: false,
+            reason: 'Disk size mismatch: expected 1G, got 536870912.',
+        });
+    });
+    it('reports incompatibility when AVD metadata differs', () => {
+        const avdConfig = parseAvdConfig(`
+image.sysdir.1=system-images/android-34/default/x86_64/
+abi.type=x86_64
+hw.device.name=pixel_7
+disk.dataPartition.size=2G
+vm.heapSize=1G
+`);
+        expect(isAvdCompatible({
+            emulator: {
+                type: 'emulator',
+                name: 'Pixel_8_API_35',
+                avd: {
+                    apiLevel: 35,
+                    profile: 'pixel_8',
+                    diskSize: '1G',
+                    heapSize: '512M',
+                },
+            },
+            avdConfig,
+            hostArch: 'x86_64',
+        })).toMatchObject({
+            compatible: false,
+        });
+    });
+    it('normalizes AVD cache key input with name and host arch', () => {
+        expect(getNormalizedAvdCacheConfig({
+            emulator: {
+                type: 'emulator',
+                name: 'Pixel_8_API_35',
+                avd: {
+                    apiLevel: 35,
+                    profile: ' Pixel_8 ',
+                    diskSize: '1G',
+                    heapSize: '512M',
+                },
+            },
+            hostArch: 'arm64-v8a',
+        })).toEqual({
+            name: 'Pixel_8_API_35',
+            apiLevel: 35,
+            arch: 'arm64-v8a',
+            profile: 'pixel_8',
+            diskSize: '1g',
+            heapSize: '512m',
+        });
+    });
+});

package/dist/__tests__/ci-action.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ci-action.test.d.ts.map

package/dist/__tests__/ci-action.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ci-action.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/ci-action.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/ci-action.test.js

@@ -0,0 +1,46 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+const workspaceRoot = path.resolve(import.meta.dirname, '../../../..');
+describe('Android GitHub action config', () => {
+    it('does not duplicate Android SDK verification in the action YAML', async () => {
+        const [rootAction, packageAction] = await Promise.all([
+            readFile(path.join(workspaceRoot, 'action.yml'), 'utf8'),
+            readFile(path.join(workspaceRoot, 'packages/github-action/src/action.yml'), 'utf8'),
+        ]);
+        for (const actionYaml of [rootAction, packageAction]) {
+            expect(actionYaml).not.toContain('Verify Android SDK packages');
+            expect(actionYaml).toContain("steps.avd-cache.outputs.cache-hit != 'true'");
+        }
+    });
+    it('removes the third-party emulator runner and maps cacheAvd to HARNESS_AVD_CACHING', async () => {
+        const [rootAction, packageAction] = await Promise.all([
+            readFile(path.join(workspaceRoot, 'action.yml'), 'utf8'),
+            readFile(path.join(workspaceRoot, 'packages/github-action/src/action.yml'), 'utf8'),
+        ]);
+        for (const actionYaml of [rootAction, packageAction]) {
+            expect(actionYaml).not.toContain('reactivecircus/android-emulator-runner');
+            expect(actionYaml).toContain('HARNESS_AVD_CACHING: ${{ inputs.cacheAvd }}');
+            expect(actionYaml).toContain('fromJson(steps.load-config.outputs.config).action.avdCachingEnabled');
+        }
+    });
+    it('saves the AVD cache after the Harness run step', async () => {
+        const [rootAction, packageAction] = await Promise.all([
+            readFile(path.join(workspaceRoot, 'action.yml'), 'utf8'),
+            readFile(path.join(workspaceRoot, 'packages/github-action/src/action.yml'), 'utf8'),
+        ]);
+        for (const actionYaml of [rootAction, packageAction]) {
+            expect(actionYaml.indexOf('- name: Run E2E tests')).toBeLessThan(actionYaml.indexOf('- name: Save AVD cache'));
+        }
+    });
+    it('uses a cache key that includes the emulator name', async () => {
+        const [rootAction, packageAction] = await Promise.all([
+            readFile(path.join(workspaceRoot, 'action.yml'), 'utf8'),
+            readFile(path.join(workspaceRoot, 'packages/github-action/src/action.yml'), 'utf8'),
+        ]);
+        for (const actionYaml of [rootAction, packageAction]) {
+            expect(actionYaml).toContain("AVD_NAME='${{ fromJson(steps.load-config.outputs.config).config.device.name }}'");
+            expect(actionYaml).toContain('CACHE_KEY="avd-$AVD_NAME-$ARCH-$AVD_CONFIG_HASH"');
+        }
+    });
+});

package/dist/__tests__/emulator-startup.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=emulator-startup.test.d.ts.map

package/dist/__tests__/emulator-startup.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emulator-startup.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/emulator-startup.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/emulator-startup.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { getEmulatorStartupArgs } from '../emulator-startup.js';
+describe('emulator startup modes', () => {
+    it('builds default boot args', () => {
+        expect(getEmulatorStartupArgs('Pixel_8_API_35', 'default-boot')).toEqual(expect.arrayContaining([
+            '@Pixel_8_API_35',
+            '-no-snapshot-load',
+            '-no-snapshot-save',
+        ]));
+    });
+    it('builds clean snapshot generation args', () => {
+        expect(getEmulatorStartupArgs('Pixel_8_API_35', 'clean-snapshot-generation')).toEqual(expect.arrayContaining(['@Pixel_8_API_35', '-no-snapshot-load']));
+        expect(getEmulatorStartupArgs('Pixel_8_API_35', 'clean-snapshot-generation')).not.toContain('-no-snapshot-save');
+    });
+    it('builds snapshot reuse args', () => {
+        expect(getEmulatorStartupArgs('Pixel_8_API_35', 'snapshot-reuse')).toEqual(expect.arrayContaining(['@Pixel_8_API_35', '-no-snapshot-save']));
+        expect(getEmulatorStartupArgs('Pixel_8_API_35', 'snapshot-reuse')).not.toContain('-no-snapshot-load');
+    });
+});

package/dist/__tests__/environment.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=environment.test.d.ts.map

package/dist/__tests__/environment.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/environment.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/environment.test.js

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getAndroidSdkRoot, getAndroidSystemImagePackage, getDefaultUnixAndroidSdkRoot, getHostAndroidSystemImageArch, getRequiredAndroidSdkPackages, } from '../environment.js';
+describe('Android environment', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        vi.unstubAllEnvs();
+    });
+    it('uses the default Unix SDK root when env vars are missing', () => {
+        expect(getDefaultUnixAndroidSdkRoot({
+            platform: 'darwin',
+            homeDirectory: '/Users/tester',
+        })).toBe('/Users/tester/Library/Android/sdk');
+        expect(getAndroidSdkRoot({}, {
+            platform: 'linux',
+            homeDirectory: '/home/tester',
+        })).toBe('/home/tester/Android/Sdk');
+    });
+    it('prefers ANDROID_HOME and ANDROID_SDK_ROOT over default paths', () => {
+        expect(getAndroidSdkRoot({
+            ANDROID_HOME: '/env/android-home',
+            ANDROID_SDK_ROOT: '/env/android-sdk-root',
+        }, {
+            platform: 'darwin',
+            homeDirectory: '/Users/tester',
+        })).toBe('/env/android-home');
+        expect(getAndroidSdkRoot({
+            ANDROID_SDK_ROOT: '/env/android-sdk-root',
+        }, {
+            platform: 'linux',
+            homeDirectory: '/home/tester',
+        })).toBe('/env/android-sdk-root');
+    });
+    it('selects Android packages using the host architecture', () => {
+        expect(getHostAndroidSystemImageArch('x64')).toBe('x86_64');
+        expect(getHostAndroidSystemImageArch('arm64')).toBe('arm64-v8a');
+        expect(getAndroidSystemImagePackage(35, 'x86_64')).toBe('system-images;android-35;default;x86_64');
+        expect(getAndroidSystemImagePackage(35, 'arm64-v8a')).toBe('system-images;android-35;default;arm64-v8a');
+    });
+    it('derives emulator package requirements from runner config fields', () => {
+        expect(getRequiredAndroidSdkPackages({
+            apiLevel: 34,
+            includeEmulator: true,
+            architecture: 'x86_64',
+        })).toEqual([
+            'platform-tools',
+            'emulator',
+            'platforms;android-34',
+            'system-images;android-34;default;x86_64',
+        ]);
+    });
+});

package/dist/__tests__/instance.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=instance.test.d.ts.map