How to Test Android Apps with Appium: Setup Guide + 17 Troubleshooting Fixes

# Check Java version (need JDK 8 or higher)
java -version
 
# Check Node.js version (need 14+ recommended)
node --version
 
# Check npm version
npm --version
 
# Check if adb is installed
adb version

# Install via Homebrew
brew install openjdk@11
 
# Add to PATH
echo 'export PATH="/usr/local/opt/openjdk@11/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

sudo apt update
sudo apt install openjdk-11-jdk
 
# Verify installation
java -version

# Install via Homebrew
brew install node
 
# Verify
node --version
npm --version

# Using NodeSource repository
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs
 
# Verify
node --version
npm --version

export ANDROID_HOME=$HOME/Library/Android/sdk  # macOS
# export ANDROID_HOME=$HOME/Android/Sdk  # Linux
 
export PATH=$PATH:$ANDROID_HOME/emulator
export PATH=$PATH:$ANDROID_HOME/platform-tools
export PATH=$PATH:$ANDROID_HOME/tools
export PATH=$PATH:$ANDROID_HOME/tools/bin

source ~/.zshrc  # or source ~/.bashrc

adb version
# Should output: Android Debug Bridge version X.X.X
 
echo $ANDROID_HOME  # macOS/Linux
echo %ANDROID_HOME%  # Windows
# Should output your SDK path

# List available AVDs
emulator -list-avds
 
# Start your AVD
emulator -avd AppiumTest

adb devices
# Should output:
# List of devices attached
# emulator-5554    device

npm install -g appium
 
# Verify installation
appium --version
# Should output something like: 2.2.1

appium driver install uiautomator2
 
# Verify driver installation
appium driver list
# Should show uiautomator2@X.X.X installed

appium

npm install -g appium-doctor
 
# Run diagnostics
appium-doctor --android

mkdir appium-android-test
cd appium-android-test
npm init -y

npm install --save-dev @wdio/cli
npm install --save-dev @wdio/local-runner
npm install --save-dev @wdio/mocha-framework
npm install --save-dev @wdio/spec-reporter
npm install --save-dev @wdio/appium-service

npx wdio config

exports.config = {
    runner: 'local',
    port: 4723,
    
    specs: [
        './test/specs/**/*.js'
    ],
    
    capabilities: [{
        platformName: 'Android',
        'appium:automationName': 'UiAutomator2',
        'appium:deviceName': 'AppiumTest', // Your AVD name
        'appium:platformVersion': '13.0', // Your Android version
        'appium:app': '/path/to/your/app.apk', // Path to your APK
        'appium:appWaitActivity': 'com.yourapp.MainActivity',
        'appium:noReset': false, // Uninstall app after session
        'appium:newCommandTimeout': 240
    }],
    
    logLevel: 'info',
    bail: 0,
    waitforTimeout: 10000,
    connectionRetryTimeout: 120000,
    connectionRetryCount: 3,
    
    services: ['appium'],
    
    framework: 'mocha',
    reporters: ['spec'],
    
    mochaOpts: {
        ui: 'bdd',
        timeout: 60000
    }
}

# Using aapt (Android Asset Packaging Tool)
aapt dump badging /path/to/your/app.apk | grep package
# Output: package: name='com.yourcompany.yourapp' versionCode='1'
 
# Find launchable activity
aapt dump badging /path/to/your/app.apk | grep launchable-activity
# Output: launchable-activity: name='com.yourcompany.yourapp.MainActivity'

# Install app on emulator/device first
adb install /path/to/your/app.apk
 
# Get package name of installed apps
adb shell pm list packages | grep yourapp
 
# Get main activity
adb shell dumpsys package com.yourcompany.yourapp | grep -A 1 MAIN

describe('Fintech App Login Test', () => {
    
    it('should successfully log in with valid credentials', async () => {
        // Wait for app to load
        await driver.pause(3000);
        
        // Find and fill email field
        const emailField = await $('~email-input'); // Using accessibility ID
        await emailField.setValue('user@example.com');
        
        // Find and fill password field
        const passwordField = await $('~password-input');
        await passwordField.setValue('SecurePass123!');
        
        // Tap login button
        const loginButton = await $('~login-button');
        await loginButton.click();
        
        // Wait for home screen to load
        await driver.pause(2000);
        
        // Verify we're on home screen by checking for balance element
        const balanceLabel = await $('~account-balance');
        const isDisplayed = await balanceLabel.isDisplayed();
        
        // Assert that we successfully logged in
        expect(isDisplayed).toBe(true);
    });
    
    it('should show error message for invalid credentials', async () => {
        // Find and fill email field
        const emailField = await $('~email-input');
        await emailField.setValue('invalid@example.com');
        
        // Find and fill password field  
        const passwordField = await $('~password-input');
        await passwordField.setValue('WrongPassword');
        
        // Tap login button
        const loginButton = await $('~login-button');
        await loginButton.click();
        
        // Wait for error message
        await driver.pause(1000);
        
        // Find error message
        const errorMessage = await $('//*[@text="Invalid email or password"]');
        const errorDisplayed = await errorMessage.isDisplayed();
        
        expect(errorDisplayed).toBe(true);
    });
});

