Mobile Testing

Getting Started with pCloudy: Setup and First Test

HelpMeTest

HelpMeTest

— 6 min read
Getting Started with pCloudy: Setup and First Test

Getting from zero to a running test on pCloudy takes about 30 minutes if you know what you're doing. This guide walks through account setup, uploading your app, running a manual session, and then automating that same flow with Appium — against real physical devices.

Account Setup

Go to pcloudy.com and sign up for a free trial. The trial gives you a limited pool of device minutes — enough to run a few manual sessions and one or two automated test runs.

After signup, you'll get:

  • A pCloudy username (your email)
  • An API token (under Account Settings → API Token)
  • Access to the device catalog

Save your API token now. You'll need it for every automated test connection and API call.

The free trial doesn't require a credit card, but device availability on the shared pool can be limited during peak hours (India business hours, roughly 09:00–18:00 IST). If you're evaluating the platform, run your initial tests outside those windows to avoid queue waits.

Uploading Your App

Before testing, your APK (Android) or IPA (iOS) needs to be in pCloudy's storage.

Via the Web Interface

  1. Log in to app.pcloudy.com
  2. Navigate to App Management
  3. Click Upload
  4. Select your APK or IPA file
  5. Wait for the upload and processing to complete — pCloudy parses the manifest and extracts package name, version, and permissions

The uploaded app gets a unique file path in pCloudy's system, something like /Appium_Test/username/1234567890_MyApp.apk. You'll reference this path in your Appium capabilities.

Via API

For CI pipelines, upload programmatically:

curl -X POST "https://device.pcloudy.com/api/upload_file" \
  -H "Content-Type: multipart/form-data" \
  -F "file=@./build/app-debug.apk" \
  -F "username=your@email.com" \
  -F "access_key=YOUR_API_TOKEN" \
  -F "source_type=raw"

Response:

{
  "result": {
    "file": "Appium_Test/your@email.com/1700000000_app-debug.apk"
  }
}

Store that file path — you'll use it as the app capability in Appium.

Running a Manual Testing Session

Manual sessions are the fastest way to validate your app on a real device and get familiar with the pCloudy interface.

  1. From the dashboard, click Start Testing
  2. Select Manual Testing
  3. Filter devices by OS (Android/iOS), version, manufacturer, or model name
  4. Click a device to check availability (green = available, orange = in use by another session, red = unavailable)
  5. Click Book and wait for the device to initialize

The device session loads in a browser tab. What you see:

  • Left panel: the device screen, interactive via mouse
  • Right panel: tools — screenshot, video recording, network throttling, geolocation, device logs

Device Log Streaming

For Android, the logcat stream is available in real time in the right panel. Filter by your app's package name to isolate relevant output:

tag:com.yourcompany.yourapp

This is genuinely useful for manual debugging — you can see exactly what the app logs when you trigger specific actions.

Network Conditions

pCloudy lets you simulate different network conditions during a manual session:

  • WiFi (unthrottled)
  • 4G LTE
  • 3G
  • 2G
  • Offline

Switch these during a session to test how your app handles degraded connectivity — loading states, offline mode, retry logic. This is a common test case that's painful to reproduce manually on physical hardware.

Session Recording

Video recording is automatic for every session. After you end the session, the recording is available in your session history. This is useful for:

  • Documenting bugs with video evidence
  • Asynchronous review with team members
  • Attaching to JIRA tickets

Running Your First Appium Test

Now let's automate the same session. We'll write a basic Appium test in Java that connects to pCloudy's remote hub.

Prerequisites

  • Java 11+
  • Maven
  • Appium Java client

Add to your pom.xml:

<dependencies>
    <dependency>
        <groupId>io.appium</groupId>
        <artifactId>java-client</artifactId>
        <version>8.6.0</version>
    </dependency>
    <dependency>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>7.8.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Capabilities for Android

import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.options.UiAutomator2Options;
import java.net.URL;

public class FirstPCloudyTest {

    private AndroidDriver driver;

    @BeforeClass
    public void setUp() throws Exception {
        UiAutomator2Options options = new UiAutomator2Options();

        // pCloudy authentication
        options.setCapability("pCloudy_Username", "your@email.com");
        options.setCapability("pCloudy_ApiKey", "YOUR_API_TOKEN");

        // Device selection
        options.setCapability("pCloudy_DeviceVersion", "13.0");
        options.setCapability("pCloudy_DeviceFullName", "Samsung Galaxy S23_13.0_");

        // Session configuration
        options.setCapability("pCloudy_DurationInMinutes", "10");
        options.setCapability("pCloudy_WildNet", "false");

        // App configuration
        options.setCapability("pCloudy_ApplicationName", 
            "Appium_Test/your@email.com/1700000000_app-debug.apk");
        options.setCapability("appPackage", "com.yourcompany.yourapp");
        options.setCapability("appActivity", "com.yourcompany.yourapp.MainActivity");
        options.setCapability("automationName", "UiAutomator2");

        driver = new AndroidDriver(
            new URL("https://device.pcloudy.com/appiumcloud/wd/hub"),
            options
        );
    }

