Multi-device interactive testing - How to test flows requiring 2+ devices?

[LucaL1fe]

Use case

Problem

I cannot find any documentation or solution for testing scenarios that require interaction between two devices.

My app is a simple messaging app (like WhatsApp for Parent and Children). Almost all my test flows require this pattern:

1. Device A (Parent) → Create an invitation code
2. Device B (Child) → Enter that invitation code
3. Device A (Parent) → Send message "Hello Sarah"
4. Device B (Child) → Verify message "Hello Sarah" was received

Every meaningful test in my app needs this: I do something on Device A, then verify the result on Device B.

What I've Found

• --shard-all / --shard-split → Runs same/split tests in parallel, but no communication between devices
• --driver-host-port → Allows running multiple Maestro instances, but no synchronization mechanism

Current Workaround (Painful)

The only solution I can think of is writing a huge orchestrator script in Python/Bash, splitting every single step into its own YAML file:

test_orchestrator.py
run_test("device1", "01_create_invitation.yaml")
code = read_file("/tmp/code.txt")
write_file("/tmp/code.txt", code)
run_test("device2", "02_enter_invitation.yaml")
run_test("device1", "03_send_message.yaml")
run_test("device2", "04_verify_message.yaml")
... and so on

Use Cases

This would enable testing for:

• 📱 Messaging apps (sender ↔ receiver)
• 🎮 Multiplayer games
• 🔗 Invitation/referral systems
• 👥 Collaborative apps
• 🔔 Push notification verification

Questions

1. Is there an official way to do this that I'm missing?
2. Is this on the roadmap?

Thanks for building such an amazing tool! This feature would make it perfect for social/collaborative app testing.

Proposal

add a switch device command to yaml

do ...

switch device to: ...

check...

Anything else?

No response

[linear]

MAE-378

[Fishbowler]

This isn't supported. Given the limited number of folks who require it, it's not something staff have planned.

If I were automating this today, I wouldn't want 2 device scenarios. I'd want to test that 1 device responds appropriately to the API, in a bunch of situations. I'd be looking to JavaScript to build out an API client to mimic the second device whilst observing and running assertions on the first.

[Jonatthu]

I am testing a chat with sender and receiver, is this supported? I see the maestro driver being installed only in one device no matter if I specify two devices

[LucaL1fe]

Okay thats intersting. In my head the are soo many use cases where you need multiple devices to test. Espically every app which works with multiple users and uses a network connection.

Messaging Apps (WhatsApp, Telegram, Messenger)
Testing a messaging app properly means verifying that when User A sends "Hello," User B actually receives it in real-time. You need to confirm that when someone starts typing, the other person sees the "typing..." indicator appear. Read receipts require one device to open a chat while the other verifies the blue ticks update. Voice and video calls need one device to initiate while the other accepts and confirms the connection is established. Even something as simple as online status requires one device to go online while another verifies the status indicator updates.

Ride-Sharing Apps (Uber, Lyft)
The entire ride-sharing experience is a two-device flow. A rider requests a pickup on their phone, and you need to verify that request appears on the driver's device. When the driver accepts, the rider should immediately see "driver on the way." As the driver moves, the rider's app should show live location updates. When the trip ends, both sides need to be able to rate each other. Even cancellation flows require both devices—if a rider cancels, the driver must receive that cancellation instantly.

Payment Apps (Venmo, Cash App, PayPal)
Sending money is meaningless if you can't verify the recipient actually receives it. When User A sends $50, User B should get a push notification and see their balance update. Money requests work the same way in reverse—one user requests $20, and the other needs to see that request and be able to accept or decline it. Split bill features require the creator to send out splits while multiple recipients receive and respond to them.

Food Delivery Apps (DoorDash, Uber Eats)
When a customer places an order, the restaurant or driver app needs to show that order immediately. As the order moves through stages—preparing, picked up, on the way—the customer's app should update in real-time. Delivery tracking means the customer watches a driver icon move on a map while the driver's location updates. When the driver marks an order as delivered, the customer should be prompted to rate and tip.

Multiplayer Games (Chess.com, Words with Friends, Among Us)
Game invites require one player to send and another to receive and accept. Turn-based games need verification that when Player A makes a move, Player B sees it appear on their board. Real-time games require even tighter synchronization—actions must appear on both screens nearly simultaneously. Game endings need to confirm both players see the correct win/lose result.

