Qampanion Logo
Qampanion

Qampanion Documentation

Overview

Qampanion is a macOS application for creating and running regression and end-to-end (E2E) tests for mobile applications. It provides a user-friendly interface for test design, device management, and test execution, making it easier for developers and testers to ensure the quality of their mobile applications.

Download & Install

Qampanion is distributed as a .dmg file. To install:

  1. Download Qampanion.dmg
  2. Open the downloaded .dmg file
  3. Drag Qampanion.app into the Applications folder
  4. Launch Qampanion from Applications or Spotlight

System Requirements: macOS 15 (Sequoia) or later.

⚠️ Public Preview — Qampanion is currently in Public Preview. You may encounter bugs or incomplete features. Feedback is welcome — feel free to reach out at support@qampanion.com!

Dependency Management

The application requires third-party dependencies to work correctly.

Installing

Dependency installation is available directly in the application:

Settings → Dependencies

All dependencies (except Xcode) are installed automatically inside the application.

⚠️ Wait until the installation process is fully completed before proceeding.

General List

Optional (iOS)

  • Xcode
  • Axe

Xcode, as part of the Apple infrastructure, must be installed manually.

Follow the instructions in the application or use the official installation guide:

Optional (Android)

  • Java 21+
  • Android SDK Command-line Tools, including:
    • sdkmanager
    • emulator
    • platform-tools
    • cmdline-tools
    • build-tools

Device Management

Qampanion supports any emulators and simulators created with:

  • Xcode (iOS)
  • Android Studio (Android)

For convenience, device management and device creation are also available directly in Qampanion.

By Qampanion

Go to: Settings → Devices

Then select:

  • platform (iOS / Android)
  • runtime/image (for example, iOS 18.2, Android 34)
  • device type / visual profile

⚠️ If the required runtime/image is not installed, Qampanion will prompt you to download it. Follow the instructions in the application.

By IDEs

You can also manage and create devices using the official development environments. Recommended options and links to the official documentation are listed below:

Application Import

Go to: Settings → Applications

Qampanion supports importing applications:

  • from a local enviroment
  • from network sources

Supported formats:

  • .apk
  • .app
  • .zip (if it contains an .apk or .app file inside)

⚠️ Make sure the network resource is accessible before starting the import.

Test Case

A test case is the core entity of a project. It is a full E2E test that consists of a list of steps. A single project can contain any number of test cases and is not tied to a specific platform or application.

Test cases within the same project can be executed on different:

  • platforms
  • devices
  • applications

⚠️ If a project contains test cases for different platforms, manual action is required when switching between them. The selected device and application used during test design are not bound to the test case or the project.

Creating New Test Case

On the project page, in the left sidebar, click the [ + ] button and enter the test case name.

After creation, you can:

  • open the test case settings
  • start creating the first steps

Steps

A Step is an entity inside a test case that represents one or more actions within a single application screen. A step is strictly bound to a test case, but it can be reused.

Four step types are supported:

  • default
  • linked
  • network request
  • script

Default step

A step that contains a set of actions on a screen.

The following actions are supported:

  • tap
  • swipe
  • text input
  • wait (no interaction)

Linked step

A link step executes the action flow defined in another step.

It is used to reuse logic, reduce duplication, and speed up new test case creation.

Network Request step

A step that sends an HTTP request to a specified URL and validates the response.

Supported HTTP methods: GET, POST, PUT, DELETE, PATCH.

Configurable options:

  • URL — target endpoint
  • Method — HTTP method
  • Headers — request headers as a JSON string
  • Body — request body as a JSON string
  • Expected Status Code — the HTTP status code the response must match
  • Response Parameters — a list of response keys to validate or save to environment variables

Response Parameters support three comparison types:

  • none — no validation; the value can still be saved to an environment variable
  • equal — checks that the response value exactly matches the expected value
  • exists — checks that the key is present in the response

Keys support dot-notation for nested objects (e.g. user.id) and bracket-notation for arrays (e.g. items[0].name).

If a response parameter has an environment key set, the actual response value for that key is saved to the project environment after execution. This value can then be referenced in subsequent steps using $key syntax.

Script step

A step that executes a user-provided bash script on the Mac where Qampanion is running.