    @Test
    public void testLoginFlow() {
        // Your test steps here
        WebElement emailField = driver.findElement(By.id("com.yourcompany.yourapp:id/email_input"));
        emailField.sendKeys("test@example.com");

        WebElement passwordField = driver.findElement(By.id("com.yourcompany.yourapp:id/password_input"));
        passwordField.sendKeys("password123");

        WebElement loginButton = driver.findElement(By.id("com.yourcompany.yourapp:id/login_button"));
        loginButton.click();

        WebElement homeScreen = driver.findElement(By.id("com.yourcompany.yourapp:id/home_container"));
        Assert.assertTrue(homeScreen.isDisplayed(), "Home screen should be visible after login");
    }

    @AfterClass
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

Key Capabilities Explained

pCloudy_Username and pCloudy_ApiKey: Authentication. Use the API token from Account Settings, not your login password.

pCloudy_DeviceFullName: The exact device identifier from pCloudy's catalog. Get available device names from the web interface or via API:

curl -X GET "https://device.pcloudy.com/api/devices?username=your@email.com&access_key=YOUR_API_TOKEN&available_now=true&os=android&duration=10"

This returns a list of currently available devices with their full names.

pCloudy_DurationInMinutes: How long to book the device. Billing runs from the moment the device is allocated, so set this to the minimum you need plus a buffer. If your tests finish early, call driver.quit() to release the device and stop the billing clock.

pCloudy_WildNet: When true, pCloudy will allocate any available device matching your OS version if your specific requested device isn't available. Useful for CI where you want any device rather than a specific one.

Capabilities for iOS

XCUITestOptions iosOptions = new XCUITestOptions();

iosOptions.setCapability("pCloudy_Username", "your@email.com");
iosOptions.setCapability("pCloudy_ApiKey", "YOUR_API_TOKEN");
iosOptions.setCapability("pCloudy_DeviceVersion", "16.0");
iosOptions.setCapability("pCloudy_DeviceFullName", "Apple iPhone 14_16.0_");
iosOptions.setCapability("pCloudy_DurationInMinutes", "10");
iosOptions.setCapability("pCloudy_ApplicationName",
    "Appium_Test/your@email.com/1700000000_MyApp.ipa");

// iOS requires bundle ID
iosOptions.setCapability("bundleId", "com.yourcompany.yourapp");
iosOptions.setCapability("automationName", "XCUITest");

IOSDriver iosDriver = new IOSDriver(
    new URL("https://device.pcloudy.com/appiumcloud/wd/hub"),
    iosOptions
);

For iOS, your IPA must be signed with an Enterprise distribution certificate or a provisioning profile that includes pCloudy's device UDIDs. This is the most common point of failure when starting with iOS testing on any cloud platform. Contact pCloudy support to get their device UDID list for your provisioning profile.

Running the Test

mvn test -Dtest=FirstPCloudyTest

While the test runs, open app.pcloudy.com and go to Reports. You'll see a live session view with the device feed, and after the test completes, a full report with:

  • Step-by-step screenshots (one per command if screenshot-on-action is enabled)
  • Command log
  • Session video
  • Device logs

Checking Test Results

The reports dashboard at app.pcloudy.com shows:

  • Pass/fail status
  • Duration
  • Device used
  • Screenshots at each step
  • Full video replay

You can also access results via API for CI integration:

curl "https://device.pcloudy.com/api/test_report?username=your@email.com&access_key=YOUR_API_TOKEN&sessionId=SESSION_ID"

Common Setup Issues

"No device available": The requested device is booked. Either wait, use pCloudy_WildNet=true, or try a different device model.

"Invalid API Key": Double-check the token from Account Settings. The API key is different from your login password.

iOS "Application Installation Failed": Provisioning profile issue. Your IPA isn't signed for pCloudy's device UDIDs. Re-sign with an Enterprise certificate or get pCloudy's UDIDs added to your development provisioning profile.

Session timeout before test completes: Increase pCloudy_DurationInMinutes. pCloudy will terminate the session when the booked time expires, even mid-test.

App crashes on launch: Check device OS version compatibility. An app built for Android 10+ may crash on Android 8. Filter devices by OS version in your capabilities.

Next Steps

Once your first test passes, the natural next step is parallelizing across multiple devices. That requires managing multiple driver instances and thinking carefully about how you pass capabilities to each. The pCloudy documentation has a parallel execution guide, but the TestNG parallel configuration section in their docs is the most useful starting point.

You'll also want to integrate this into your CI pipeline rather than running it locally — which means externalizing credentials and triggering test runs as part of your build process.

Read more

Start now free