@samsara-dev/appwright 0.7.2 → 0.7.3

package/dist/providers/awsDeviceFarm/index.spec.js

@@ -0,0 +1,801 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const index_1 = require("./index");
+const fs = __importStar(require("fs"));
+const logger_1 = require("../../logger");
+//@ts-ignore
+const client_device_farm_1 = require("@aws-sdk/client-device-farm");
+// Helper function to cast test project to expected type
+const asProject = (project) => project;
+// Create a mock fetch function
+const mockFetch = vitest_1.vi.fn();
+vitest_1.vi.stubGlobal("fetch", mockFetch);
+// Mock utils module
+vitest_1.vi.mock("../../utils", async () => {
+    const actual = await vitest_1.vi.importActual("../../utils");
+    return {
+        ...actual,
+        validateBuildPath: vitest_1.vi.fn(),
+    };
+});
+// Mock async-retry
+vitest_1.vi.mock("async-retry", () => ({
+    default: vitest_1.vi.fn((fn) => fn()),
+}));
+// Mock node-fetch
+vitest_1.vi.mock("node-fetch", () => ({
+    default: mockFetch,
+}));
+// Mock stream/promises pipeline
+vitest_1.vi.mock("stream/promises", () => ({
+    pipeline: vitest_1.vi.fn().mockResolvedValue(undefined),
+}));
+// Mock webdriver
+vitest_1.vi.mock("webdriver", () => ({
+    default: {
+        newSession: vitest_1.vi.fn().mockResolvedValue({
+            sessionId: "test-session-id",
+        }),
+    },
+}));
+// Mock AWS SDK
+vitest_1.vi.mock("@aws-sdk/client-device-farm", () => {
+    const mockDeviceFarmClient = vitest_1.vi.fn();
+    mockDeviceFarmClient.prototype.send = vitest_1.vi.fn();
+    // Create mock command constructors that store their input
+    const mockCommandConstructors = {};
+    const createMockCommand = (name) => {
+        const mockConstructor = vitest_1.vi.fn((input) => {
+            const command = { input, constructor: { name } };
+            // Add the constructor as a property for instanceof checks
+            Object.defineProperty(command, "constructor", {
+                value: mockCommandConstructors[name],
+                writable: false,
+                enumerable: false,
+                configurable: true,
+            });
+            return command;
+        });
+        mockCommandConstructors[name] = mockConstructor;
+        return mockConstructor;
+    };
+    const commands = {
+        CreateUploadCommand: createMockCommand("CreateUploadCommand"),
+        GetUploadCommand: createMockCommand("GetUploadCommand"),
+        CreateRemoteAccessSessionCommand: createMockCommand("CreateRemoteAccessSessionCommand"),
+        GetRemoteAccessSessionCommand: createMockCommand("GetRemoteAccessSessionCommand"),
+        StopRemoteAccessSessionCommand: createMockCommand("StopRemoteAccessSessionCommand"),
+        ListArtifactsCommand: createMockCommand("ListArtifactsCommand"),
+    };
+    return {
+        DeviceFarmClient: mockDeviceFarmClient,
+        UploadStatus: {
+            FAILED: "FAILED",
+            SUCCEEDED: "SUCCEEDED",
+            INITIALIZED: "INITIALIZED",
+            PROCESSING: "PROCESSING",
+        },
+        ...commands,
+    };
+});
+// Mock AWS STS SDK
+vitest_1.vi.mock("@aws-sdk/client-sts", () => {
+    const mockSTSClientClass = vitest_1.vi.fn();
+    mockSTSClientClass.prototype.send = vitest_1.vi.fn();
+    mockSTSClientClass.prototype.destroy = vitest_1.vi.fn();
+    const mockAssumeRoleCommand = vitest_1.vi.fn((input) => ({
+        input,
+        constructor: { name: "AssumeRoleCommand" },
+    }));
+    return {
+        STSClient: mockSTSClientClass,
+        AssumeRoleCommand: mockAssumeRoleCommand,
+    };
+});
+// Mock fs
+vitest_1.vi.mock("fs", () => {
+    const mockFs = {
+        createReadStream: vitest_1.vi.fn(),
+        statSync: vitest_1.vi.fn(),
+        existsSync: vitest_1.vi.fn(),
+        mkdirSync: vitest_1.vi.fn(),
+        createWriteStream: vitest_1.vi.fn(),
+        renameSync: vitest_1.vi.fn(),
+        unlinkSync: vitest_1.vi.fn(),
+        rmSync: vitest_1.vi.fn(),
+    };
+    return {
+        default: mockFs,
+        ...mockFs,
+    };
+});
+(0, vitest_1.describe)("AWSDeviceFarmProvider", () => {
+    let provider;
+    let mockClient;
+    (0, vitest_1.beforeEach)(() => {
+        // Reset all mocks
+        vitest_1.vi.clearAllMocks();
+        mockFetch.mockReset();
+        // Setup mock client with send method
+        mockClient = {
+            send: vitest_1.vi.fn(),
+            destroy: vitest_1.vi.fn(),
+        };
+        vitest_1.vi.mocked(client_device_farm_1.DeviceFarmClient).mockImplementation(() => mockClient);
+        // Default fs mocks - use the default export since that's what the provider uses
+        const fsModule = fs;
+        const fsDefault = fsModule.default || fs;
+        vitest_1.vi.mocked(fsDefault.existsSync).mockReturnValue(true);
+        vitest_1.vi.mocked(fsDefault.statSync).mockReturnValue({ size: 1024 });
+        vitest_1.vi.mocked(fsDefault.createReadStream).mockReturnValue({});
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        mockFetch.mockReset();
+    });
+    (0, vitest_1.describe)("Constructor & Setup", () => {
+        (0, vitest_1.test)("validates required fields (projectArn, deviceArn, platform)", () => {
+            // Missing projectArn
+            (0, vitest_1.expect)(() => {
+                const project = {
+                    name: "test-project",
+                    use: {
+                        device: {
+                            deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        },
+                        platform: "android",
+                    },
+                };
+                new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            }).toThrow("AWS Device Farm: `projectArn` is required in the device configuration.");
+            // Missing deviceArn
+            (0, vitest_1.expect)(() => {
+                const project = {
+                    name: "test-project",
+                    use: {
+                        device: {
+                            projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        },
+                        platform: "android",
+                    },
+                };
+                new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            }).toThrow("AWS Device Farm: `deviceArn` is required in the device configuration.");
+            // Missing platform
+            (0, vitest_1.expect)(() => {
+                const project = {
+                    name: "test-project",
+                    use: {
+                        device: {
+                            projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                            deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        },
+                    },
+                };
+                new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            }).toThrow("AWS Device Farm: `platform` must be specified in the project configuration.");
+            // Valid configuration
+            (0, vitest_1.expect)(() => {
+                const project = {
+                    name: "test-project",
+                    use: {
+                        device: {
+                            projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                            deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        },
+                        platform: "android",
+                    },
+                };
+                new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            }).not.toThrow();
+        });
+        (0, vitest_1.test)("globalSetup uses existing appArn when provided", async () => {
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        appArn: "arn:aws:devicefarm:upload:existing",
+                    },
+                    platform: "ios",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            await provider.globalSetup();
+            // Should not create upload or upload file
+            (0, vitest_1.expect)(mockClient.send).not.toHaveBeenCalled();
+            (0, vitest_1.expect)(mockFetch).not.toHaveBeenCalled();
+        });
+        (0, vitest_1.test)("uses explicit appArn from config without globalSetup", async () => {
+            // This test simulates a runtime provider that doesn't call globalSetup
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        appArn: "arn:aws:devicefarm:upload:explicit-arn",
+                    },
+                    platform: "ios",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            // The provider should have uploadArn set from config even without globalSetup
+            (0, vitest_1.expect)(provider.uploadArn).toBe("arn:aws:devicefarm:upload:explicit-arn");
+            // Mock session creation to verify appArn is passed correctly
+            mockClient.send
+                .mockResolvedValueOnce({
+                remoteAccessSession: { arn: "arn:aws:devicefarm:session:123" },
+            })
+                .mockResolvedValueOnce({
+                remoteAccessSession: {
+                    arn: "arn:aws:devicefarm:session:123",
+                    status: "RUNNING",
+                    endpoint: "wss://device.example.com",
+                    device: { name: "iPhone 14", os: "16.0" },
+                },
+            });
+            // Create remote session without calling globalSetup
+            await provider.createRemoteSession();
+            // Verify that createRemoteSession used the appArn from config
+            const createSessionCall = mockClient.send.mock.calls[0][0];
+            (0, vitest_1.expect)(createSessionCall.input.appArn).toBe("arn:aws:devicefarm:upload:explicit-arn");
+        });
+        (0, vitest_1.test)("persists upload ARN across provider instances", async () => {
+            // Clean up any existing env var
+            delete process.env.AWS_DEVICE_FARM_APP_ARN_TEST_PROJECT;
+            // First provider instance (simulates globalSetup)
+            const project1 = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                    },
+                    platform: "android",
+                    buildPath: "/path/to/app.apk",
+                },
+            };
+            const provider1 = new index_1.AWSDeviceFarmProvider(asProject(project1), "com.example.app");
+            // Simulate globalSetup storing the ARN
+            provider1.uploadArn =
+                "arn:aws:devicefarm:upload:123";
+            process.env.AWS_DEVICE_FARM_APP_ARN_TEST_PROJECT =
+                "arn:aws:devicefarm:upload:123";
+            // Second provider instance (simulates fixture creation)
+            // IMPORTANT: This has the same buildPath as the first instance
+            // This is the typical scenario - same config for all instances
+            const project2 = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                    },
+                    platform: "android",
+                    buildPath: "/path/to/app.apk", // Same buildPath as first instance
+                },
+            };
+            const provider2 = new index_1.AWSDeviceFarmProvider(asProject(project2), "com.example.app");
+            // The constructor should have loaded the ARN from env var
+            // even though buildPath is provided
+            (0, vitest_1.expect)(provider2.uploadArn).toBe("arn:aws:devicefarm:upload:123");
+            // Mock session creation
+            mockClient.send
+                .mockResolvedValueOnce({
+                remoteAccessSession: { arn: "arn:aws:devicefarm:session:123" },
+            })
+                .mockResolvedValueOnce({
+                remoteAccessSession: {
+                    arn: "arn:aws:devicefarm:session:123",
+                    status: "RUNNING",
+                    endpoint: "wss://device.example.com",
+                    device: { name: "Pixel 6", os: "12" },
+                },
+            });
+            // Create remote session with second provider
+            await provider2.createRemoteSession();
+            // Verify that the second provider used the uploaded ARN from the first provider
+            (0, vitest_1.expect)(mockClient.send).toHaveBeenCalled();
+            // Check that the CreateRemoteAccessSessionCommand was called with the correct appArn
+            const createSessionCall = mockClient.send.mock.calls[0][0];
+            (0, vitest_1.expect)(createSessionCall.input).toBeDefined();
+            (0, vitest_1.expect)(createSessionCall.input.appArn).toBe("arn:aws:devicefarm:upload:123");
+            // Also verify the other expected properties
+            (0, vitest_1.expect)(createSessionCall.input.projectArn).toBe("arn:aws:devicefarm:us-west-2:123:project:456");
+            (0, vitest_1.expect)(createSessionCall.input.deviceArn).toBe("arn:aws:devicefarm:us-west-2::device:123");
+            // Clean up
+            delete process.env.AWS_DEVICE_FARM_APP_ARN_TEST_PROJECT;
+        });
+    });
+    (0, vitest_1.describe)("Session Management", () => {
+        (0, vitest_1.beforeEach)(() => {
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        appArn: "arn:aws:devicefarm:upload:123",
+                    },
+                    platform: "android",
+                    expectTimeout: 30000,
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+        });
+        (0, vitest_1.test)("creates and starts remote session successfully", async () => {
+            const mockSession = {
+                arn: "arn:aws:devicefarm:session:123",
+                status: "RUNNING",
+                endpoint: "wss://device.example.com",
+                device: {
+                    name: "Pixel 6",
+                    os: "12",
+                },
+            };
+            // Mock session creation - returns ARN
+            mockClient.send.mockResolvedValueOnce({
+                remoteAccessSession: { arn: "arn:aws:devicefarm:session:123" },
+            });
+            // Mock session status check - returns RUNNING session
+            mockClient.send.mockResolvedValueOnce({
+                remoteAccessSession: mockSession,
+            });
+            const session = await provider.createRemoteSession();
+            (0, vitest_1.expect)(session).toEqual(mockSession);
+            (0, vitest_1.expect)(mockClient.send).toHaveBeenCalled();
+            const createSessionCall = mockClient.send.mock.calls[0][0];
+            (0, vitest_1.expect)(createSessionCall.input.projectArn).toBe("arn:aws:devicefarm:us-west-2:123:project:456");
+            (0, vitest_1.expect)(createSessionCall.input.deviceArn).toBe("arn:aws:devicefarm:us-west-2::device:123");
+        });
+        (0, vitest_1.test)("handles query parameters in endpoint correctly", async () => {
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        appArn: "arn:aws:devicefarm:upload:123",
+                    },
+                    platform: "android",
+                    expectTimeout: 30000,
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            // Mock session with query parameters in endpoint
+            mockClient.send
+                .mockResolvedValueOnce({
+                remoteAccessSession: { arn: "arn:aws:devicefarm:session:123" },
+            })
+                .mockResolvedValueOnce({
+                remoteAccessSession: {
+                    arn: "arn:aws:devicefarm:session:123",
+                    status: "RUNNING",
+                    endpoint: "wss://device.example.com/wd/hub?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=test&X-Amz-Date=20250101T000000Z&X-Amz-Expires=3600&X-Amz-SignedHeaders=host&X-Amz-Signature=abc123",
+                    device: { name: "Pixel 6", os: "12" },
+                },
+            });
+            // Mock WebDriver
+            const mockWebDriver = (await import("webdriver")).default;
+            const mockNewSession = vitest_1.vi.fn().mockResolvedValue({
+                sessionId: "mock-session-id",
+            });
+            vitest_1.vi.mocked(mockWebDriver.newSession).mockImplementation(mockNewSession);
+            await provider.getDevice();
+            // Verify WebDriver was called with correct connection options
+            (0, vitest_1.expect)(mockNewSession).toHaveBeenCalledWith(vitest_1.expect.objectContaining({
+                protocol: "https",
+                hostname: "device.example.com",
+                port: 443,
+                path: "/wd/hub", // Path should NOT include query parameters
+                queryParams: {
+                    "X-Amz-Algorithm": "AWS4-HMAC-SHA256",
+                    "X-Amz-Credential": "test",
+                    "X-Amz-Date": "20250101T000000Z",
+                    "X-Amz-Expires": "3600",
+                    "X-Amz-SignedHeaders": "host",
+                    "X-Amz-Signature": "abc123",
+                },
+            }));
+        });
+        (0, vitest_1.test)("builds correct capabilities for Android/iOS", async () => {
+            // Android
+            const androidProject = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        appArn: "arn:aws:devicefarm:upload:123",
+                    },
+                    platform: "android",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(androidProject), "com.example.app");
+            const androidCaps = provider.buildCapabilities({
+                device: { name: "Pixel 6", os: "12" },
+            });
+            (0, vitest_1.expect)(androidCaps.platformName).toBe("Android");
+            (0, vitest_1.expect)(androidCaps["appium:automationName"]).toBe("UiAutomator2");
+            (0, vitest_1.expect)(androidCaps["appium:deviceName"]).toBe("Pixel 6");
+            (0, vitest_1.expect)(androidCaps["appium:platformVersion"]).toBe("12");
+            (0, vitest_1.expect)(androidCaps["appium:bundleId"]).toBeUndefined();
+            // Should include app capability with the upload ARN
+            (0, vitest_1.expect)(androidCaps["appium:app"]).toBe("arn:aws:devicefarm:upload:123");
+            // iOS
+            const iosProject = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        appArn: "arn:aws:devicefarm:upload:123",
+                    },
+                    platform: "ios",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(iosProject), "com.example.app");
+            const iosCaps = provider.buildCapabilities({
+                device: { name: "iPhone 14", os: "16.0" },
+            });
+            (0, vitest_1.expect)(iosCaps.platformName).toBe("iOS");
+            (0, vitest_1.expect)(iosCaps["appium:automationName"]).toBe("XCUITest");
+            (0, vitest_1.expect)(iosCaps["appium:deviceName"]).toBe("iPhone 14");
+            (0, vitest_1.expect)(iosCaps["appium:platformVersion"]).toBe("16.0");
+            (0, vitest_1.expect)(iosCaps["appium:bundleId"]).toBe("com.example.app");
+            // Should include app capability with the upload ARN
+            (0, vitest_1.expect)(iosCaps["appium:app"]).toBe("arn:aws:devicefarm:upload:123");
+        });
+        (0, vitest_1.test)("includes app capability for Android without appPackage/appActivity", async () => {
+            // This tests the main bug scenario - user provides buildPath only
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        appArn: "arn:aws:devicefarm:upload:android-app",
+                        // No appPackage or appActivity provided
+                    },
+                    platform: "android",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), undefined);
+            const caps = provider.buildCapabilities({
+                device: { name: "Pixel 6", os: "12" },
+            });
+            // Must include app capability for Appium to work
+            (0, vitest_1.expect)(caps["appium:app"]).toBe("arn:aws:devicefarm:upload:android-app");
+            (0, vitest_1.expect)(caps["appium:appPackage"]).toBeUndefined();
+            (0, vitest_1.expect)(caps["appium:appActivity"]).toBeUndefined();
+        });
+        (0, vitest_1.test)("stops session on cleanup", async () => {
+            provider.remoteSessionArn =
+                "arn:aws:devicefarm:session:123";
+            mockClient.send.mockResolvedValueOnce({});
+            await provider.stopRemoteSession();
+            (0, vitest_1.expect)(mockClient.send).toHaveBeenCalled();
+            const stopSessionCall = mockClient.send.mock.calls[0][0];
+            (0, vitest_1.expect)(stopSessionCall.input.arn).toBe("arn:aws:devicefarm:session:123");
+        });
+        (0, vitest_1.test)("stops remote session when WebDriver.newSession fails", async () => {
+            // Mock successful remote session creation
+            mockClient.send
+                .mockResolvedValueOnce({
+                remoteAccessSession: { arn: "arn:aws:devicefarm:session:123" },
+            })
+                .mockResolvedValueOnce({
+                remoteAccessSession: {
+                    arn: "arn:aws:devicefarm:session:123",
+                    status: "RUNNING",
+                    endpoint: "wss://device.example.com",
+                    device: { name: "Pixel 6", os: "12" },
+                },
+            });
+            // Mock WebDriver.newSession to fail
+            const mockWebDriver = (await import("webdriver")).default;
+            vitest_1.vi.mocked(mockWebDriver.newSession).mockRejectedValueOnce(new Error("Invalid capabilities: bad automation name"));
+            // Mock stopRemoteSession to verify it's called
+            mockClient.send.mockResolvedValueOnce({}); // for StopRemoteAccessSessionCommand
+            // Attempt to get device should throw
+            await (0, vitest_1.expect)(provider.getDevice()).rejects.toThrow("Invalid capabilities: bad automation name");
+            // Verify that stopRemoteSession was called to clean up
+            (0, vitest_1.expect)(mockClient.send).toHaveBeenCalledTimes(3); // create, get, stop
+            const stopSessionCall = mockClient.send.mock.calls[2][0];
+            (0, vitest_1.expect)(stopSessionCall.input.arn).toBe("arn:aws:devicefarm:session:123");
+        });
+    });
+    (0, vitest_1.describe)("Error Handling", () => {
+        (0, vitest_1.test)("throws error when both buildPath and appArn missing", async () => {
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                    },
+                    platform: "android",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            await (0, vitest_1.expect)(provider.globalSetup()).rejects.toThrow("AWS Device Farm: Either provide `buildPath` or `appArn` in the configuration.");
+        });
+        (0, vitest_1.test)("handles session creation failure gracefully", async () => {
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                        appArn: "arn:aws:devicefarm:upload:123",
+                    },
+                    platform: "android",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            // Mock session creation returns empty response (no ARN)
+            mockClient.send.mockResolvedValueOnce({
+                remoteAccessSession: {},
+            });
+            await (0, vitest_1.expect)(provider.createRemoteSession()).rejects.toThrow("AWS Device Farm: Remote access session ARN was not returned.");
+        });
+        (0, vitest_1.test)("handles upload failure with proper error message", async () => {
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:123",
+                    },
+                    platform: "android",
+                    buildPath: "/path/to/app.apk",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            // Mock upload creation failure
+            mockClient.send.mockRejectedValueOnce(new Error("Upload creation failed"));
+            await (0, vitest_1.expect)(provider.globalSetup()).rejects.toThrow("Upload creation failed");
+        });
+    });
+    (0, vitest_1.describe)("Video Download", () => {
+        (0, vitest_1.test)("downloadVideo handles node-fetch v3 stream correctly", async () => {
+            const sessionArn = "arn:aws:devicefarm:us-west-2:123:session:456";
+            const outputDir = "/tmp/test-output";
+            const fileName = "test-video";
+            // Mock fs operations
+            const fsDefault = fs.default || fs;
+            vitest_1.vi.mocked(fsDefault.mkdirSync).mockReturnValue(undefined);
+            vitest_1.vi.mocked(fsDefault.existsSync).mockReturnValue(false);
+            // Create a mock writable stream
+            const mockWriteStream = {};
+            vitest_1.vi.mocked(fsDefault.createWriteStream).mockReturnValue(mockWriteStream);
+            vitest_1.vi.mocked(fsDefault.renameSync).mockReturnValue(undefined);
+            // Mock client to return video artifact
+            mockClient.send.mockResolvedValueOnce({
+                artifacts: [
+                    {
+                        type: "VIDEO",
+                        url: "https://presigned-url.example.com/video.mp4",
+                    },
+                ],
+            });
+            // Mock fetch to return a Node.js Readable stream (node-fetch v3 behavior)
+            const { Readable } = await import("stream");
+            const mockVideoData = Buffer.from("mock-video-content");
+            const mockStream = Readable.from([mockVideoData]);
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                body: mockStream, // This is a Node.js Readable, not a Web Stream with getReader()
+            });
+            // Mock the pipeline function
+            const { pipeline } = await import("stream/promises");
+            vitest_1.vi.mocked(pipeline).mockResolvedValueOnce(undefined);
+            // Call downloadVideo
+            const result = await index_1.AWSDeviceFarmProvider.downloadVideo(sessionArn, outputDir, fileName);
+            // Verify the video was downloaded successfully
+            (0, vitest_1.expect)(result).toEqual({
+                path: "/tmp/test-output/test-video.mp4",
+                contentType: "video/mp4",
+            });
+            // Verify fetch was called with the presigned URL
+            (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith("https://presigned-url.example.com/video.mp4", vitest_1.expect.objectContaining({ method: "GET" }));
+            // Verify the stream was written to the file using pipeline
+            (0, vitest_1.expect)(fsDefault.createWriteStream).toHaveBeenCalledWith("/tmp/test-output/test-video.mp4.part");
+            // Verify pipeline was called with the stream and write stream
+            (0, vitest_1.expect)(pipeline).toHaveBeenCalledWith(mockStream, mockWriteStream);
+        });
+        (0, vitest_1.test)("downloadVideo returns null when video artifact is not found", async () => {
+            const sessionArn = "arn:aws:devicefarm:us-west-2:123:session:456";
+            const outputDir = "/tmp/test-output";
+            const fileName = "test-video";
+            // Mock fs operations
+            const fsDefault = fs.default || fs;
+            vitest_1.vi.mocked(fsDefault.mkdirSync).mockReturnValue(undefined);
+            // Mock client to return no video artifacts
+            mockClient.send.mockResolvedValueOnce({
+                artifacts: [],
+            });
+            // Mock async-retry to throw error immediately instead of retrying
+            const retryModule = await import("async-retry");
+            vitest_1.vi.mocked(retryModule.default).mockImplementationOnce(((fn) => fn(() => { }, 1)));
+            // Mock logger to suppress error logs during test
+            const originalError = logger_1.logger.error;
+            logger_1.logger.error = vitest_1.vi.fn();
+            // Call downloadVideo
+            const result = await index_1.AWSDeviceFarmProvider.downloadVideo(sessionArn, outputDir, fileName);
+            // Restore logger.error
+            logger_1.logger.error = originalError;
+            // Should return null when no video found
+            (0, vitest_1.expect)(result).toBeNull();
+        });
+    });
+    (0, vitest_1.describe)("IAM Role Assumption", () => {
+        let mockStsClient;
+        let STSClientMock;
+        (0, vitest_1.beforeEach)(async () => {
+            // Get the mocked STS client
+            const stsModule = await import("@aws-sdk/client-sts");
+            STSClientMock = stsModule.STSClient;
+            mockStsClient = {
+                send: vitest_1.vi.fn(),
+                destroy: vitest_1.vi.fn(),
+            };
+            vitest_1.vi.mocked(STSClientMock).mockImplementation(() => mockStsClient);
+        });
+        (0, vitest_1.test)("assumes IAM role when roleArn is provided", async () => {
+            // Setup STS mock to return credentials
+            mockStsClient.send.mockResolvedValueOnce({
+                Credentials: {
+                    AccessKeyId: "AKIAIOSFODNN7EXAMPLE",
+                    SecretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+                    SessionToken: "FwoGZXIvYXdzEBY...",
+                },
+            });
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        provider: "aws-device-farm",
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:789",
+                        roleArn: "arn:aws:iam::123456789012:role/DeviceFarmAccess",
+                        roleSessionName: "test-session",
+                        externalId: "test-external-id",
+                    },
+                    platform: "android",
+                    buildPath: "/path/to/app.apk",
+                    appBundleId: "com.example.app",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            // Mock upload flow
+            mockClient.send
+                .mockResolvedValueOnce({
+                upload: {
+                    arn: "arn:aws:devicefarm:upload:123",
+                    url: "https://upload-url.example.com",
+                },
+            })
+                .mockResolvedValueOnce({
+                upload: { status: "SUCCEEDED" },
+            });
+            mockFetch.mockResolvedValueOnce({ ok: true });
+            await provider.globalSetup();
+            // Verify STS AssumeRole was called
+            (0, vitest_1.expect)(mockStsClient.send).toHaveBeenCalledTimes(1);
+            (0, vitest_1.expect)(mockStsClient.destroy).toHaveBeenCalled();
+            // Verify DeviceFarmClient was recreated (called twice - once in constructor, once after assume role)
+            (0, vitest_1.expect)(client_device_farm_1.DeviceFarmClient).toHaveBeenCalledTimes(2);
+            (0, vitest_1.expect)(client_device_farm_1.DeviceFarmClient).toHaveBeenLastCalledWith({
+                region: "us-west-2",
+                credentials: {
+                    accessKeyId: "AKIAIOSFODNN7EXAMPLE",
+                    secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+                    sessionToken: "FwoGZXIvYXdzEBY...",
+                },
+            });
+        });
+        (0, vitest_1.test)("uses default session name when roleSessionName not provided", async () => {
+            mockStsClient.send.mockResolvedValueOnce({
+                Credentials: {
+                    AccessKeyId: "AKIAIOSFODNN7EXAMPLE",
+                    SecretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+                    SessionToken: "FwoGZXIvYXdzEBY...",
+                },
+            });
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        provider: "aws-device-farm",
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:789",
+                        roleArn: "arn:aws:iam::123456789012:role/DeviceFarmAccess",
+                        appArn: "arn:aws:devicefarm:upload:existing",
+                        // No roleSessionName provided
+                    },
+                    platform: "android",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            await provider.globalSetup();
+            // Verify AssumeRoleCommand was called with default session name
+            const { AssumeRoleCommand } = await import("@aws-sdk/client-sts");
+            (0, vitest_1.expect)(AssumeRoleCommand).toHaveBeenCalledWith({
+                RoleArn: "arn:aws:iam::123456789012:role/DeviceFarmAccess",
+                RoleSessionName: "appwright-device-farm",
+                ExternalId: undefined,
+            });
+        });
+        (0, vitest_1.test)("throws error when AssumeRole returns incomplete credentials", async () => {
+            mockStsClient.send.mockResolvedValueOnce({
+                Credentials: {
+                    AccessKeyId: "AKIAIOSFODNN7EXAMPLE",
+                    // Missing SecretAccessKey and SessionToken
+                },
+            });
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        provider: "aws-device-farm",
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:789",
+                        roleArn: "arn:aws:iam::123456789012:role/DeviceFarmAccess",
+                        appArn: "arn:aws:devicefarm:upload:existing",
+                    },
+                    platform: "android",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            await (0, vitest_1.expect)(provider.globalSetup()).rejects.toThrow("AWS Device Farm: AssumeRole returned incomplete credentials.");
+        });
+        (0, vitest_1.test)("does not assume role when roleArn is not provided", async () => {
+            const project = {
+                name: "test-project",
+                use: {
+                    device: {
+                        provider: "aws-device-farm",
+                        projectArn: "arn:aws:devicefarm:us-west-2:123:project:456",
+                        deviceArn: "arn:aws:devicefarm:us-west-2::device:789",
+                        appArn: "arn:aws:devicefarm:upload:existing",
+                        // No roleArn
+                    },
+                    platform: "android",
+                },
+            };
+            provider = new index_1.AWSDeviceFarmProvider(asProject(project), "com.example.app");
+            await provider.globalSetup();
+            // Verify STS was never called
+            (0, vitest_1.expect)(mockStsClient.send).not.toHaveBeenCalled();
+            // Verify DeviceFarmClient was only created once (in constructor)
+            (0, vitest_1.expect)(client_device_farm_1.DeviceFarmClient).toHaveBeenCalledTimes(1);
+        });
+    });
+});