Configurable options:

  • Description — step name shown in the test case list
  • Required — if disabled, a script failure does not fail the test case
  • Script — bash script content

During execution Qampanion:

  1. Replaces $KEY placeholders with values from project environment variables.
  2. Runs the script through /bin/bash using stdin.
  3. Marks the step as passed if the script exits successfully (exit code 0).
  4. Marks the step as failed (or skipped if not required) if the script exits with a non-zero code or cannot be executed.

Required option

Each step has a Required setting. It is enabled by default. It meaning that the step is blocking for test-case result.

⚠️ If a step is not blocking, its result does not affect the overall test case outcome, regardless of it’s status.

This setting is recommended for optional or conditional screens (for example, pop-up or system notification).

Expected Result and Assert

Most test cases require validation of intermediate and final application states. To simplify and speed up test creation, a regular Step type is used for expected results and assertions.

⚠️ The usage examples below are based on the Qampanion execution algorithm. See the Qampanion Execution Algorithm section for details.

Step without actions (Expected Result, Assert)

If a step contains no actions, it runs in screenshot comparison mode only.

Such the step can be used as:

  • an expected result
  • a final assert

Step without screenshot, but with actions (Expectation, dynamic screens)

If a step contains actions, but no screenshot, screen comparison is not performed.

Such thr step can be used for:

  • waiting for application loading
  • working with dynamic screens (for example, browser or webview screens)

⚠️ In this mode, only wait and text input actions are available.

Actions

There are 4 action types available in the application. A step has no limits on the number, order, or uniqueness of actions.

Tap

A quick press at a specific point on the screen.

Swipe

A press followed by cursor movement.

⚠️ The initial touch is treated as a tap. Use swipe carefully on screens with interactive elements.

Type

Enters the text without using the system keyboard. This action can be used without an expected screenshot.

⚠️ It is recommended to disable the system keyboard on the device.

Expectation

Pauses test case execution for a specified time (Delay). This action can be used without an expected screenshot.

Test Plan

A Test Plan is used to simplify launch of multiple test cases. Qampanion provides test plans as configurable sets of test cases to run full application flows. Test plans can be configured individually, allowing you to run tests for a specific feature, device, or the entire project.

⚠️ When running a test plan across different platforms, you must manually switch the device in the application header.

Creating New Test Plan

  1. On the project page, open the Test plan section.
  2. Click [ + ], enter a name, and open the created plan.
  3. Use the checkboxes to select which test cases are included in the test plan.

Excluded Zones and Threshold

Qampanion performs screenshot comparison (when screenshots are present) before executing the actions of each step, taking into account the allowed deviation from the expected result.

The comparison mechanism is configured using:

  • Threshold
  • Excluded zone (ignored areas)

Threshold

Threshold is the allowed difference between the current screen state and the expected one, expressed as a percentage.

Value range:

  • 0% — full difference is allowed
  • 100% — even a 1-pixel difference is not allowed

The default value when creating a test case is 95%. The global threshold for whole test case can be changed in the test case settings (“Global Test Case Settings” section)*

Excluded Zone

Application interfaces often contain dynamic elements (animations, timers, avatars, ad banners, etc.). For accurate comparison, you can define Excluded zones — screen areas that will be ignored during comparison. Within a single step, you can add one or more excluded zones of any size and position. You can also define global excluded zones for the test case (link to the “Global Test Case Settings” section). These areas are excluded from the "expected vs actual" screen comparison.

Global Test Case Settings

To simplify configuration, you can set shared Threshold and Excluded zones at the test case level.

Open the test case settings:

Test case → Settings

Excluded zones are defined manually by specifying screen area coordinates. To make this easier, you can copy coordinates from a step where the excluded zone was created through the UI.

When changing the global threshold or excluded zones, two options are available:

  • apply settings to all existing and future steps
  • apply settings only to new steps

Important Notes About Global Excluded Zones

⚠️ Global excluded zones can still be additionally modified inside individual steps.

⚠️⚠️ If you change excluded zones in global test case settings and choose “apply to all steps”, the global zones will be overwritten in every step, regardless of their current values.

⚠️⚠️⚠️ Removing a excluded zone from a step is not reversible. If you delete a excluded zone from a step and later change global settings with “apply to all steps,” the zone will not be restored in that step.