Collaboration Apps (Google Docs, Notion, Figma, Slack)
Real-time collaboration is the core feature of these apps. When one user types text, another user should see it appear character by character. Cursor presence means seeing where other collaborators are working in the document. Comments and @mentions trigger notifications that the mentioned user should receive immediately. None of this can be tested properly with a single device.

Dating Apps (Tinder, Bumble, Hinge)
A match only happens when both users swipe right—so you need two devices swiping to verify the match notification triggers on both. First messages need to be sent from one account and verified as received on the other. Even unmatching requires confirmation that when one user unmatches, the conversation disappears from the other person's chat list.

Marketplace Apps (eBay, Facebook Marketplace, Airbnb)
Buyer-seller communication is central to marketplace apps. When a buyer sends an inquiry about an item, the seller should receive it. Offers need to be made by one party and received by another who can accept or counter. Purchase completions should trigger notifications for sellers. Reviews posted by buyers should appear on seller profiles.

The Pain Without Native Multi-Device Support
Without built-in orchestration, teams are forced to manually sync test timing between devices, which is error-prone and tedious. You end up building custom socket or API-based coordination systems just to get two test scripts to talk to each other. Race conditions become your constant enemy since you have no reliable way to say "wait until the other device reaches this state." CI/CD pipelines become complex messes of parallel jobs with fragile synchronization. Tests become flaky because network latency between your coordination layer and the devices introduces unpredictable delays. Every team ends up writing their own boilerplate "wait for other device" logic, reinventing the wheel poorly.

But if you say nobody needs this I will search a workaround. But I am not a fan from mimic anyhting as then it is (in my eyes) not a real End to End test anymore, and against the purpose of it.

[LucaL1fe]

I am testing a chat with sender and receiver, is this supported? I see the maestro driver being installed only in one device no matter if I specify two devices

There are folks building workarounds, maybe intersting for you: #2556 (comment)

[LucaL1fe]

My Workaround: Maestro Multi-Device Test Runner

Run sequential Maestro flows across multiple devices with data passing between them.

---

Quick Start

1. Define your devices:

const devices = {
  DAD: 'R5CW23AHD1E',   // Get ID from: adb devices
  MOM: '30ef154',
};

2. Define your flows:

const flows = [
  {
    device: 'DAD',
    file: './subflows/createInvitation.yaml',
    env: {
      NAME: 'Mom'              // Static value
    },
    returnValues: ['INVITE_CODE']
  },
  {
    device: 'MOM',
    file: './subflows/joinWithInviteCode.yaml',
    env: {
      INVITE_CODE: '$INVITE_CODE'  // $ = lookup from sharedData
    }
  }
];

3. Run:

node test-runner.js

---

The env Object

Single unified way to pass parameters to flows:

env: {
  NAME: 'Mom',              // Plain string = static value
  INVITE_CODE: '$INVITE_CODE'  // $ prefix = lookup from sharedData
}

Syntax	Meaning	Example
'value'	Static value	NAME: 'Mom' → -e NAME=Mom
'$KEY'	sharedData lookup	INVITE_CODE: '$INVITE_CODE' → -e INVITE_CODE=<value>

---

Outputting Values from Flows

Use copyTextFrom to capture text, then evalScript to output it:

# 1. Add testID to your React Native component
<ThemedText testID="invite_code">{invitationCode}</ThemedText>

# 2. In your YAML flow - capture with copyTextFrom
- copyTextFrom:
    id: "invite_code"

# 3. Output to console (test-runner parses this)
- evalScript: "${console.log('INVITE_CODE=' + maestro.copiedText)}"

---

Naming Convention

Use UPPER_SNAKE_CASE consistently everywhere:

// In test-runner.js
returnValues: ['INVITE_CODE']  // Not 'inviteCode'
env: { INVITE_CODE: '$INVITE_CODE' }

// In YAML
- evalScript: "${console.log('INVITE_CODE=' + maestro.copiedText)}"

---

Known Issue: Port 7001 Conflict

Problem: Maestro uses port 7001 for device communication. When switching between devices, the port doesn't release cleanly, causing Connection refused errors.

Solution: Kill the process on port 7001 before switching devices.

The test-runner includes killPort7001() that runs automatically on device switch:

function killPort7001() {
  // Find PID using port 7001 via netstat
  // Kill it with taskkill
}