# Make sure Appium server is running in another terminal
# appium
 
# Run the test
npx wdio run wdio.conf.js

// In your Android app XML:
// <Button android:contentDescription="login-button" />
 
const loginButton = await $('~login-button');
await loginButton.click();

// Find by text
const element = await $('//*[@text="Transfer Money"]');
 
// Find by resource-id
const element = await $('//*[@resource-id="com.app:id/transfer_button"]');
 
// Find by class and text
const element = await $('//android.widget.Button[@text="Submit"]');
 
// Find by index
const firstButton = await $('(//android.widget.Button)[1]');

// Find by text
const element = await $('android=new UiSelector().text("Transfer")');
 
// Find by text contains
const element = await $('android=new UiSelector().textContains("Trans")');
 
// Find by resource ID
const element = await $('android=new UiSelector().resourceId("com.app:id/button")');
 
// Find by class name
const element = await $('android=new UiSelector().className("android.widget.Button")');
 
// Combining selectors
const element = await $('android=new UiSelector().className("android.widget.EditText").instance(0)');

const element = await $('id=com.app:id/transfer_button');

# Start your emulator and open your app
emulator -avd AppiumTest
 
# Install your app
adb install /path/to/app.apk
 
# Open the app screen you want to inspect
# Then run uiautomatorviewer
$ANDROID_HOME/tools/bin/uiautomatorviewer

const button = await $('~submit-button');
await button.click();
 
// Alternative: tap by coordinates
await driver.touchAction({
    action: 'tap',
    x: 200,
    y: 400
});

const emailField = await $('~email-input');
await emailField.setValue('user@example.com');
 
// Clear existing text first
await emailField.clearValue();
await emailField.setValue('newuser@example.com');
 
// Add to existing text
await emailField.addValue(' additional text');

// Swipe down to refresh
await driver.touchAction([
    { action: 'press', x: 200, y: 400 },
    { action: 'wait', ms: 500 },
    { action: 'moveTo', x: 200, y: 800 },
    'release'
]);
 
// Scroll to element (UIAutomator method)
await $('android=new UiScrollable(new UiSelector().scrollable(true)).scrollIntoView(new UiSelector().text("Account Settings"))');
 
// Swipe element (like dismissing a card)
const element = await $('~transaction-card');
await element.touchAction([
    { action: 'press', x: 0, y: 0 },
    { action: 'wait', ms: 100 },
    { action: 'moveTo', x: -300, y: 0 },
    'release'
]);

const element = await $('~transaction-item');
await element.touchAction([
    { action: 'longPress' },
    { action: 'release' }
]);
 
// Long press with duration
await driver.touchAction([
    { action: 'longPress', x: 200, y: 400 },
    { action: 'wait', ms: 2000 },
    'release'
]);

const balanceElement = await $('~account-balance');
 
// Get displayed text
const balanceText = await balanceElement.getText();
console.log(`Current balance: ${balanceText}`); // "Current balance: $2,450.00"
 
// Get attribute value
const resourceId = await balanceElement.getAttribute('resource-id');
const isEnabled = await balanceElement.getAttribute('enabled');
 
// Check if element is displayed
const isVisible = await balanceElement.isDisplayed();
 
// Check if element exists
const exists = await balanceElement.isExisting();