Debug and Launch

Qampanion is based on comparing screenshots of the expected and actual application states. Before executing any actions, each step verifies that the current application state matches the expected one. If the states are different, the step is marked as failed.

The application supports three launch modes:

  • running a test case
  • running a set of test cases
  • running a single step (Debug mode)

Run Test Cases

A single test case is executed by clicking the Launch button (icon).

A full run:

  • removes the previously installed version of the application
  • reinstalls it
  • launch all steps of the test case

Step Statuses

During execution, each step shows its current state and receives a terminal status after completion (Passed / Failed / Skipped).

If the actual screen state does not match the expected one:

  • the step is marked as Failed
  • the test case is considered failed
  • the dropdown menu provides access to:
    • expected screenshot
    • actual screenshot
    • diff between them

Run Test Plans

To validate a feature or story that includes multiple test cases, it is recommended to use a Test plan. For running a test plan, open it and start launch the same way as a single test case.

Status Display

During execution:

  • test case statuses are shown on the test plan page
  • in the overall test case list
  • in opening page with one of test case
  • in the logs panel with details for each test case

You can open any test case from the list and observe its step execution in real time.

Execution Results

After execution completes:

  • terminal statuses for each test case are shown in the test plan and in the test cases list
  • error details are available when opening the failed test case

Run Single Step

This mode is intended for development, adjustments, and quick logic verification (Debug Mode).

To run a single step:

  1. Open the test case.
  2. Choose a step.
  3. Click the Debug button (icon).
  4. Wait until the step launch completes.

⚠️ Debug mode:

  • does not reinstall the application
  • does not reset it to the initial state
  • does not start the simulator/emulator

Debug mode assumes that the device and the application are already in the required state. Step results in Debug mode follow the same validation rules as a full test case run. On success or failure, the step status and screenshot differences are displayed the same way as in a regular launch.

Logs

During test case, test plan, or debug runs, the following events are logged:

  • each executed step
  • each action inside a step

These logs are displayed in a separate panel at the bottom of the screen.

Logs:

  • update in real time
  • reflect the actual execution order
  • preserve the history of the current run

CLI

A command-line tool to work with Qampanion projects. You can get information about devices, test cases, and test plans, and also run tests on a device.

You can access the tool at the following path:

/Applications/Qampanion.app/Contents/MacOS/QampanionCLI

get-devices

Get a list of devices that are available to run tests on.

Parameter Required Description
--os No Filter devices by OS. Use ios or android.
--json No Print the result as JSON.

Example:

QampanionCLI get-devices
QampanionCLI get-devices --os ios
QampanionCLI get-devices --os android --json

get-test-cases

Get a list of test cases from a Qampanion project file.

Parameter Required Description
--project Yes Path to the .qpn project file.
--json No Print the result as JSON.

Example:

QampanionCLI get-test-cases --project "/path/to/Project.qpn"
QampanionCLI get-test-cases --project "/path/to/Project.qpn" --json

get-test-case

Get detailed information about a specific test case, including its steps and actions.

ℹ️ Step snapshots (reference images) are excluded from the output.

Parameter Required Description
--project Yes Path to the .qpn project file.
--test Yes Test case ID. Use get-test-cases to find it.
--json No Print the result as JSON.

Example:

QampanionCLI get-test-case \
  --project "/path/to/Project.qpn" \
  --test "A1B2C3D4-0000-0000-0000-000000000000"

QampanionCLI get-test-case \
  --project "/path/to/Project.qpn" \
  --test "A1B2C3D4-0000-0000-0000-000000000000" \
  --json

get-test-result

Get the saved test result log for a specific test case. The result is written after running the test case via run-test-case or run-test-plan.

Parameter Required Description
--test Yes Test case ID. Use get-test-cases to find it.
--json No Print the result as JSON.

Example:

QampanionCLI get-test-result --test "A1B2C3D4-0000-0000-0000-000000000000"
QampanionCLI get-test-result --test "A1B2C3D4-0000-0000-0000-000000000000" --json

get-test-plans

Get a list of test plans from a Qampanion project file.

Parameter Required Description
--project Yes Path to the .qpn project file.
--json No Print the result as JSON.