// Called automatically when device changes
if (lastDevice && lastDevice !== flow.device) {
  killPort7001();
}

Future Fix: Maestro PR #2821 adds --driver-host-port flag to use different ports per device. Once released, you can use:

maestro --driver-host-port 7005 --device device1 test flow.yaml
maestro --driver-host-port 7006 --device device2 test flow.yaml

Track progress: #2556

---

How Data Flows

┌─────────────────────────────────────────────────────────────┐
│                     test-runner.js                          │
│                                                             │
│     sharedData = { INVITE_CODE: 'QZSJYF', ... }            │
└─────────────────────────────────────────────────────────────┘
        │                              │
        │ 1. maestro test              │ 2. maestro test
        │    -e NAME=Mom               │    -e INVITE_CODE=QZSJYF
        │                              │
        ▼                              ▼
  ┌───────────┐                  ┌───────────┐
  │    DAD    │   killPort7001   │    MOM    │
  │  Device   │ ──────────────▶  │  Device   │
  │           │                  │           │
  │ copyText  │                  │ uses      │
  │ From →    │                  │ INVITE_   │
  │ console.  │                  │ CODE var  │
  │ log(...)  │                  │           │
  └───────────┘                  └───────────┘
        │
        ▼
  maestro.log
  "JsConsole: INVITE_CODE=QZSJYF"
        │
        ▼
  test-runner extracts → sharedData

---

Full test-runner.js

const { spawnSync } = require('child_process');
const fs = require('fs');
const path = require('path');

// ============================================================
// CONFIGURE THESE
// ============================================================

const devices = {
  DAD: 'R5CW23AHD1E',
  MOM: '30ef154',
};

const flows = [
  {
    device: 'DAD',
    file: './subflows/createInvitation.yaml',
    env: {
      NAME: 'Mom'
    },
    returnValues: ['INVITE_CODE']
  },
  {
    device: 'MOM',
    file: './subflows/joinWithInviteCode.yaml',
    env: {
      INVITE_CODE: '$INVITE_CODE'
    }
  }
];

// ============================================================
// TEST RUNNER
// ============================================================

const DEBUG_DIR = path.join(__dirname, '.temp-debug-logs');
const sharedData = {};

function setupCleanupHandlers() {
  const cleanup = () => {
    if (fs.existsSync(DEBUG_DIR)) {
      try { fs.rmSync(DEBUG_DIR, { recursive: true, force: true }); } catch (e) {}
    }
  };
  process.on('exit', cleanup);
  process.on('SIGINT', () => { cleanup(); process.exit(1); });
  process.on('SIGTERM', () => { cleanup(); process.exit(1); });
  process.on('uncaughtException', (err) => {
    console.error('\n❌ Unexpected error:', err.message);
    cleanup();
    process.exit(1);
  });
}

setupCleanupHandlers();

/**
 * Kill process using port 7001 (Maestro driver port)
 * Needed when switching between devices
 */
function killPort7001() {
  console.log('\n--- Killing process on port 7001 ---');
  try {
    const netstat = spawnSync('netstat', ['-ano'], { encoding: 'utf-8', shell: true });
    const lines = (netstat.stdout || '').split('\n');

    for (const line of lines) {
      if (line.includes(':7001') && line.includes('LISTENING')) {
        const parts = line.trim().split(/\s+/);
        const pid = parts[parts.length - 1];
        if (pid && pid !== '0') {
          console.log(`  Found PID ${pid} on port 7001, killing...`);
          spawnSync('taskkill', ['//F', '//PID', pid], { encoding: 'utf-8', shell: true });
          console.log(`  Killed PID ${pid}`);
        }
      }
    }
  } catch (e) {
    console.warn('  Warning: Could not kill port 7001 process:', e.message);
  }
}

function findMaestroLog(debugDir) {
  const testsDir = path.join(debugDir, '.maestro', 'tests');
  if (!fs.existsSync(testsDir)) return null;

  const folders = fs.readdirSync(testsDir)
    .filter(f => fs.statSync(path.join(testsDir, f)).isDirectory())
    .sort()
    .reverse();

  for (const folder of folders) {
    const logPath = path.join(testsDir, folder, 'maestro.log');
    if (fs.existsSync(logPath)) return logPath;
  }
  return null;
}