describe('Money Transfer Flow', () => {
    
    it('should transfer money between accounts successfully', async () => {
        // Login first
        await $('~email-input').setValue('user@example.com');
        await $('~password-input').setValue('SecurePass123!');
        await $('~login-button').click();
        
        // Wait for home screen
        await driver.pause(2000);
        
        // Get initial balance
        const initialBalanceText = await $('~account-balance').getText();
        const initialBalance = parseFloat(initialBalanceText.replace(/[$,]/g, ''));
        
        // Navigate to transfer screen
        await $('~transfer-button').click();
        await driver.pause(1000);
        
        // Select recipient account
        await $('~recipient-dropdown').click();
        await $('//*[@text="Savings Account"]').click();
        
        // Enter transfer amount
        await $('~amount-input').setValue('100.00');
        
        // Add memo
        await $('~memo-input').setValue('Test transfer');
        
        // Review transfer details
        await $('~review-button').click();
        await driver.pause(500);
        
        // Verify transfer details are correct
        const confirmAmount = await $('~confirm-amount').getText();
        expect(confirmAmount).toBe('$100.00');
        
        const confirmRecipient = await $('~confirm-recipient').getText();
        expect(confirmRecipient).toBe('Savings Account');
        
        // Confirm transfer
        await $('~confirm-transfer-button').click();
        
        // Wait for success message
        await driver.pause(2000);
        const successMessage = await $('~success-message');
        expect(await successMessage.isDisplayed()).toBe(true);
        
        // Navigate back to home
        await $('~home-button').click();
        await driver.pause(1000);
        
        // Verify balance decreased
        const newBalanceText = await $('~account-balance').getText();
        const newBalance = parseFloat(newBalanceText.replace(/[$,]/g, ''));
        
        expect(newBalance).toBe(initialBalance - 100);
    });
    
    it('should reject transfer with insufficient funds', async () => {
        // Navigate to transfer screen
        await $('~transfer-button').click();
        
        // Select recipient
        await $('~recipient-dropdown').click();
        await $('//*[@text="Savings Account"]').click();
        
        // Try to transfer more than available balance
        await $('~amount-input').setValue('999999.00');
        await $('~review-button').click();
        
        // Verify error message appears
        await driver.pause(500);
        const errorMessage = await $('//*[@text="Insufficient funds"]');
        expect(await errorMessage.isDisplayed()).toBe(true);
        
        // Confirm button should be disabled
        const confirmButton = await $('~confirm-transfer-button');
        const isEnabled = await confirmButton.getAttribute('enabled');
        expect(isEnabled).toBe('false');
    });
});

describe('Permission Handling', () => {
    
    it('should grant camera permission when requested', async () => {
        // Trigger camera feature
        await $('~scan-check-button').click();
        
        // Wait for permission dialog
        await driver.pause(1000);
        
        // Grant permission using UIAutomator selector
        const allowButton = await $('android=new UiSelector().text("Allow")');
        await allowButton.click();
        
        // Verify camera view is now visible
        const cameraView = await $('~camera-preview');
        expect(await cameraView.isDisplayed()).toBe(true);
    });
    
    it('should handle location permission', async () => {
        // Trigger location feature
        await $('~find-atm-button').click();
        
        // Wait for permission dialog
        await driver.pause(1000);
        
        // Grant precise location
        const allowPreciseButton = await $('android=new UiSelector().text("Allow only while using the app")');
        await allowPreciseButton.click();
        
        // Verify map loads
        const mapView = await $('~atm-map');
        expect(await mapView.isDisplayed()).toBe(true);
    });
});

describe('Screenshot Example', () => {
    
    it('should capture screenshots at key points', async () => {
        // Take screenshot before action
        await driver.saveScreenshot('./screenshots/before-login.png');
        
        // Perform login
        await $('~email-input').setValue('user@example.com');
        await $('~password-input').setValue('SecurePass123!');
        await $('~login-button').click();
        
        await driver.pause(2000);
        
        // Take screenshot after successful login
        await driver.saveScreenshot('./screenshots/after-login.png');
        
        // Take screenshot of specific element
        const balanceElement = await $('~account-balance');
        await balanceElement.saveScreenshot('./screenshots/balance-element.png');
    });
});

describe('Video Recording', () => {
    
    before(async () => {
        // Start recording
        await driver.startRecordingScreen({
            videoSize: '1280x720',
            bitRate: 3000000
        });
    });
    
    it('should execute transaction flow', async () => {
        // Your test code here
        await $('~transfer-button').click();
        // ... more test steps
    });
    
    after(async () => {
        // Stop recording and save
        const videoBase64 = await driver.stopRecordingScreen();
        const fs = require('fs');
        fs.writeFileSync('./recordings/test-execution.mp4', videoBase64, 'base64');
    });
});

# Check if port is in use
lsof -i :4723  # macOS/Linux
netstat -ano | findstr :4723  # Windows
 
# Kill process using port
kill -9 <PID>  # macOS/Linux
 
# Start Appium on different port
appium --port 4725
 