Example:

QampanionCLI get-test-plans --project "/path/to/Project.qpn"
QampanionCLI get-test-plans --project "/path/to/Project.qpn" --json

get-ui-hierarchy

Get the current UI element tree from a running device. Returns all visible elements with their coordinates, types, and labels. Coordinates are returned in device pixel space (scaled by the device's scale factor) and can be used directly with perform-action.

Parameter Required Description
--device Yes Device ID. Use get-devices to find it.
--json No Print the result as JSON.

Example:

QampanionCLI get-ui-hierarchy \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549"

QampanionCLI get-ui-hierarchy \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549" \
  --json

Plain-text output format:

<type> | <name> | <elementDescription> | x:<x> y:<y> w:<width> h:<height>

JSON output format:

[
  {
    "id": "A1B2C3D4-0000-0000-0000-000000000000",
    "x": 207.0,
    "y": 375.5,
    "width": 225.0,
    "height": 61.0,
    "type": "StaticText",
    "name": "Test Card",
    "elementDescription": "text"
  }
]

create-test-case

Create a new test case in a Qampanion project file.

Parameter Required Description
--project Yes Path to the .qpn project file.
--name Yes Name of the new test case.
--description No Description of the new test case.
--json No Print the result as JSON.

Example:

QampanionCLI create-test-case \
  --project "/path/to/Project.qpn" \
  --name "Login flow"

QampanionCLI create-test-case \
  --project "/path/to/Project.qpn" \
  --name "Login flow" \
  --description "Verifies login screen" \
  --json

create-step

Create a new step in an existing test case.

Parameter Required Description
--project Yes Path to the .qpn project file.
--test-case-id Yes Test case ID. Use get-test-cases to find it.
--description Yes Description of the new step.
--json No Print the result as JSON.

Example:

QampanionCLI create-step \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --description "Tap login button"

QampanionCLI create-step \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --description "Tap login button" \
  --json

create-linked-step

Create a new linked step in an existing test case. A linked step references another test case, allowing you to reuse existing test logic.

Parameter Required Description
--project Yes Path to the .qpn project file.
--test-case-id Yes Test case ID to add the linked step to. Use get-test-cases to find it.
--name Yes Name of the linked step.
--linked-test-case-id Yes Test case ID that this step links to.
--required No Whether the step is required (default: true). Pass --no-required to make it optional.
--json No Print the result as JSON.

Example:

QampanionCLI create-linked-step \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --name "Re-use login flow" \
  --linked-test-case-id "B2C3D4E5-0000-0000-0000-000000000000"

QampanionCLI create-linked-step \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --name "Optional onboarding" \
  --linked-test-case-id "B2C3D4E5-0000-0000-0000-000000000000" \
  --no-required \
  --json

create-network-request-step

Create a new network request step in an existing test case.

Parameter Required Description
--project Yes Path to the .qpn project file.
--test-case-id Yes Test case ID. Use get-test-cases to find it.
--description Yes Description of the new step.
--url Yes Target URL for the request.
--method Yes HTTP method: get, post, put, delete, patch.
--expected-status-code No Expected HTTP status code (default: 200).
--headers No Request headers as a JSON string (default: empty).
--body No Request body as a JSON string (default: empty).
--json No Print the result as JSON.

Example:

QampanionCLI create-network-request-step \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --description "Login API call" \
  --url "https://api.example.com/login" \
  --method post \
  --expected-status-code 200 \
  --headers '{"Content-Type": "application/json"}' \
  --body '{"username": "test", "password": "123"}' \
  --json

create-comparison-parameter

Create a new response comparison parameter in an existing network request step.

Parameter Required Description
--project Yes Path to the .qpn project file.
--test-case-id Yes Test case ID. Use get-test-cases to find it.
--step-id Yes Network request step ID. Use get-test-case --json to find it.
--description Yes Human-readable description of the parameter.
--key Yes Response key to validate. Supports dot-notation (e.g. user.id) and bracket-notation (e.g. items[0].name).
--comparison-type Yes Comparison type: without (no validation), equal (exact match), exists (key presence).
--expected-value No Expected value. Required when --comparison-type is equal.
--environment-key No Environment key to save the response value to after execution.
--json No Print the result as JSON.

Example:

# Check status field equals "active"
QampanionCLI create-comparison-parameter \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --step-id "B2C3D4E5-0000-0000-0000-000000000000" \
  --description "Status is active" \
  --key "status" \
  --comparison-type equal \
  --expected-value "active"

# Check key exists and save value to environment
QampanionCLI create-comparison-parameter \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --step-id "B2C3D4E5-0000-0000-0000-000000000000" \
  --description "User ID exists" \
  --key "user.id" \
  --comparison-type exists \
  --environment-key "userId" \
  --json

create-script-step

Create a new bash script step in an existing test case.

Parameter Required Description
--project Yes Path to the .qpn project file.
--test-case-id Yes Test case ID. Use get-test-cases to find it.
--description Yes Description of the new step.
--script Yes Bash script content to execute.
--json No Print the result as JSON.

Example:

QampanionCLI create-script-step \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --description "Clean build artifacts" \
  --script "rm -rf /tmp/build-output && echo 'cleaned'" \
  --json

create-action

Create a new action in an existing step.

Parameter Required Description
--project Yes Path to the .qpn project file.
--test-case-id Yes Test case ID. Use get-test-cases to find it.
--step-id Yes Step ID. Use get-test-case --json to find it.
--description Yes Description of the new action.
--type Yes Action type: tap, swipe, type, wait.
--x No X coordinate for tap action (default: 0).
--y No Y coordinate for tap action (default: 0).
--from-x No Start X coordinate for swipe action (default: 0).
--from-y No Start Y coordinate for swipe action (default: 0).
--to-x No End X coordinate for swipe action (default: 0).
--to-y No End Y coordinate for swipe action (default: 0).
--text No Text to input for type action (default: empty string).
--seconds No Duration in seconds for wait action (default: 0).
--json No Print the result as JSON.

Example:

# tap
QampanionCLI create-action \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --step-id "B2C3D4E5-0000-0000-0000-000000000000" \
  --description "Tap on submit" \
  --type tap \
  --x 540 --y 1200

# swipe
QampanionCLI create-action \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --step-id "B2C3D4E5-0000-0000-0000-000000000000" \
  --description "Swipe up" \
  --type swipe \
  --from-x 500 --from-y 1500 --to-x 500 --to-y 500

# type
QampanionCLI create-action \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --step-id "B2C3D4E5-0000-0000-0000-000000000000" \
  --description "Enter username" \
  --type type \
  --text "user@example.com"

# wait
QampanionCLI create-action \
  --project "/path/to/Project.qpn" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --step-id "B2C3D4E5-0000-0000-0000-000000000000" \
  --description "Wait for animation" \
  --type wait \
  --seconds 3

take-snapshot

Take a screenshot from a running device and save it as the reference snapshot for a specific test step. This snapshot will be used as the expected baseline during future test runs.

Parameter Required Description
--project Yes Path to the .qpn project file.
--device Yes Device ID. Use get-devices to find it.
--test-case-id Yes Test case ID. Use get-test-cases to find it.
--step-id Yes Step ID. Use get-test-case --json to find it.

Example:

QampanionCLI take-snapshot \
  --project "/path/to/Project.qpn" \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549" \
  --test-case-id "A1B2C3D4-0000-0000-0000-000000000000" \
  --step-id "B2C3D4E5-0000-0000-0000-000000000000"

run-test-case

Run one test case on a device. The tool installs the app, launches it, and runs the test steps.

Parameter Required Description
--project Yes Path to the .qpn project file.
--bundle Yes Path to the .app file, or a URL to download it from.
--device Yes Device ID. Use get-devices to find it.
--test Yes Test case ID. Use get-test-cases to find it.

Example:

QampanionCLI run-test-case \
  --project "/path/to/Project.qpn" \
  --bundle "/path/to/App.app" \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549" \
  --test "A1B2C3D4-0000-0000-0000-000000000000"

run-test-plan

Run a test plan on a device. A test plan is a group of test cases that run one by one.

Parameter Required Description
--project Yes Path to the .qpn project file.
--bundle Yes Path to the .app file, or a URL to download it from.
--device Yes Device ID. Use get-devices to find it.
--plan Yes Test plan ID. Use get-test-plans to find it.

Example:

QampanionCLI run-test-plan \
  --project "/path/to/Project.qpn" \
  --bundle "/path/to/App.app" \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549" \
  --plan "EC0888D0-AED4-406C-B4F8-199625929A87"

perform-action

Perform an interactive action on a running device without running a full test case. Useful for exploratory testing and AI-assisted test creation. Coordinate values must match the device pixel space returned by get-ui-hierarchy.

Parameter Required Description
--project Yes Path to the .qpn project file (used for environment variable substitution in type actions).
--device Yes Device ID. Use get-devices to find it.
--type Yes Action type: tap, swipe, type, wait.
--x No X coordinate for tap action.
--y No Y coordinate for tap action.
--from-x No Start X coordinate for swipe action.
--from-y No Start Y coordinate for swipe action.
--to-x No End X coordinate for swipe action.
--to-y No End Y coordinate for swipe action.
--text No Text to input for type action.
--seconds No Duration in seconds for wait action.

Example:

# tap
QampanionCLI perform-action \
  --project "/path/to/Project.qpn" \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549" \
  --type tap \
  --x 319 --y 406

# swipe
QampanionCLI perform-action \
  --project "/path/to/Project.qpn" \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549" \
  --type swipe \
  --from-x 500 --from-y 1500 --to-x 500 --to-y 500

# type
QampanionCLI perform-action \
  --project "/path/to/Project.qpn" \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549" \
  --type type \
  --text "user@example.com"

# wait
QampanionCLI perform-action \
  --project "/path/to/Project.qpn" \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549" \
  --type wait \
  --seconds 2

launch-app

Install and launch an application on a device. Boots the device automatically if it is not running. Pass --reinstall to uninstall the existing version before installing.

Parameter Required Description
--device Yes Device ID. Use get-devices to find it.
--bundle Yes URL to the application bundle (local path or http(s):// URL).
--reinstall No Uninstall the app before installing (disabled by default).

Example:

# Just install and launch (default)
QampanionCLI launch-app \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549" \
  --bundle "/path/to/App.app"

# Full reinstall: uninstall, then install and launch
QampanionCLI launch-app \
  --device "0EBECE94-2084-4F51-8591-9A82A8C3B549" \
  --bundle "https://example.com/App.zip" \
  --reinstall

MCP

An MCP (Model Context Protocol) server that exposes Qampanion functionality to AI assistants. It allows AI tools to interact with your projects, devices, and tests directly.

The server binary is located at:

/Applications/Qampanion.app/Contents/MacOS/QampanionMCP

Connecting to an AI

Add the following configuration to your AI client's MCP settings (e.g., Claude Desktop, Cursor, or any MCP-compatible client):

{
  "mcpServers": {
    "qampanion": {
      "command": "/Applications/Qampanion.app/Contents/MacOS/QampanionMCP"
    }
  }
}

You can also install SKILL for your AI agent to improve its understanding of Qampanion's capabilities.

Available Tools

  • get_devices — Get a list of devices available to run tests on.
  • get_test_cases — Get a list of test cases from a Qampanion project.
  • get_test_case — Get detailed information about a specific test case, including its steps.
  • get_test_plans — Get a list of test plans from a Qampanion project.
  • get_test_result — Get the saved test result log for a specific test case.
  • create_test_case — Create a new test case in a Qampanion project.
  • create_step — Create a new step inside an existing test case.
  • create_linked_step — Create a new linked step inside an existing test case that references another test case.
  • create_action — Create a new action inside an existing step.
  • create_network_request_step — Create a new network request step inside an existing test case.
  • create_comparison_parameter — Create a new response comparison parameter in an existing network request step.
  • create_script_step — Create a new bash script step inside an existing test case.
  • run_test_case — Run a test case on a device.
  • run_test_plan — Run a test plan on a device.
  • get_ui_hierarchy — Get the current UI element tree from a running device, with coordinates ready for use in perform_action.
  • perform_action — Perform an interactive action (tap, swipe, type, wait) on a running device.
  • take_snapshot — Take a screenshot from a running device and save it as the reference snapshot for a test step.
  • launch_app — Install and launch an application on a device. Supports optional uninstall before install (reinstall mode).