function extractFromLog(logPath, keys) {
  const extracted = {};
  if (!logPath || !fs.existsSync(logPath)) return extracted;

  const content = fs.readFileSync(logPath, 'utf-8');

  for (const key of keys) {
    const pattern = new RegExp(`JsConsole:\\s*${key}=([A-Za-z0-9_-]+)`, 'i');
    const match = content.match(pattern);
    if (match) extracted[key] = match[1];
  }

  return extracted;
}

function cleanDebugDir() {
  if (fs.existsSync(DEBUG_DIR)) {
    fs.rmSync(DEBUG_DIR, { recursive: true, force: true });
  }
}

function runFlow(flow) {
  const deviceId = devices[flow.device];
  if (!deviceId) {
    console.error(`Unknown device: ${flow.device}`);
    return false;
  }

  console.log(`\n${'='.repeat(50)}`);
  console.log(`=== ${flow.device}: ${flow.file} ===`);
  console.log('='.repeat(50));

  cleanDebugDir();

  // Build env flags
  const envFlags = [];
  if (flow.env) {
    for (const [envKey, value] of Object.entries(flow.env)) {
      if (value.startsWith('$')) {
        const dataKey = value.slice(1);
        const resolvedValue = sharedData[dataKey];
        if (resolvedValue) {
          envFlags.push('-e', `${envKey}=${resolvedValue}`);
          console.log(`  ${envKey} = "${resolvedValue}" (from $${dataKey})`);
        } else {
          console.warn(`  Warning: ${dataKey} not found in sharedData`);
        }
      } else {
        envFlags.push('-e', `${envKey}=${value}`);
        console.log(`  ${envKey} = "${value}"`);
      }
    }
  }

  const args = [
    `--device=${deviceId}`,
    'test',
    `--debug-output=${DEBUG_DIR}`,
    ...envFlags,
    flow.file
  ];
  console.log(`\nRunning: maestro ${args.join(' ')}\n`);

  const result = spawnSync('maestro', args, {
    encoding: 'utf-8',
    cwd: __dirname,
    shell: true
  });

  if (result.stdout) console.log(result.stdout);

  if (result.status !== 0) {
    console.error(`\n✗ ${flow.device} FAILED (exit code: ${result.status})`);
    if (result.stderr) console.error(result.stderr);
    return false;
  }

  // Extract returnValues
  if (flow.returnValues && flow.returnValues.length > 0) {
    const logPath = findMaestroLog(DEBUG_DIR);

    if (logPath) {
      console.log(`\n--- Parsing maestro.log for values ---`);
      const extracted = extractFromLog(logPath, flow.returnValues);

      for (const key of flow.returnValues) {
        if (extracted[key]) {
          sharedData[key] = extracted[key];
          console.log(`>>> Extracted ${key}: ${sharedData[key]}`);
        } else {
          console.warn(`>>> Warning: Could not extract ${key} (looked for JsConsole: ${key}=...)`);
        }
      }
    } else {
      console.warn(`\n>>> Warning: Could not find maestro.log`);
    }
  }

  console.log(`\n✓ ${flow.device} completed`);
  return true;
}

// Main execution
console.log('\n🚀 Multi-Device Test Runner\n');
console.log('Devices:');
Object.entries(devices).forEach(([name, id]) => {
  console.log(`  ${name}: ${id}`);
});

let lastDevice = null;
for (const flow of flows) {
  // Kill port 7001 when switching devices
  if (lastDevice && lastDevice !== flow.device) {
    killPort7001();
  }
  lastDevice = flow.device;

  if (!runFlow(flow)) {
    console.error(`\n❌ Stopped at: ${flow.file}`);
    cleanDebugDir();
    process.exit(1);
  }
}

cleanDebugDir();
console.log('\n' + '='.repeat(50));
console.log('✅ All flows completed!');
console.log('='.repeat(50) + '\n');

---

Subflow Pattern

Create reusable subflows with parameters:

# subflows/createInvitation.yaml
appId: com.raccoonrewards.app.dev
---
- tapOn:
- tapOn: ${NAME}
- tapOn: Send Invitation
- copyTextFrom:
    id: "invite_code"
- evalScript: "${console.log('INVITE_CODE=' + maestro.copiedText)}"
- tapOn: Done
- tapOn: ✕

// Call it with:
{
  device: 'DAD',
  file: './subflows/createInvitation.yaml',
  env: { NAME: 'Mom' },
  returnValues: ['INVITE_CODE']
}