# Update wdio.conf.js to match
# port: 4725

node --version
# Need v14 or higher for Appium 2.x
 
# Update if needed (macOS)
brew upgrade node

# Restart ADB server
adb kill-server
adb start-server
 
# List devices again
adb devices
 
# If device shows "unauthorized", check device for authorization prompt
# Accept "Allow USB debugging" on your Android device

# Check emulator is running
emulator -list-avds
ps aux | grep emulator
 
# Start emulator if not running
emulator -avd AppiumTest -no-snapshot-load
 
# Wait 30-60 seconds for full boot
# Then check adb again
adb devices

// Add explicit wait
const loginButton = await $('~login-button');
await loginButton.waitForDisplayed({ timeout: 5000 });
await loginButton.click();
 
// Or use WebDriverIO's built-in retry
await driver.waitUntil(
    async () => {
        const button = await $('~login-button');
        return await button.isDisplayed();
    },
    {
        timeout: 10000,
        timeoutMsg: 'Login button not found after 10 seconds'
    }
);

// Wrong - missing tilde for accessibility ID
const element = await $('login-button');
 
// Correct
const element = await $('~login-button');
 
// Wrong - incorrect XPath quotes
const element = await $("//*[@text='Login']");
 
// Correct
const element = await $('//*[@text="Login"]');

# Install and launch app manually
adb install app.apk
adb shell monkey -p com.yourapp -c android.intent.category.LAUNCHER 1
 
# Check current activity
adb shell dumpsys window windows | grep -E 'mCurrentFocus'
# Output: mCurrentFocus=Window{abc123 u0 com.yourapp/.activities.SplashActivity}

capabilities: [{
    // ...
    'appium:appWaitActivity': 'com.yourapp/.activities.SplashActivity',
    'appium:appWaitDuration': 30000, // Wait up to 30 seconds
}]

capabilities: [{
    // ...
    'appium:appWaitActivity': '*', // Any activity
}]
 
// In test
await driver.pause(5000); // Wait for app to fully load

# Capture logcat output during test
adb logcat > logcat-output.txt
 
# Filter for crashes
adb logcat | grep -i "fatal\|exception\|crash"
 
# Check specifically for your app
adb logcat | grep "com.yourapp"

try {
    await $('~submit-button').click();
    await driver.pause(2000);
} catch (error) {
    // Capture screenshot before test fails
    await driver.saveScreenshot('./screenshots/error-state.png');
    
    // Get app state
    const currentActivity = await driver.getCurrentActivity();
    console.log('Current activity:', currentActivity);
    
    throw error;
}

// Hide keyboard before interacting with elements
await driver.hideKeyboard();
 
// Or press back button
await driver.pressKeyCode(4); // 4 is Back button keycode
 
// Wait a moment for keyboard animation
await driver.pause(500);
 
// Now interact with element
await $('~submit-button').click();

// Scroll to make element visible above keyboard
await $('android=new UiScrollable(new UiSelector().scrollable(true)).scrollIntoView(new UiSelector().resourceId("com.app:id/submit_button"))');
 
await $('~submit-button').click();

# Disable all animations
adb shell settings put global window_animation_scale 0
adb shell settings put global transition_animation_scale 0
adb shell settings put global animator_duration_scale 0
 
# Re-enable after testing (optional)
adb shell settings put global window_animation_scale 1
adb shell settings put global transition_animation_scale 1
adb shell settings put global animator_duration_scale 1

const button = await $('~transfer-button');
 
// Wait for element to be clickable (not just displayed)
await button.waitForClickable({ timeout: 5000 });
await button.click();

# Uninstall existing app
adb uninstall com.yourapp.package
 
# Or set noReset: false in capabilities to auto-uninstall

capabilities: [{
    // ...
    'appium:noReset': false, // Uninstall app after each session
    'appium:fullReset': true, // Also clear app data
}]

// In wdio.conf.js
waitforTimeout: 5000, // Reduce from default 10000
 
// Use explicit waits instead of pause
// Bad
await driver.pause(5000);
 
// Good
await $('~element').waitForDisplayed({ timeout: 5000 });

// Slow - XPath searches entire hierarchy
const button = await $('//android.widget.Button[@text="Submit"]');
 
// Fast - direct accessibility ID
const button = await $('~submit-button');
 
// Fast - resource ID
const button = await $('id=com.app:id/submit_button');

// In wdio.conf.js
capabilities: [{
    // ...
    'appium:noReset': true, // Keep app installed between tests
}]
 
// Login once in before() hook instead of each test
before(async () => {
    await $('~email-input').setValue('user@example.com');
    await $('~password-input').setValue('SecurePass123!');
    await $('~login-button').click();
    await driver.pause(2000);
});

adb devices
# Should show:
# List of devices attached
# ABC123456789    device

capabilities: [{
    // ...
    'appium:deviceName': 'ABC123456789', // Your device ID from adb devices
    'appium:udid': 'ABC123456789', // Same as device name
}]

# From emulator, ping Google
adb shell ping -c 3 google.com
 
# If fails, restart emulator with network
emulator -avd AppiumTest -dns-server 8.8.8.8

# Forward emulator port to host machine
adb reverse tcp:8080 tcp:8080
 
# Now emulator's localhost:8080 points to host's localhost:8080

// Instead of
const API_URL = 'http://localhost:8080';
 
// Use
const API_URL = 'http://10.0.2.2:8080'; // Emulator only

// Instead of hardcoded resource IDs (can change between versions)
const button = await $('id=com.android.permissioncontroller:id/permission_allow_button');
 
// Use text that's consistent
const button = await $('android=new UiSelector().text("Allow")');
 
// Or use multiple fallback selectors
async function findPermissionButton() {
    try {
        return await $('id=com.android.permissioncontroller:id/permission_allow_button');
    } catch {
        try {
            return await $('id=com.android.packageinstaller:id/permission_allow_button');
        } catch {
            return await $('android=new UiSelector().text("Allow")');
        }
    }
}
 
const button = await findPermissionButton();
await button.click();

// In wdio.conf.js
capabilities: [
    {
        platformName: 'Android',
        'appium:platformVersion': '11.0',
        'appium:deviceName': 'Android11Emulator',
        'appium:app': '/path/to/app.apk'
    },
    {
        platformName: 'Android',
        'appium:platformVersion': '13.0',
        'appium:deviceName': 'Android13Emulator',
        'appium:app': '/path/to/app.apk'
    }
]

// Open deep link during test
await driver.execute('mobile: deepLink', {
    url: 'myapp://transfer/123',
    package: 'com.yourapp.package'
});
 
// Wait for app to process deep link
await driver.pause(2000);
 
// Verify you're on correct screen
const transferScreen = await $('~transfer-details-screen');
expect(await transferScreen.isDisplayed()).toBe(true);
 
// Test app link (HTTPS link that opens app)
await driver.execute('mobile: deepLink', {
    url: 'https://yourapp.com/transfer/123',
    package: 'com.yourapp.package'
});

await driver.execute('mobile: shell', {
    command: 'am start -a android.intent.action.VIEW -d "myapp://transfer/123" com.yourapp.package'
});

// In wdio.conf.js
afterTest: async function() {
    // Clear app data and restart
    await driver.reset();
}
 
// Or terminate and relaunch app
afterTest: async function() {
    await driver.terminateApp('com.yourapp.package');
    await driver.pause(1000);
    await driver.activateApp('com.yourapp.package');
}

// Split into smaller suites
// suite1.spec.js - login tests (5-10 tests)
// suite2.spec.js - transfer tests (5-10 tests)
// suite3.spec.js - profile tests (5-10 tests)
 
// Run separately
npx wdio run wdio.conf.js --spec test/specs/suite1.spec.js

# Set up fingerprint on running emulator
adb -e emu finger touch 1
 
# Or enable face unlock via emulator extended controls
# Extended Controls → Fingerprint → Touch the sensor

describe('Biometric Login', () => {
    
    it('should authenticate with fingerprint', async () => {
        // Trigger biometric prompt
        await $('~use-biometric-button').click();
        
        // Wait for biometric dialog
        await driver.pause(1000);
        
        // Simulate fingerprint touch
        await driver.execute('mobile: fingerprint', { action: 'authenticate' });
        
        // Or using adb
        await driver.execute('mobile: shell', {
            command: 'adb -e emu finger touch 1'
        });
        
        // Wait for authentication
        await driver.pause(1000);
        
        // Verify logged in
        const homeScreen = await $('~home-screen');
        expect(await homeScreen.isDisplayed()).toBe(true);
    });
});

// Scroll into view using UIAutomator
await $('android=new UiScrollable(new UiSelector().scrollable(true)).scrollIntoView(new UiSelector().text("Account Settings"))');
 
// For horizontal scroll
await $('android=new UiScrollable(new UiSelector().scrollable(true).instance(0)).setAsHorizontalList().scrollForward()');
 
// Scroll to end of list
await $('android=new UiScrollable(new UiSelector().scrollable(true)).scrollToEnd(10)'); // max 10 swipes
 
// Custom scroll action
await driver.execute('mobile: scrollGesture', {
    left: 100,
    top: 400,
    width: 600,
    height: 800,
    direction: 'down',
    percent: 3.0
});

name: Android Tests
 
on: [push, pull_request]
 
jobs:
  test:
    runs-on: macos-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Java
        uses: actions/setup-java@v3
        with:
          java-version: '11'
          distribution: 'adopt'
      
      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
      
      - name: Install dependencies
        run: |
          npm install -g appium
          appium driver install uiautomator2
          npm install
      
      - name: Run Appium tests
        uses: reactivecircus/android-emulator-runner@v2
        with:
          api-level: 33
          target: google_apis
          arch: x86_64
          profile: pixel_5
          script: |
            appium &
            sleep 10
            npx wdio run wdio.conf.js

// pages/LoginPage.js
class LoginPage {
    get emailInput() { return $('~email-input'); }
    get passwordInput() { return $('~password-input'); }
    get loginButton() { return $('~login-button'); }
    get errorMessage() { return $('//*[@text="Invalid email or password"]'); }
    
    async login(email, password) {
        await this.emailInput.setValue(email);
        await this.passwordInput.setValue(password);
        await this.loginButton.click();
        await driver.pause(2000);
    }
    
    async getErrorMessage() {
        return await this.errorMessage.getText();
    }
}
 
module.exports = new LoginPage();

// test/specs/login.spec.js
const LoginPage = require('../pages/LoginPage');
const HomePage = require('../pages/HomePage');
 
describe('Login Tests', () => {
    
    it('should login successfully', async () => {
        await LoginPage.login('user@example.com', 'SecurePass123!');
        
        const balance = await HomePage.getBalance();
        expect(balance).toContain('$');
    });
    
    it('should show error for invalid credentials', async () => {
        await LoginPage.login('invalid@example.com', 'wrong');
        
        const error = await LoginPage.getErrorMessage();
        expect(error).toBe('Invalid email or password');
    });
});

// testdata/users.json
{
    "validUser": {
        "email": "user@example.com",
        "password": "SecurePass123!"
    },
    "invalidUser": {
        "email": "invalid@example.com",
        "password": "wrong"
    }
}

// test/specs/login.spec.js
const testData = require('../testdata/users.json');
 
describe('Login Tests', () => {
    
    it('should login successfully', async () => {
        await LoginPage.login(
            testData.validUser.email,
            testData.validUser.password
        );
        
        expect(await HomePage.isDisplayed()).toBe(true);
    });
});

// utils/waits.js
class Waits {
    async waitForElementAndClick(selector, timeout = 10000) {
        const element = await $(selector);
        await element.waitForClickable({ timeout });
        await element.click();
    }
    
    async waitForTextAndVerify(selector, expectedText, timeout = 10000) {
        await driver.waitUntil(
            async () => {
                const element = await $(selector);
                const text = await element.getText();
                return text === expectedText;
            },
            {
                timeout,
                timeoutMsg: `Expected text "${expectedText}" not found after ${timeout}ms`
            }
        );
    }
    
    async waitForElementToDisappear(selector, timeout = 10000) {
        await driver.waitUntil(
            async () => {
                try {
                    const element = await $(selector);
                    return !(await element.isDisplayed());
                } catch {
                    return true; // Element doesn't exist anymore
                }
            },
            {
                timeout,
                timeoutMsg: `Element still visible after ${timeout}ms`
            }
        );
    }
}
 
module.exports = new Waits();

// utils/logger.js
class Logger {
    info(message) {
        console.log(`[INFO] ${new Date().toISOString()} - ${message}`);
    }
    
    async logAction(action, selector) {
        const timestamp = new Date().toISOString();
        console.log(`[ACTION] ${timestamp} - ${action} on ${selector}`);
    }
    
    async logAppState() {
        const activity = await driver.getCurrentActivity();
        const packageName = await driver.getCurrentPackage();
        console.log(`[STATE] Current: ${packageName}/${activity}`);
    }
}
 
module.exports = new Logger();

const logger = require('../utils/logger');
 
describe('Transfer Test', () => {
    
    it('should complete transfer', async () => {
        logger.info('Starting transfer test');
        
        await logger.logAction('click', 'transfer-button');
        await $('~transfer-button').click();
        
        await logger.logAppState();
        
        // ... rest of test
    });
});