# Welcome to TestFirst **TestFirst** is a **full-stack QA platform** designed to help teams turn product knowledge into reliable test coverage. Start from requirements, generate structured test cases, automate workflows, and track results — all in one workspace. TestFirst supports the full testing lifecycle, from understanding requirements to generating tests, running tests, and reviewing results. You can start without writing code and expand into advanced automation as your testing needs grow. ### What you can do with TestFirst * Start testing directly from **requirements, specifications, or design documents** * **Generate AI-assisted test case drafts** * Refine test cases using the **TestFirst Editor or the Recorder** * Run automated tests **in the cloud** * Track **execution progress, failures, and results** You can begin without writing code, and gradually expand into more advanced automation workflows as your testing needs grow. ### Jump right in
Cover image

:bolt:

QuickstartCreate, run, and review your first automated test case in minutes./files/MC5HdInmtxlpEBIEgLw8/pages/7FvWQMF0kTK7HGhlQfmo

:leaf:

Test ScopesOrganize requirements, generate tests, and manage testing for a feature or module./files/lymZkIOolYJOX63bz9IL/pages/C3PK9ydRXsyJQLO7CJuz

:globe-pointer:

Editor BasicsLearn how to write and edit tests using the TestFirst editor, selectors, and data repository./files/jLBWiayZUZ0DjMhNKikK/pages/mktsCgbmKhQ6URJTaYmm
## How TestFirst Works TestFirst organizes testing through a structured workflow built around three core components: **Test Scopes, Test Cases, and Test Execution**. Test Scopes define what needs to be tested, Test Cases describe the scenarios to verify, and Test Execution runs those tests and records the results, including outcomes and any defects found. At a high level, the platform follows this flow: ``` Test Scope ↓ Test Cases ↓ Test Execution ↓ Results & Issues ``` Each layer builds on the previous one and helps teams maintain structured and repeatable testing. *** ### Test Scopes A **Test Scope** defines the area of the product you want to test. It acts as the workspace where you: * organize test cases * generate tests from documentation * run tests and track results Scopes help keep testing focused on a specific feature, module, or release. ### Test Cases A **Test Case** describes a scenario you want to verify. Test cases can be: * generated from source documents * written manually * automated using the Recorder Test cases can also be reused from the **Test Case Library** across multiple scopes. ### Test Execution When tests are executed, TestFirst creates a **Test Plan** and records the results as a **Test Run**. Execution tracks: * pass or fail status * execution details * logs and artifacts from the run This makes it easy to monitor the quality of the system over time. ### Results and Issues After execution, you can review results and investigate failures. When problems are found, issues can be created and tracked directly from the testing workflow. This keeps testing results connected with development and debugging. *** ### How the Pieces Fit Together Most teams use TestFirst in a repeating cycle: ``` Define scope ↓ Add or generate tests ↓ Run tests ↓ Review results ↓ Improve tests ``` This cycle helps teams continuously expand and maintain reliable test coverage. # Quickstart ### Create, Run, and Review Your First Automated Test This quickstart guide walks you through the core TestFirst workflow—from defining what to test to running your first automated test. Before you begin, you’ll need a **TestFirst account**. [Sign up](https://www.testfirst.com/plans) using your email or Google account. Once you’re signed in, you can start testing immediately. You don’t need prior QA experience.\ If you can describe how a feature works, TestFirst helps you turn that knowledge into structured tests. ### What You’ll Achieve By the end of this guide, you will have: * Created a **Test Scope** * Generated **AI-assisted test cases** * Completed a test using the **Recorder** * Run a test * Viewed the **test results** ### The Big Picture ``` Requirement / Specification ↓ Test Scope ↓ AI-generated Test Cases ↓ Automate Test Case ↓ Run Test ↓ View Results ``` This workflow helps you move from **product knowledge to test coverage** quickly. ### Step 1: Create Your First Test Scope A **Test Scope** defines what you want to test. It typically represents a feature, module, or release. Examples include: * Login functionality * Checkout flow * A new feature * Regression testing for a release #### Create a Test Scope 1. Open **Test Scopes** from the sidebar 2. Click **+ New Test Scope** 3. Enter a **scope title** *(optional)*\ If left empty, TestFirst generates one automatically. 4. Upload a requirement or design document\ Supported formats include **TXT, Markdown, DOCX, and PDF**.\ You can also use the **demo file** to get started quickly. 5. Click **Create** :star2: Your Test Scope is now ready. *** ### Step 2: Generate Test Cases Once your scope is created, TestFirst can generate draft test cases automatically. #### Generate test cases 1. Click **Generate Test Cases** 2. TestFirst analyzes your uploaded documents 3. Draft test cases are generated automatically You may see two types of suggestions: * **AI-generated test cases** based on your documents * **Recommended tests from your Test Library** (if available) #### Review and select tests 1. Review the generated test cases 2. Select the ones you want to include 3. Click **Add** These tests are now part of your Test Scope. *** ### Step 3: Open the Test Case in the Editor and Complete the Test Case Before tests can be executed, each test case must be **completed**. Completing a test case means either: * **Automating it**, or * **Writing the steps manually** using the **TestFirst Editor** #### Recommended: Use the Recorder The **Recorder** is the fastest way to create automated tests. 1. In your Test Scope, click the :pencil: **Edit** icon on a test case 2. The test case opens in the **TestFirst Editor** 3. Click **Recorder** 4. Download and install the **Utilities Pack** if prompted, and run the **Test Runner** 5. Enter the **website URL** 6. Record the test by performing actions such as: * Clicking elements * Typing input * Verifying page content 7. Set the test case status to **Ready for Testing** 8. Save the test case Your automated test is now ready :tada: *** ### Step 4: Run the Test Back in your Test Scope: 1. Refresh the page, then click **Run Test** 2. Select the test cases to execute 3. Click **Run** #### What happens automatically * A **Test Plan** is created * The test plan is sent for execution * The run appears under **Last Test Runs** *** ### Step 5: View Test Results To see results: * Click the **Test Run** link in your Test Scope From there, you can: * See pass/fail status * Open execution details * Review screenshots and logs * Generate reports *** ### You’re Done! 🎉 You’ve just completed the full TestFirst workflow: ✔ Defined what to test\ ✔ Generated test cases\ ✔ Automated a test\ ✔ Executed the test\ ✔ Viewed the results You now have a working automated test in TestFirst. *** ### What to Do Next Continue exploring TestFirst: * Add more test cases to the same scope * Create a new scope for another feature * Explore your Test Case Library organization * Generate reports from Test Runs # What Can I Automate? TestFirst provides **Unified Test Automation**, allowing teams to automate multiple technologies, workflows, and end-to-end business processes using a single editor, shared test structure, and natural language test steps. With TestFirst, you can perform: #### 🌐 Web Automation Automate browser-based applications, user interfaces, and end-to-end user journeys. ```gherkin Given browser "Chrome" When I visit "https://testfirst.com" Then "START NOW" is displayed ``` *** #### 📱 Mobile Automation Automate Android applications running on emulators or existing devices. ```gherkin Given application "{Android apps.TestFirst Sample 1}" And mobile device "{Devices.Android.Pixel 10}" When I run application ``` *** #### 🔌 API Testing Send requests and validate backend services and integrations. ```gherkin Given GET HTTP request When I send request to "https://bit.ly/SampleEndpointUrl" Then response status should be 200 ``` *** #### 🖥️ Shell & SSH Automation Execute commands and validate behaviour on remote systems. ```gherkin When I execute command "systemctl status nginx" Then command output should contain "active" ``` *** #### 🔄 Cross-Platform End-to-End Testing Combine multiple automation types within the same test case. ``` Mobile → Web → API → Shell ``` ## One Platform, Multiple Automation Types Regardless of what you are testing, all automation is created and executed using the same: * TestFirst Editor * Natural language syntax * Data Repository * Reusable Fragments * Execution and reporting workflow This unified approach allows teams to automate complete business processes without switching between multiple testing tools and frameworks. # Web Automation Automate browser-based applications using natural language test steps or the Recorder. Create automated tests for user journeys such as signing in, submitting forms, navigating pages, validating content, and interacting with complex web applications, all without traditional scripting. ```gherkin Scenario: Step 1 - Visit testfirst.com and check for "Forgot password?" link Given browser "Chrome" When I visit "https://www.testfirst.com/" And I click "Sign In" And I wait for 2 seconds Then "Sign In" page is displayed Scenario: Step 2 - User tries login with a wrong username and password When I wait for 2 seconds And I visit "https://www.testfirst.com/" And I click "Sign In" And I type "test_user" in "Username" And I type "Password" in "Password" And I click "SIGN IN" Then "Invalid username/email or password" is displayed ``` **Learn more:** * [Writing Automated Test Cases](/testfirst-editor/writing-test-cases) * [Record Test Cases using the Recorder](/testfirst-editor/writing-test-cases/record-test-cases) * [Running & Debugging Tests](/testfirst-editor/run-and-debug-tests) * [Multi-Tab & Multi-Window Support](/testfirst-editor/advanced-test-capabilities#multi-tab-and-multi-window-testing) * [iFrame Support](/testfirst-editor/advanced-test-capabilities#iframe-support) * [Fragments](/testfirst-editor/fragments) # Mobile Automation ## Android Mobile Automation Automate Android applications using the TestFirst Editor, natural language syntax, and execution workflow used for other automation types. Mobile automation supports Android emulators and existing devices, allowing you to launch applications, interact with mobile UI elements, validate application behaviour, and execute end-to-end user journeys without traditional scripting. **Example** ```gherkin Scenario: Start emulator and run the app Given application "{Android apps.Reddit}" Given mobile device "{Devices.Android.My device}" When I run application ``` Mobile automation is fully integrated into TestFirst's **Unified Test Automation** approach, allowing mobile tests to be combined with web, API, and other automation types within the same test case. **Learn more:** * [Android Mobile Automation](/testfirst-editor/android-mobile-automation) * [Inspect Mobile Applications](/testfirst-editor/android-mobile-automation/inspect-mobile-applications) * [Write a Mobile Test](/testfirst-editor/android-mobile-automation/write-mobile-tests) * [Run Mobile Tests](/testfirst-editor/android-mobile-automation/run-mobile-tests) # API Testing Validate APIs and backend services directly from the TestFirst Editor using natural language test steps. API testing allows you to send requests, validate responses, extract data, and verify integrations without interacting with a user interface. API tests can be executed independently or combined with other automation types as part of an end-to-end testing workflow. **Example** ```gherkin Scenario: Get user details Given GET HTTP request When I send request to "{Endpoints.Users}" Then response status should be 200 ``` API testing is fully integrated into TestFirst's **Unified Test Automation** approach, allowing API tests to work seamlessly with web, mobile, and other automation types within the same test case. **Learn more:** * [Write Test Cases using Gherkin](/testfirst-editor/writing-test-cases/write-test-cases-with-gherkin) * [Endpoints](/data-repository/data-repository/endpoints) * [Variables](/data-repository/data-repository/variables) * [Environments](/data-repository/data-repository/environments) * [Fragments](/testfirst-editor/fragments) # Shell & SSH Automation Execute commands on remote systems and validate infrastructure behavior directly from the TestFirst Editor using natural language test steps. Commands can be executed independently or combined with other automation types as part of an end-to-end workflow. **Example** ```gherkin Scenario: Establish shell session and run a command Given shell session to """ { "type": "ssh", "host": "test.rebex.net", "port": 22, "basicAuth": { "username": "demo", "password": "password" } } """ When I run command "whoami" Then command should complete successfully And command output should contain "demo" ``` Shell and SSH automation are fully integrated into TestFirst's **Unified Test Automation** approach, allowing command-line validation to work seamlessly with web, mobile, and API automation within the same test case. **Learn more:** * [Write Test Cases using Gherkin](/testfirst-editor/writing-test-cases/write-test-cases-with-gherkin) * [Endpoints](/data-repository/data-repository/endpoints) * [Variables](/data-repository/data-repository/variables) * [Environments](/data-repository/data-repository/environments) * [Fragments](/testfirst-editor/fragments) * Cross-Platform Test Automation # End-to-End Testing TestFirst allows multiple automation types to be combined within a single test case. A workflow can span mobile applications, web applications, APIs, and remote systems while using the same editor, test structure, and execution model. **Example workflow** ``` Mobile Application ↓ Web Application ↓ API Validation ↓ Shell / SSH Verification ``` **Example** {% hint style="info" icon="dot" %} The example below starts in a mobile application, continues in a web browser, validates an API, and finally verifies the server state. {% endhint %} ```gherkin Scenario: Launch mobile application Given application "{Android apps.TestFirst Sample 1}" And mobile device "{Devices.Android.Pixel 10}" When I run application And I tap "Submit" Scenario: Continue in web application Given browser "Chrome" When I visit "https://testfirst.com" And I click "Sign in" Scenario: Validate backend service Given GET HTTP request When I send request to "{Endpoints.Tasks}" Then response status should be 200 Scenario: Verify server state Given shell session "{Endpoints.Linux Server}" When I execute command "tail -100 /var/log/application.log" Then output should contain "Task Created" ``` {% hint style="success" icon="dot" %} End-to-end testing workflows are particularly useful for validating complete business processes that span multiple systems and technologies. {% endhint %} **Learn more:** * [Write Test Cases using Gherkin](/testfirst-editor/writing-test-cases/write-test-cases-with-gherkin) * [Endpoints](/data-repository/data-repository/endpoints) * [Variables](/data-repository/data-repository/variables) * [Fragments](/testfirst-editor/fragments) * [Mobile Automation](/testfirst-editor/android-mobile-automation) # Test Scopes Overview ``` Test Scopes generate coverage and draft test cases from source documents. ``` A **Test Scope** is the workspace in TestFirst used to define and manage testing for a specific feature, module, or release item. Within a scope, teams can collect product context, generate test coverage, manage test cases, and execute tests in one place. A Test Scope represents a **complete testing package** for any functional unit of work. ## What You Can Do in a Test Scope Within a Test Scope you can: * Upload requirement or design documents * Generate **test coverage** and draft test cases * Combine generated tests with items from the **Test Case Library** * Organize tests into suites or sections * Run tests and track execution results This keeps all testing activities for a feature organized within a single workspace. ## Coverage and Test Cases When TestFirst analyzes source files, it generates **test coverage** for the feature being tested. Coverage represents the set of behaviors, flows, and scenarios identified in the uploaded requirements or design documents. From this coverage, TestFirst creates draft test cases that verify those scenarios. Coverage helps teams understand: * which parts of a feature are already tested * which scenarios may still require additional tests * how complete the testing is for that scope This makes it easier to track testing progress at the **feature or release level**. *** ### Typical Workflow Testing within a scope usually follows this cycle: ``` Add Product Context(Source Files) ↓ Generate Coverage and Draft Test Cases ↓ Review and Select Test Cases ↓ Record/ Write Test Cases ↓ Run Tests ↓ Review Results ``` As development evolves, scopes can be updated and executed again to maintain reliable coverage. ### When to Use Test Scopes Use a Test Scope whenever you want to organize testing for a specific unit of work, such as: * a new feature * a product module * a release or regression cycle * a bug fix or improvement Scopes keep related requirements, coverage, tests, and results connected. # Create a Test Scope Create a **Test Scope** to start organizing testing for a feature, module, or release item. A scope acts as the workspace where requirements, test cases, and execution results are grouped together. ### Steps to Create a New Scope {% stepper %} {% step %} Open Test Scopes in the left navigation {% endstep %} {% step %} Click + New Test Scope {% endstep %} {% step %} (Optional) Upload source files {% endstep %} {% step %} Enter a Scope Title *(TestFirst can automatically generate a title when files are uploaded.)* {% endstep %} {% step %} Select a Project *(TestFirst can generate a new project from uploaded sources.)* {% endstep %} {% step %} Click Create {% endstep %} {% step %} (Optional) [Generate Test Cases](/test-scopes/prepare-test-cases) * Review & select test cases when test cases are generated. * Click Add. {% endstep %} {% endstepper %} New test cope will be created and the scope detail page will appear on the page. *** ### Upload Source Files Source files provide product context that can later be used to generate testing artifacts. You can upload files when creating a scope or add them later from the scope detail page. To upload files: 1. Open the **Test Scope Detail Page**. 2. Scroll to the **Sources** section, click number of sources link. 3. **Upload Files** or drag and drop files in Test Scope Sources modal. The **AI Capacity Bar** updates as files are added. ### Manage Source Files From the **Sources** section you can also: * Download existing files * Delete files These actions allow teams to update the product context as requirements evolve. ### Supported File Types The following file types are supported: * `.txt` * `.md` * `.docx` * `.pdf` {% hint style="info" %} Demo files can also be uploaded for testing purposes. {% endhint %} ### Source File Rules When uploading files: * Maximum size: **30 MB per file** * Duplicate files are **blocked** * Empty files are **rejected** These checks ensure uploaded files can be processed correctly. # Prepare Test Cases Test Scopes allow you to generate, review, and organize test cases for the feature or module being tested. Test cases can be generated automatically from uploaded source files or added from the **Test Case Library**. ## Generate Test Cases If source files are available in the scope, TestFirst can analyze them to generate draft test cases. You can generate test cases: * during **initial scope creation** * anytime from **Sources → Generate test cases** ### What Happens During Generation TestFirst analyzes uploaded source files and extracts: * functional requirements * expected behaviors * user flows * constraints and edge cases From this analysis, the system produces: * **coverage** of the feature behavior * a draft hierarchy of **suites, sections, and test cases** This structure provides an initial testing framework that can be reviewed before being added to the scope. ### Handling Low-Quality Inputs The quality of generated tests depends on the quality of the uploaded files. Possible outcomes: * If **all files contain little useful information**, generation may produce minimal output or display a warning. * If **at least one file contains useful information**, meaningful test scenarios can still be generated. Duplicate tests with the same name and folder are removed automatically. *** ## Review Generated Test Cases After generation, a **review screen** appears where you select the tests that should be added to the scope. The review interface contains two panels: | Panel | Purpose | | ----------- | ---------------------------------- | | Left panel | Displays generated test cases | | Right panel | Shows tests selected for the scope | Generated items may include: * **NEW** – AI-generated test cases * **EXISTING** – tests already available in the Test Case Library ### Select Test Cases During review you can: * select or deselect individual tests * select all tests within a folder * expand or collapse the test hierarchy Once confirmed, selected tests are automatically added to the **Test Scope**. *** ## Add Test Cases from the Library Existing tests can also be added from the **Test Case Library**. To add tests from the library: 1. Open the **Test Scope Detail Page** 2. Click **+ Add From Library** 3. Browse the library hierarchy 4. Select the tests to include The library browser displays: * full test hierarchy *(suites, sections, subsections, test cases)* * test status *(Draft / Ready for testing)* Items that are already present in the scope are automatically filtered out. Selected items appear in the **Test Cases Tree**. *** ## Manage Test Cases in the Scope All tests added to the scope appear in the **Test Cases Tree**. From this tree you can organize and manage tests within the scope. ### Remove From Scope This action: * removes the test from the current scope * **does not delete the test from the Test Case Library** This is useful when a test should not be included in this scope but may still be used elsewhere. ### Remove Permanently This action deletes the test globally. Key rules: * requires **Test Case Delete** permission * removes the test from the **Test Case Library** * affects **all scopes referencing the test** #### Folder Deletion Rules A folder cannot be deleted if: * some child tests exist elsewhere in the library * some tests are not visible within the current scope This prevents accidental deletion of shared test structures. *** ## Complete Draft Test Cases Before tests can be executed, each **draft test case must be completed**. Completing a test case means defining the steps that verify the expected behavior of the system. A test case can be completed in two ways: by automating it using the Recorder or by defining the steps manually in the Test Case Editor. ### :robot: Automate the Test Case using the Recorder Test cases can be automated using the [Recorder](broken://pages/u54yXXq4Xo4sIXQWPHMQ), a tool available inside the **TestFirst Editor** which captures browser interactions and converts them into automated test steps. These recorded steps become part of the test case and can later be edited, extended, or combined with manually written steps. This approach is commonly used for **UI test automation** and allows tests to be created without writing code. ### :person:Write Test Steps Manually Test cases can also be completed manually using the [**TestFirst Editor**](broken://pages/KAmY9JD2xnlHb59rvRQ0). In the editor you can define: * Preconditions * Test steps * Expected results Manual completion is useful for tests that cannot be automated using recorder. Once a test case is completed, it can be marked as **Ready for testing** and included in test execution. # Run Tests Test cases within a Test Scope can be executed to verify the behavior of the feature or module being tested. Running tests creates a **Test Plan** and records the results as a **Test Run**. ### Run Tests in a Scope To run tests: 1. Open the **Test Scope Detail Page**. 2. Click **Run Test**. 3. Select the test cases you want to execute. 4. Click **Run**. TestFirst creates a **Test Plan** and sends it for execution. *** #### What Happens During Execution When a run starts: * a **Test Plan** is created for the selected tests * the tests are executed using the configured environment * execution results are recorded automatically The run then appears in the **Last Test Runs** section of the scope. *** ### View Test Runs Each scope shows the most recent test executions. From the **Last Test Runs** section you can: * open a test run * view pass or fail status * inspect execution details * review screenshots and failure details This allows teams to quickly understand the current testing status of the scope. # Manage Scope Settings Scope settings control the lifecycle of a **Test Scope**. From the scope detail page, you can complete a scope when testing is finished, restore it if testing needs to continue, or delete it permanently. *** ### Complete a Test Scope Mark a test scope as **Complete** when testing for that feature or release is finished. Completing a scope indicates that the testing work in that scope is done and no further changes are expected. #### Complete a scope 1. Open the **Test Scope Detail Page**. 2. Click the **⋯ (More options)** menu in the top-right corner. 3. Select **Complete Test Scope**. The scope will be marked as **Completed** and moved to the **Completed Test Scopes** list. *** ### Restore a Completed Scope A completed scope can be restored if additional testing is required. #### Restore a scope 1. Open **Test Scopes** from the left navigation. 2. Click **Completed Test Scopes**. 3. Select the scope you want to restore. 4. Open the **Scope Detail Page**. 5. Click **Restore**. The scope will return to the active **Test Scopes** list. *** ### Delete a Test Scope Deleting a scope permanently removes it from the system. This action should only be performed if the scope and its test results are no longer needed. #### Delete a scope 1. Open the **Test Scope Detail Page**. 2. Click the **⋯ (More options)** menu in the top-right corner. 3. Select **Delete**. 4. Confirm the deletion. Once deleted, the scope cannot be recovered. *** ### When to Use These Actions | Action | When to Use | | -------------- | ----------------------------------------------- | | Complete Scope | Testing for the feature or release is finished | | Restore Scope | Additional testing is required after completion | | Delete Scope | The scope is no longer needed | # Test Case Library The **Test Case Library** is the central repository for all test cases created within your organization in TestFirst. Test cases are organized in a **hierarchical tree structure** consisting of: * Projects * Suites * Sections * Subsections * Test Cases A test case can be created under **any node in the tree**, allowing you to structure your library in a way that best fits your product or testing strategy. *** #### Configure Visible Columns 1. **Right-click** on any column header in the Test Case Library table. 2. A context menu will appear showing all available columns. 3. **Check** the columns you want to display. 4. **Uncheck** the columns you want to hide. {% hint style="info" %} Column visibility settings help reduce clutter and focus on the information most relevant to your workflow. {% endhint %} *** ### Filters in the Test Case Library Filters allow you to narrow down test cases based on specific criteria such as status, priority, owner, or other attributes. Filters can be applied to any column, and multiple column filters can be active at the same time. #### Apply a Filter 1. Click the **filter icon (funnel)** in the header of the column you want to filter. 2. Select the filtering criteria from the list of available options. 3. Click **FILTER** to apply the filter. 4. Click **✕** to close the filter menu. When a filter is active, the filter icon turns **green**. #### Clear a Filter 1. Click the **filter icon** on the filtered column. 2. Click **CLEAR** to remove the filter. The table will refresh to show all items again. # Projects A **Project** is the **top-level container** in the Test Case Library. All test cases, suites, and sections are organized under a project. You can create **multiple projects** within an organization to separate testing by product, application, or major feature area. {% hint style="info" %} Test project names must be **unique within the organization.** {% endhint %} ### Who Can Manage Projects? | Action | Required Permission | | -------------- | ------------------------ | | Create project | Create/Edit Test Project | | Edit project | Create/Edit Test Project | | Delete project | Delete Test Project | Permissions are managed in [**Roles and Permissions**](/administration/roles-and-permissions). *** ### How to Create a Project #### Steps 1. Click **Test Case Management** in the left navigation. 2. Click **+ CREATE NEW PROJECT** 3. Enter: **Name** (required) 4. Click **CREATE** *** ### How to Edit a Project #### Steps 1. Right-click the project 2. Select **Edit** 3. Update the name 4. Click **SAVE** *** ### How to Delete a Project #### Steps 1. Right-click the project 2. Select **Delete** 3. Confirm by clicking **YES** ### What Happens When a Project Is Deleted? * ❌ Deletion is **permanent** * 🧹 All child items are deleted: Suites/ Sections and subsections/ Test cases * 📋 Existing test plans are **not affected** * Tests and results already included in test plans remain unchanged # Suites, Sections & Subsections Suites, Sections, and Subsections are used to organize test cases within a test project.\ They help structure large test libraries by grouping related test cases in a clear, hierarchical way. *** #### Where They Fit in the Test Case Library The Test Case Library follows this hierarchy: ``` Project └─ Test Suite └─ Section └─ Subsection └─ Test Case ``` * **Suites** belong directly to a **Test Project** * **Sections** belong to a **Suite** * **Subsections** belong to a **Section** * **Test cases** can be created at any level of the library tree, from the test project down to a subsection. *** {% tabs %} {% tab title="Test Suites" %} ## Test Suites A **Test Suite** is the primary grouping mechanism under a test project. Test suites group test cases by feature, module, or functional area and act as the parent container for sections and test cases. {% hint style="info" %} Suite names must be **unique within the same project** {% endhint %} ### Who Can Manage Test Suites? | Action | Required Permission | | ----------------- | ---------------------- | | Create test suite | Create/Edit Test Suite | | Edit test suite | Create/Edit Test Suite | | Delete test suite | Delete Test Suite | Permissions are managed in [**Roles and Permissions**](/administration/roles-and-permissions). *** ### How to Create a Test Suite **Steps** 1. Right-click the **Project** where the suite should be created 2. Select **Add Test Suite** 3. Enter: * **Name** (required) 4. Click **CREATE** The suite appears under the selected project in the Test Case Library. *** ### How to Edit a Test Suite **Steps** 1. Right-click the test suite 2. Select **Edit** 3. Update the name 4. Click **SAVE** *** ### How to Copy a Test Suite Link You can share a direct link to a test suite. **Steps** 1. Right-click the test suite 2. Select **Copy Link** 3. Share the copied link using your preferred method *** ### How to Delete a Test Suite **Steps** 1. Right-click the test suite 2. Select **Delete** 3. Confirm by clicking **YES** {% hint style="warning" %} Deleting a suite permanently removes all its sections and test cases. {% endhint %} {% endtab %} {% tab title="Sections" %} ## Sections **Sections** help group related test cases inside a suite, improving readability and maintainability. {% hint style="info" %} Section names must be **unique within the same suite** {% endhint %} ### Who Can Manage Test Sections? | Action | Required Permission | | ------------------- | ------------------------ | | Create test section | Create/Edit Test Section | | Edit test section | Create/Edit Test Section | | Delete test section | Delete Test Section | Permissions are managed in [**Roles and Permissions**](/administration/roles-and-permissions). *** ### How to Create a Section **Steps** 1. Right-click the **Test Suite** 2. Select **Add Section** 3. Enter: * **Name** (required) 4. Click **CREATE** *** ### How to Edit a Section **Steps** 1. Right-click the section 2. Select **Edit** 3. Update the name 4. Click **SAVE** *** ### How to Copy a Test Section Link You can share a direct link to a test section. **Steps** 1. Right-click the test section 2. Select **Copy Link** 3. Share the copied link using your preferred method *** ### How to Delete a Section **Steps** 1. Right-click the section 2. Select **Delete** 3. Confirm by clicking **YES** {% hint style="warning" %} Deleting a section permanently removes all its subsections and test cases. {% endhint %} {% endtab %} {% tab title="Subsections" %} ## Subsections A **Subsection** is a nested section used for deeper organization inside a section. {% hint style="info" %} Subsection names must be **unique within the same section** {% endhint %} ### Who Can Manage Test Subsections? | Action | Required Permission | | ---------------------- | --------------------------- | | Create test subsection | Create/Edit Test Subsection | | Edit test subsection | Create/Edit Test Subsection | | Delete test subsection | Delete Test Subsection | Permissions are managed in [**Roles and Permissions**](/administration/roles-and-permissions). *** ### How to Create a Subsection **Steps** 1. Right-click the **Section** 2. Select **Add Subsection** 3. Enter: * **Name** (required) 4. Click **CREATE** *** ### How to Edit a Subsection **Steps** 1. Right-click the subsection 2. Select **Edit** 3. Update the name 4. Click **SAVE** *** ### How to Copy a Test Subsection Link You can share a direct link to a test subsection. **Steps** 1. Right-click the test subsection 2. Select **Copy Link** 3. Share the copied link using your preferred method *** ### How to Delete a Subsection **Steps** 1. Right-click the subsection 2. Select **Delete** 3. Confirm by clicking **YES** {% hint style="info" %} Sections and subsections are optional. You can create test cases directly under a suite if additional grouping is not required. {% endhint %} {% hint style="success" %} Deleting a section does not affect existing test plans or their results. {% endhint %} {% endtab %} {% endtabs %} *** # Test Cases A **Test Case** is the core testing unit in TestFirst. It describes how a specific feature or behavior should be tested. A test case typically includes: * **Precondition** – conditions that must be met before the test starts * **Action / Steps** – the steps required to perform the test * **Expected Result** – the expected outcome after performing the actions Test cases can be **automated** using the Recorder or **written manually**. ### Where Test Cases Fit in the Test Case Library Test cases are stored in the **Test Case Library**, which is organized in a hierarchical structure. {% hint style="info" %} Test cases can be created at **any level of the library tree**. {% endhint %} *** ## Create a Test Case Test cases can be created in multiple ways in TestFirst. They can be: * **Generated automatically** when using **Test Scopes** * **Created manually** in the **Test Case Library** * **Created** from the **Mini Test Case Library** inside the **Test Case Editor** This section explains how to create a test case manually in the Test Case Library. {% hint style="info" %} To create a test case, the user must have: **Create/Edit permission for Test Case** See [**Roles and Permissions**](/administration/roles-and-permissions) for more information. {% endhint %} ### Create a Test Case M**anually in the Test Case Library** 1. Open **Test Case Library**. 2. Locate the node where you want to create the test case.\ *A test case can be created under any level of the library tree: Test Project/ Suite/ Section/ Subsection* 3. **Right-click** the node. 4. Click **Add Test Case**. 5. The **Add Test Case** dialog will appear. 6. Enter the **Test Case Title**. 7. Click **Create**. The test case will be created and can then be opened in the **Test Case Editor**. ### Next Step: Complete the Test Case in Test Case Editor After creating a test case, you should **open it in the Test Case Editor** to define the test logic. In the editor, you can: * Automate the test using the **Recorder** * Write test steps using **Gherkin** * Create **manual test steps** See [**Test Case Editor**](broken://spaces/ErSaU4WjIuLC7zfVEh8L/pages/aEXqsZpDhGC03MuwgBbm) for more details. *** ## Copy a Test Case Link You can share a direct link to a test case. #### Steps 1. Right-click the test case 2. Click **Copy Link** The link will be copied to your clipboard and can be shared with other users. *** ## Delete a Test Case Deleting a test case permanently removes it from the Test Case Library. #### Steps 1. Right-click the test case 2. Click **Delete** 3. Confirm the deletion in the confirmation dialog {% hint style="warning" %} **Warning** Deleted test cases **cannot be restored**. If the test case is referenced in a Test Scope, it will no longer appear there. {% endhint %} # Editor Overview The **TestFirst Editor** is where you create, edit, and run your test cases. It is a fully integrated workspace that allows you to: * Write automated tests using Gherkin * Record and automate tests using the Recorder * Create manual test cases * Run and debug tests * View execution results in real time *** ### Editor Layout The editor is designed to keep everything you need on a single screen. #### Test Case Library (click **Library** to open the left panel) * Organize your test cases into: * Projects * Suites * Sections * Subsections * Create new test cases (Automated or Manual) * Quickly navigate between tests *** #### Editor Area This is where you build your test. Depending on the test type: * **Automated tests** → Written using Gherkin * **Manual tests** → A step-by-step table with expected results You also get: * Auto-complete suggestions while typing * Easy editing and updates *** #### Preview Panel (Right Side) {% hint style="info" %} Click the **Preview** button to show or hide the preview. The preview appears automatically when you run a test. {% endhint %} The **Preview panel** shows your test execution in real time. * Displays browser interactions * Updates as the test runs * Helps verify UI behavior instantly *** #### Debug Console (Bottom Panel) The Debug Console provides execution details: * Mapped Selectors (how elements are identified during execution) * Execution log (step-by-step results) * Debug log (detailed runtime info) * Local variables (data during execution) This is useful for troubleshooting and debugging tests. *** ### Test Case Types You can create two types of test cases in the editor: #### Automated Test Cases * Written using Gherkin syntax * Can be executed directly in the editor * Ideal for automation and regression testing *** #### Manual Test Cases * Created using structured steps and expected results * Used for manual testing workflows *** ### Basic Workflow A typical workflow in the TestFirst Editor: 1. **Create or open a test case** 2. **Write your test** * Use Gherkin, Recorder, or manual steps 3. **Save the test** 4. **Run the test** * Use Dry Run or Debug mode 5. **Fix issues if needed** *** ### Key Actions From the top toolbar, you can: * **Save** → Save your test case * **Recorder** → Record test cases * **Local Run** * **Dry Run** → Run the test normally * **Debug** → Run with step-by-step control * **Remote Run** → Run the test in the cloud * **Stop** → Stop execution at any time # Write Automated Test Cases ### Choose How You Want to Create Tests In the TestFirst Editor, you can create test cases in multiple ways depending on your workflow and experience. Each approach is designed to help you move from idea :arrow-right: test quickly. You can combine these approaches as needed.
Cover image

:video:

Record using the Recorder

Capture your actions and convert them into test steps automatically.

  • Fastest way to create tests
  • No coding required
  • Ideal for UI workflows
/files/fhSrGNvE8CBL3JkQkgQa/pages/eAh9QPFkiho17uMNepKa

:square-pen:

Write Test Cases using Gherkin

Create automated tests using a simple, human-readable format.

  • Best for structured and repeatable tests
  • Full control over test logic
  • Supported by auto-complete suggestions
/files/iQfqESNg0tQePM4a8LAt/pages/YIJB8QBorDIKBRvsfihQ
# Record Test Cases ### What is the Recorder? The **Recorder** allows you to create automated tests by capturing your actions in a browser. Instead of writing steps manually, you can: * Click through your application * Type into inputs * Navigate between pages The Recorder converts these actions into structured test steps automatically. ### When to Use the Recorder Use the Recorder when you want to: * Quickly create UI test cases * Capture real user flows * Add steps to an existing test * Avoid writing Gherkin manually It’s the fastest way to turn manual testing into automation. *** ### Before You Start To use the Recorder, you need: * **TestFirst Utilities Pack** is installed and **Test Runner** is running If the Recorder button is disabled: * Download the **Utilities Pack** * Install utilities pack and run the **Test Runner** *** ### How to Record a New Test {% stepper %} {% step %} #### Open TestFirst Editor Open a test case in the **TestFirst Editor** {% endstep %} {% step %} #### Click Recorder {% endstep %} {% step %} #### Enter website URL Enter the URL you want to test {% endstep %} {% step %} #### **Click Start Recording** {% endstep %} {% step %} #### Perform actions in the browser * Click elements * Type text * Navigate pages * Assertions {% endstep %} {% step %} #### Stop Click **Stop** when finished {% endstep %} {% step %} #### Review and edit the generated steps {% endstep %} {% step %} #### **Click Save** {% endstep %} {% endstepper %} Your recorded actions are now converted into an automated test. *** ### What the Recorder Captures The Recorder currently supports capturing the following actions: * **Clicks** (buttons, links, tables) * **Typing** (inputs, forms) * **Basic navigation flows** * **Table Interactions** (intelligently detect table relationships to interact with rows and cells) * **Assertions** (verifying elements are displayed) *** ### Tips for Best Results 💡 **Use Recorder whenever possible**\ Recorder is the fastest and easiest way to create automated tests in TestFirst. 💡 **Record realistic user flows**\ Record clear, intentional actions and avoid unnecessary clicks or navigation 💡 **Review recorded steps before saving**\ This helps ensure the test logic is correct and clean. 💡Add validations to make tests more reliable *** ### Next Steps After recording a test case, you can: * Run the test using the **Test Runner** * Run the test from a **Test Scope** * Add additional actions or assertions # Write Test Cases with Gherkin {% hint style="info" %} Gherkin is a **human-readable language** used to define how your application should behave. It allows you to write automated tests as structured scenarios that are easy to read, write, and maintain. {% endhint %} ### Basic Structure Every test is written as a **Scenario**: ``` Scenario: Navigate to TestFirst website Given browser "Chrome" When I visit "https://www.testfirst.com/" And I click "START NOW" Then "Pricing Plans" page is displayed And "Flexible pricing for any team" is displayed ``` ### Gherkin Keywords | Keyword | Purpose | | ------------ | --------------------------- | | **Scenario** | Defines the test case | | **Given** | Sets the starting condition | | **When** | Describes actions | | **Then** | Defines expected results | | **And** | Adds additional steps | *** ### How Gherkin Works Each scenario represents a complete test: * **Given** :arrow-right: Precondition (e.g., browser, environment) * **When** :arrow-right: Actions performed * **Then** → Expected outcome You can use **And** to extend any part of the scenario. ### Auto-Complete Support The editor provides intelligent suggestions while typing: * Suggests valid Gherkin steps * Adapts based on your test context * Helps reduce syntax errors Use: ``` CTRL + SPACE ``` to trigger suggestions manually. *** ## Selecting Elements in Tests When interacting with UI elements, TestFirst supports 3 selector types. 1\. AI Selectors 2\. Quick Selectors 3\. Custom Selectors ### AI Selectors Describe elements in natural language: ``` When I click "'Login' button" ``` * No need for technical selectors * Works well with dynamic UIs * Adapts to layout changes You can also add context: ``` When I click "'Sign up' button near to Login" ``` #### Tips for Better AI Selectors * Be specific about element type * `'Username' input field` * `'Submit' button` * Use relationships when needed * `'Amount' input field near to 'Bonus'` * Add context when elements repeat * `'Bonus' item in dropdown near to 'Allowance'` *** ### Quick Selectors Use `!` for simple matching: ``` When I click "!Login" ``` * Fast and simple * Works best when elements are unique * Does not use cloud credits *** ### Custom Selectors Use selectors stored in the Data Repository: ``` When I click "{Login Button}" ``` * Fully controlled (XPath / CSS) * Reusable across tests * Best for complex or unstable elements #### Using Variables Variables allow you to reuse data across tests. ``` When I type "{{username}}" in "Username" ``` * Stored in the **Data Repository** * Useful for credentials, URLs, and test data #### Additional Notes * The editor supports a wide range of Gherkin steps * Auto-complete reflects the latest supported syntax * Actual editor behaviour should be treated as the source of truth *** ### Special Cases * Escape double quotes using `\"`: ``` When I click "Text with \"quotes\"" ``` * Use variables inside selectors: ``` When I click "Button with {{label}}" ``` ### Best Practices * Use clear and descriptive scenario names * Keep steps simple and readable * Prefer AI Selectors for speed and flexibility * Use variables instead of hardcoding values * Split large flows into smaller scenarios # Write Manual Test Cases
Cover image

Create step-by-step manual tests with expected results.

  • Ideal for exploratory or non-automatable scenarios
  • Simple and structured format
  • Useful for QA validation flows
/files/5QKKVvORAXSX1wSxdwVx
Manual test cases define **step-by-step actions and expected results** that a tester performs instead of an automated test. They are useful when: * The test cannot be automated * Exploratory testing is required * Human validation is needed ### When to Use Manual Tests Use manual test cases when: * The scenario involves **visual validation** * The flow is **too complex or dynamic to automate** * The test is **temporary or one-time** *** ## How to Create a Manual Test Case ### Option 1 - From Test Case Library * Go to **Test Case Library** * Right-click any node (**Project**, **Suite**, **Section**, or **Subsection**) * Click **Add Manual Test Case** * **Open** the new test case when prompted * **Write** the preconditions and steps in the table, and add a reference if needed * Click **Save** ### Option 2 - From Editor (Mini Library) * Open the **TestFirst Editor** * Open **Library** from the left-side navigation bar * Right-click any node or use the **More actions** button\ ![](/files/aT7EY7V9LxPVjuNSPrym) * Click **Add Manual Test Case** * **Enter** the test case **name** * **Open** the new test case * **Write** the preconditions and steps in the table, and add a reference if needed * Click **Save** ### Option 3 - Write First, Then Save as Manual 1. Open the **TestFirst Editor** 2. **Record steps** or **write the test case in Gherkin** 3. Set the test type to **Manual**\ ![](/files/AvMglHXlFjKZWuVj8y29) 4. Click **Convert to manual** in the confirmation 5. Click **Save** *** ### Writing Manual Test Steps Manual test cases are written in a **structured table format**. * **Action** → What the tester should do * **Expected Result** → What should happen #### Example | Action | Expected Result | | --------------------------------- | --------------------------------------- | | Open the login page | The login page is displayed | | Enter valid username and password | The input is accepted | | Click "Sign In" | The user is redirected to the dashboard | *** ## Completing the Manual Test Case After writing your steps: 1. Review the test case 2. Change the **Status** :arrow-right: **Ready for Testing** 3. Click **Save** {% hint style="info" %} Saving is required after updating the status. {% endhint %} ## Tips for Writing Manual Test Cases * Keep steps **clear and simple** * Make expected results **verifiable** * Avoid combining multiple actions in one step * Use consistent wording across tests # Android Mobile Automation Android Mobile Automation allows you to automate Android applications using the TestFirst Editor. Tests can be written using the same Gherkin syntax used for web automation, making it easy to create, maintain, and execute mobile test scenarios alongside your existing automated tests. Mobile automation supports running applications on **Android emulators** or existing **Android devices** and interacting with mobile UI elements using actions such as tapping, scrolling, waiting, and validations. {% hint style="success" icon="asterisk" %} Mobile automation uses application endpoints and mobile device endpoints stored in the Data Repository to launch and interact with Android applications. {% endhint %} ## Prerequisites Before running Android mobile tests, configure the Android tools on the machine where tests will execute. {% stepper %} {% step %} ### Install Java Install **Amazon Corretto 25**. {% endstep %} {% step %} ### Install Android Command-Line Tools 1. Download the Android Command-Line Tools from: 2. Extract the files so the following directory exists: ``` C:\Tools\Android\cmdline-tools\latest ``` 3. Create the following environment variable: ``` ANDROID_SDK_ROOT=C:\Tools\Android ``` {% endstep %} {% step %} ### Install Android Emulator Image Run: ```bash sdkmanager "system-images;android-36.1;google_apis;x86_64" ``` {% hint style="info" %} ⚠️ This must be installed using the Android Command-Line Tools. Installing the image through Android Studio is not sufficient. {% endhint %} {% endstep %} {% step %} ### Install Android Platform Tools 1. Download Platform Tools from: 2. Extract the package so the following directory exists: ``` C:\Tools\Android\platform-tools ``` {% endstep %} {% step %} ### Install Android Build Tools Navigate to: ``` C:\Tools\Android\cmdline-tools\latest\bin ``` Run: ```bash sdkmanager "build-tools;36.1.0" ``` {% endstep %} {% endstepper %} *** ### Configure the Application Before writing a mobile test, add the Android application to the Data Repository. 1. Open **Data Repository** 2. Select **Endpoints** 3. Create a new endpoint 4. Set the endpoint type to **App** 5. Upload the APK file 6. Save the endpoint The application can then be referenced from your test case. ```gherkin Given application "{Android apps.TestFirst Sample 1}" ```
### Configure a Mobile Device Mobile tests require a mobile device endpoint. 1. Open **Data Repository** 2. Select **Endpoints** 3. Create a new endpoint 4. Set the endpoint type to **Mobile Device** 5. Enter the device configuration and save the endpoint #### Start an Emulator Use the following configuration when TestFirst should start an emulator automatically.
```json { "start": { "emulator": { "apiLevel": "36.1", "imageType": "google_apis", "profile": { "deviceDefinitionName": "Pixel 5" } } }, "type": "Android" } ``` #### Use an Existing Device or Emulator Use the following configuration when an Android emulator or device is already running.
```json { "use": {}, "type": "Android" } ``` ### Next Steps After configuring your Android environment: 1. Use Appium Inspector if you need to inspect application elements while creating selectors. 2. Write your first mobile test. 3. Run the test from the Editor. # Inspect Mobile Applications Appium Inspector can be used to inspect Android applications and identify elements when creating selectors for mobile tests. The sample configuration below assumes that: * An Android emulator is already running * The emulator instance name is `emulator-5554` (the default emulator name in most Android SDK installations) {% hint style="info" %} Appium Inspector is commonly used during test development to inspect application elements and identify selectors that can be used in mobile test steps. {% endhint %} #### Install Appium Server Run: ```bash npm install -g appium ``` #### Install UiAutomator2 Driver Run: ```bash appium driver install uiautomator2 ``` #### Install Appium Inspector Download and install Appium Inspector from: #### Start Appium Server Run: ```bash appium ``` Leave the Appium server running while using Appium Inspector. #### Open Appium Inspector Launch Appium Inspector and create a new session. In **Capability Builder → JSON Representation**, enter the following configuration: ```json { "platformName": "Android", "appium:automationName": "UiAutomator2", "appium:deviceName": "emulator-5554", "appium:udid": "emulator-5554", "appium:noReset": true } ``` #### Save the Configuration 1. Click **Save As** 2. Enter a name (for example, `local android`) 3. Click **Save** The saved configuration can be reused for future sessions. #### Start the Session Click **Start Session**. Appium Inspector will connect to the running emulator and display the application hierarchy, allowing you to inspect elements and identify selectors for use in your mobile tests. # Write Mobile Tests Reference both the application and mobile device in your test. {% hint style="info" %} Every mobile test must specify an application endpoint and a mobile device endpoint before launching the application. {% endhint %} #### Launch the Application ```gherkin Scenario: Start emulator and run the app Given application "{Android apps.TestFirst Sample 1}" Given mobile device "{Devices.Android.Pixel 10}" When I run application ``` The application and mobile device values are resolved from the Data Repository. #### Interact with Mobile Elements and Validate Content ```gherkin Scenario: Test 1 When I tap "Show table" And I tap "R2C2" And I tap "R6C3" Then "R6C3 - clicked" is displayed in mobile device ``` #### Scroll and Navigate ```gherkin Scenario: Test 2 When I scroll down in mobile device And I wait for 2 seconds And I tap "Back" ``` ### Supported Mobile Actions Mobile tests support common Android interactions including: * Launching applications * Tapping elements * Scrolling * Waiting * Validating displayed content * Device navigation actions Additional mobile actions may be available depending on the target application and device. # Run Mobile Tests Mobile tests can be executed the same way as other automated tests. 1. Open the test case in the Editor. 2. Ensure the required Android emulator or device configuration is available. 3. Click **Run Locally**. 4. TestFirst will start the emulator (if configured) and execute the test. Execution progress and logs are displayed in the Editor during the run. {% hint style="info" %} If the selected mobile device endpoint is configured to start an emulator, TestFirst will automatically launch the emulator before executing the test. {% endhint %} # Cross-Platform Test Automation Unlike traditional automation frameworks that separate web and mobile testing, TestFirst allows multiple automation types to be executed within the same test flow. This means a single test can: * Launch and validate a mobile application * Continue execution in a web browser * Call APIs * Execute SSH commands * Share variables and data between steps All within the same test case. The example below starts in an Android application and continues in a web browser using the same test case: ```gherkin Scenario: Start emulator and run the app Given application "{Android apps.TestFirst Sample 1}" And mobile device "{Devices.Android.Pixel 10}" When I run application Scenario: Test 1 When I tap "Click me" Scenario: Test 2 When I tap "Show table" And I tap "R2C2" And I tap "R6C3" Then "R6C3 - clicked" is displayed in mobile device Scenario: Test 3 When I scroll down in mobile device And I wait for 2 seconds And I tap "Back" Scenario: Browser Given browser "Chrome" When I visit "testfirst.com" And I click "Sign in" And I tap "Show table" And I tap "Back" ``` This allows teams to automate end-to-end business workflows that span multiple platforms while using the same editor, test structure, and execution model. # Run & Debug Tests ## Run Tests in the Editor Once you have written a test case, you can run it to validate execution and identify issues.. There are two types of test run available in TF Automate: * Local run * Run the test on the cloud ## Local Run {% hint style="info" %} #### **Before You Run (Local Run)** To execute tests locally, ensure: * **Utilities Pack** is installed * **Test Runner** is running on your machine The Test Runner runs in the background and connects automatically when a test starts. {% endhint %} #### Start a Local Test Run 1. Open your test case in the **Editor** 2. Click the **Local Run** button 3. The test execution will start immediately #### What Happens During Execution * The test runs in **headless mode** * The **Preview panel** (right side) shows real-time execution * The **Execution Log** appears in the **Debug Console** * The current step is highlighted as it runs Even though tests run in headless mode, you can visually follow the execution in real time. ## Dry Run & Debug Mode * By default, tests run in **Dry Run mode** * You can switch to **Debug mode anytime during execution** * Debug controls will appear in the Debug Console ### What is Debug Mode? Debug mode allows you to **pause, inspect, and control test execution step-by-step**. It helps you quickly identify why a test is failing and fix issues faster. ### Stop a Test * Click **STOP** at any time * The test execution will terminate immediately ### How the Test Runner Works The Test Runner is a lightweight background application. * No interaction is required once the Test Runner is started * You can safely **minimize it and continue working** * If it is closed accidentally: * Reopen it via system search (e.g., *“Test Runner”*) {% hint style="info" %} #### **Summary** * **Local Run** → Executes test using your machine * **Preview Panel** → Real-time visual execution * **Execution Log** → Step-by-step results * **Debug Mode** → Optional control during execution {% endhint %} *** ## Run the Test on the cloud (Remote Execution) Remote execution runs your tests using **TestFirst cloud or self-hosted runners**. Click the **Cloud run** button next to local run button, * Test runs **in the background** (no live preview) * **Execution logs** are available * **Screenshots** are captured for all steps * You may see: > *"Initializing runner… This may take a while"* * If a **self-hosted runner** is available :arrow-right: it is used * Otherwise :arrow-right: TestFirst **cloud runner** is used {% hint style="info" %} Remote runs are typically used for **test plan execution and CI/CD scenarios**. {% endhint %} # Browser Preview & Execution Insights TestFirst provides a **built-in browser preview with execution insights** to help you understand how your test runs. You can visually track execution, inspect logs, and analyze how each step behaves, all within the Editor. ## Browser Preview
The **Preview panel** shows a live view of your test execution. #### Key Characteristics * Always enabled during test runs * Shows **real-time UI interactions** * Runs in **headless mode with visual simulation** * Does not open an external browser ## Execution Insights Execution insights are available in the **Debug Console** tabs. {% hint style="info" %} Read more in [Debugging Tools](/testfirst-editor/run-and-debug-tests/debugging-tools). {% endhint %} ### Screenshots and Visual Validation * Screenshots are captured for **every step** in browser tests * Each screenshot highlights the exact interaction area * Click the screenshot link in each step of the **Execution Log** to open the annotated screenshot 💡 Use screenshots together with logs to identify issues faster. # Debugging Tools Once Debug mode is active, you can pause and inspect your test executions in real time. Whether you're troubleshooting a failing step or verifying values mid-execution, the debugging tools helps you stay in control and fix issues faster. ### **Adding and Removing Breakpoints** Breakpoints allow you to pause the test at specific steps. * To set a breakpoint, **click on the line number** of any step in your test. * To remove a breakpoint, **click the line number again**. This lets you pause test execution exactly where you want to inspect the test behaviour. ### **Pausing and Controlling Execution** When your test hits a breakpoint or when you pause it manually, you gain access to a set of controls: * **Pause test** * **Resume test** * **Run current step and move to next** * **Run current step and stay on it** * **Skip current step** * **Stop** ### **Debugging Tools and Information** #### **Mapped Selectors**
Shows how each step in your test is resolved into actual selectors during execution and how TestFirst identified elements on the page #### **Execution Log**
You can also access the traditional **execution log** to review test steps, timing, and outcomes as before. It complements the debug log for full traceability. #### **Debug Log (Live View)**
As your test runs, the **debug log** updates in real time, showing detailed execution data. This helps you trace the exact behaviour of your test.\
#### **Viewing Local Variables**
When the test is paused, you can view all local variables and their values.\ This helps you understand what data is being passed and how your test logic is behaving at each step.
# Fragments ## What are Fragments? Fragments are **reusable blocks of test steps** that you can use across multiple test cases. They help you avoid duplication and make your tests easier to maintain. ### Why Use Fragments Use Fragments when: * The same steps are repeated across tests (e.g., login, navigation) * You want to **standardize common flows** * You want to update logic **in one place instead of many** 💡 Update a Fragment once → all dependent tests benefit automatically. ## Create a Fragment ### Extract from an Existing Test Case You can convert existing steps into a reusable Fragment directly from a test case. **Steps:** 1. Select the steps you want to reuse 2. Click the **more options** button next to the **Preview** button 3. Click **Extract** 4. Enter a name in the **Extract as Fragment** modal 5. Click **Create** #### Replace Source Steps * When enabled → the selected steps are replaced with a Fragment call * If disabled → the Fragment is created, but the original steps remain 💡 This is the fastest way to refactor duplicate logic into reusable components. ### Create from Scratch 1. Open the **TestFirst Editor** 2. Open the library from the left toolbar, then switch to the **Fragment** tab (next to the **Test Case** tab) 3. Right-click → **New Fragment**, or click the more options icon in the toolbar → **New Fragment** 4. Enter a fragment name and double-click to open it 5. Add steps using Gherkin or the Recorder 6. Save the Fragment #### Use a Fragment in a Test Case Once created, Fragments can be reused in test cases. #### **Example** ``` Scenario: Login and access dashboard When I run fragment "TCF1" Then "Welcome" is displayed ``` #### Running a Fragment Fragments can be run independently or within the context of a calling test case, depending on their setup and dependencies. To run a Fragment **independently**: 1. Open the Fragment in the editor. 2. Run the Fragment directly. To run a Fragment **with a calling test case**: 1. Open the Fragment in the editor. 2. Use the **Run with** dropdown. 3. Select a test case that uses the Fragment. 4. Run the test. 💡 Use **Run with** when the Fragment depends on setup, variables, browser sessions, or other context provided by the calling test case. :star2:Prefer opening the browser in the main test case so the Fragment can reuse the session. ```gherkin Given browser "chrome" Given fragment "Complete checkout" When I run the fragment ``` Open a browser inside the Fragment only when a separate session or user is required. **Example:** User 1 submits a form in Browser 1, and User 2 verifies it in Browser 2. ## When to Use Fragments Fragments are ideal for: * Login / authentication flows * Repeated navigation steps * Setup or precondition steps * Complex reusable sequences *** ## Best Practices * Keep Fragments **small and focused** * Use clear, descriptive names (e.g., `Login Flow`, `Create User`) * Avoid putting too many unrelated steps in one Fragment * Reuse instead of duplicating logic ### Things to Keep in Mind * Changes to a Fragment affect all test cases using it * Fragments should represent **reusable behaviour**, not full test cases * Keep them stable to avoid breaking multiple tests # Advanced Test Capabilities TestFirst Editor supports advanced testing scenarios that go beyond basic automation. You can simulate real-world user behaviour, handle multiple sessions, and build dynamic, reusable tests, all within a single flow. With the advanced capabilities of TestFirst you can: * Handle [**multi-tab and multi-window flows**](/testfirst-editor/advanced-test-capabilities/multi-tab-and-multi-window-testing) * Test content in [**iFrames**](/testfirst-editor/advanced-test-capabilities/iframe-support) * Build dynamic tests with [**dynamic selectors**](/testfirst-editor/advanced-test-capabilities/dynamic-selectors) and [**variables**](/data-repository/data-repository/variables) * Reuse logic with [**fragments**](/testfirst-editor/fragments) * Automate **complex real-world scenarios** # Multi-Tab & Multi-Window Testing You can work with **multiple tabs and browser instances** in the same test. This allows you to automate complex scenarios such as: * Navigating across multiple pages * Comparing views in parallel * Simulating multiple users or sessions #### **Multi-Tab Example** ``` Scenario: Work with multiple tabs Given browser "Chrome" When I visit "https://www.testfirst.com" And I click "!See What’s New" And I switch to the new tab remembering it as "whats-new" And I visit "https://www.testfirst.com/plans" in a new tab And I remember the new tab as "plans" And I switch to the tab remembered as "plans" ``` #### **Multi-Window Example** ``` Scenario: Use multiple browser instances Given browser "Chrome" as "second" When I visit "https://testfirst.com" And I switch to "second" browser instance ``` #### **What You Can Do** * Open and switch between tabs * Launch multiple browser instances * Switch across tabs and instances * Close tabs and sessions when done 💡 Always name tabs and browser instances for reliable switching. # iFrame Support TestFirst supports testing applications that use iFrames, including nested and embedded iFrame content. Elements inside iFrames can be interacted with the same way as elements on the main page, whether tests are recorded using the Recorder or written manually using Gherkin. ### **Automatic iFrame Handling** TestFirst automatically detects and handles iFrame boundaries during recording and execution. In most cases, users do not need to manually switch into frames. Tests transparently pass through iFrame boundaries, including cross-origin iFrames, allowing elements inside iFrames to behave as if they were part of the main page. This allows you to: * Record interactions inside embedded frames reliably * Execute tests across nested iFrame structures * Work with pages containing multiple frames with similar elements * Replay Recorder-generated tests across iFrame boundaries automatically #### **Example** In this example, the button exists inside an iFrame, but no manual frame switching is required. ``` Scenario: Interact with elements inside an iFrame Given browser "Chrome" When I visit "https://playground.testfirst-qa.com/iframe" And I click "'Click Me' button in 'Second Level Iframe' section" Then "'Button Clicked' message" is displayed ``` #### **Current Automatic Handling Limits** Automatic iFrame traversal currently supports: * Up to **20 visible iFrames** per page * Up to **3 nested iFrame levels** For more complex applications, manual iFrame handling can be used. *** ### **Improved / Manual iFrame Handling** Although iFrame handling is automatic in most cases, users can explicitly focus test execution on a specific iFrame when needed. This can be useful for: * Very complex applications * Large pages with many iFrame elements * Improving selector precision * Working around automatic traversal limits * Deeply nested iFrame structures #### **Switch to a Frame** Use frame switching when you want to interact with elements inside a specific iFrame. #### Example ``` Scenario: Work inside an iFrame Given browser "Chrome" When I visit "https://playground.testfirst-qa.com/iframe" And I switch to "frame-earth" frame Then "counter" is displayed ``` #### **Work with Nested Frames** TestFirst also supports nested iFrames (iFrames inside other iFrames). #### Example ``` Scenario: Work inside nested iFrames Given browser "Chrome" When I visit "https://playground.testfirst-qa.com/iframe" And I switch to "frame-earth" frame And I switch to "frame-moon" inner frame Then "counter" is displayed ``` #### **Remember Frames** You can remember frames by name and switch back to them later. This is useful for complex applications with multiple frame contexts. #### Example ``` Scenario: Remember and switch between frames Given browser "Chrome" When I visit "https://playground.testfirst-qa.com/iframe" Then I remember "frame-earth" frame as "earth" Scenario: Switch back to remembered frame When I switch to remembered frame "earth" Then "counter" is displayed ``` #### **Return to the Root Frame** Use the root frame command to exit iFrame context and return to the main page. #### Example ``` When I switch to root frame ``` # Dynamic Selectors Dynamic Selectors make automated tests more resilient by allowing selectors to use variables instead of fixed values. This is useful when applications display dynamically generated content such as project names, customer names, order numbers, or other data that changes between test runs. Instead of locating an element using a fixed value: ``` Then "Project Demo123" is displayed ``` you can reference a variable: ``` Then "Project {{projectName}}" is displayed ``` At runtime, TestFirst automatically replaces the variable with its current value before locating the element. ### Create a Dynamic Selector Dynamic Selectors can be created while recording a test. 1. Start **Recording** a test in the TestFirst Editor. The Recorder toolbar appears. 2. Right-click the action you want to record (for example, **Click** or **Validate**). 3. Select **Dynamic selector**. 4. Click the target element in the application. TestFirst records the action using a variable-aware selector instead of a fixed value. {% hint style="info" %} **Tip:** The **Validate** action records a `Then "..." is displayed` assertion. Right-click **Validate** and select **Dynamic selector** to create a dynamic validation. {% endhint %} #### Use an Existing Variable If you want to bind the selector to an existing variable: 1. Add a variable assignment before the recorded action, for example: ``` When I set "projectName" variable to "Project Alpha" ``` 2. Run the test up to that step so the variable is available in the current recording session. 3. Record the Dynamic Selector as described above. TestFirst uses the variable value when creating the selector, allowing the same test to work with different application data. ### AI-assisted Dynamic Selectors Dynamic Selectors work with AI-generated element descriptions on web applications. When the Recorder detects dynamic values, it can generate selectors that use variables, making recorded tests more resilient to changing application data. ### Example ``` Scenario: Create a project When I type "Project-{{random value}}" in "Project name" And I click "Create" Then "Project-{{random value}}" is displayed ``` The same test can now run repeatedly without updating selectors when the project name changes. {% hint style="info" %} Dynamic Selectors reduce maintenance by making automated tests resilient to dynamically generated application data. {% endhint %} # Data Repository The **Data Repository** is a centralized storage area where you can manage reusable data used in automated test cases. Instead of hardcoding values inside tests, the Data Repository allows you to store important data elements, such as selectors, variables, and endpoints, and reference them across multiple test cases. This helps keep tests **clean, maintainable, and reusable**. Data in the repository is organized by **environment**, allowing different values to be used for different testing environments (for example: Development, Staging, or Production). *** ### What Can Be Stored in the Data Repository The Data Repository supports several types of reusable data. * Variables * Selectors * Endpoints *** ### Environments Data Repository items can be organized by **environment**. This allows different data values to be used depending on where the tests run. Example environments might include: * Development * QA * Staging * Production For example: | Environment | Variable Value | | ----------- | -------------- | | Development | dev-user | | Staging | staging-user | | Production | prod-user | This ensures tests remain consistent while adapting to different environments. *** ## Permissions Access to the Data Repository is controlled using a dedicated permission. Navigate to: **Administration → Roles and Permissions → Automation → Data Repository** Permission: **Modify** This permission controls whether a user can modify Data Repository items. *** ### Modify Permission Enabled If the **Modify** permission is enabled, the user can: * Create new items * Create folders * Edit existing items * Delete items This provides **full access** to manage the Data Repository. *** ### Modify Permission Disabled If the **Modify** permission is not enabled, the user has **read-only access**. Users can: * View repository items * Reference stored data in test cases But they **cannot modify repository data**. *** ## Read-Only User Interface Behaviour When a user has **read-only access**, the interface automatically hides editing controls. The following actions are not available: #### Hidden Action Buttons * **Create New Item** * **Create New Folder** *** ### Best Practices To keep the Data Repository organized and maintainable: * Use **clear naming conventions** for selectors and variables * Group related items into **folders** * Separate environment-specific values properly * Avoid duplicating selectors across multiple items * Update selectors in the repository instead of editing test cases Using a well-structured Data Repository improves **test stability, reuse, and maintainability** across your automation suite. # Environments Environments let you manage different configurations for your tests. You can define separate selectors, variables and endpoints per environment, such as - * **QA** * **Staging** * **Production** ## Default Environment Every project includes a **Default** environment: * Cannot be edited or deleted * Used as a fallback * Used when a value is not defined in another environment {% hint style="info" %} If a selector, variable, or endpoint is missing in the selected environment, TestFirst automatically uses the value from **Default**. {% endhint %} ### Create an Environment 1. Open **Data Repository** 2. Click the **Environment dropdown** 3. Click **Add** 4. Enter name and save ### Edit or Delete * Select an environment from the dropdown * Use **Edit** or **Delete** {% hint style="danger" %} Deleting an environment also removes all its data (selectors, variables, endpoints).\ This action cannot be undone. {% endhint %} ### How It Works When you run a test: * TestFirst uses data from the **selected environment** * If a value is missing → it falls back to **Default** ### Summary * Environments = **configuration per context** * Support multiple setups (QA, Staging, Production) * Default environment acts as a fallback * Changes are isolated per environment # Variables **Variables** in the Data Repository allow you to store reusable values that can be referenced in automated test cases. Variables can be created, edited, and deleted from the **Data Repository → Variables** section. *** ### Supported Variable Types Variables support the following types: * **Text** – general text values such as usernames or labels * **Number** – numeric values used in test inputs or calculations * **Date** – date values used for scheduling or validation scenarios * **Name** – names used for testing form inputs or user fields * **File** – files used in test steps such as uploads or attachments All variable types can be used in both **Local Run** and **Remote Run** environments. *** ## Add a Variable To add a new variable: #### Step 1 - Select Variables Open the Data Repository and select **Variables**. *** #### Step 2 - Open the Add Item Modal You can create a variable in two ways: * Click the **New Item** icon in the Data Repository header * Right-click the folder where you want to add the variable and select **Add Item** The **Add Item** modal will appear. *** #### Step 3 - Enter Variable Details Provide the following information: * **Name** – The variable name used in test cases * **Description** – Optional explanation of the variable * **Parent Folder** – Folder where the variable will be stored * **Environment** – The environment where the variable applies * **Type** – Select one of the supported variable types * **Value** – The value assigned to the variable *** #### Step 4 - Save the Variable Click **SAVE**. The modal will close and a confirmation message will appear: The variable is now available for use in your test cases. *** ## Edit a Variable To modify an existing variable: #### Step 1 - Open the Context Menu Right-click the variable you want to edit. #### Step 2 - Select Edit Click **Edit** from the context menu. The **Edit Item** modal will appear. #### Step 3 - Update Variable Details Modify the fields such as: * Name * Folder * Environment * Type * Value #### Step 4 - Save Changes Click **SAVE**. *** ## Delete a Variable To delete a variable: #### Step 1 - Open the Context Menu Right-click the variable you want to delete. #### Step 2 - Select Delete Click **Delete** from the context menu. A **Delete Item confirmation modal** will appear. #### Step 3 - Confirm Deletion Click **YES** to permanently remove the variable. {% hint style="danger" %} Restoring deleted items is not supported. Once you delete an item from the Data Repository, it is gone for good. {% endhint %} *** ## Best Practices To manage variables effectively: * Use **clear and descriptive variable names** * Organize variables into **logical folders** * Use environment-specific variables when values differ across environments * Avoid duplicating the same values across multiple variables A well-structured variable repository makes tests **easier to maintain and update** across the entire automation suite. # Selectors **Selectors** in the Data Repository are used to locate elements in the application under test. Selectors allow automated tests to identify UI components such as buttons, input fields, links, tables, and other interactive elements on a web page. By storing selectors in the Data Repository, you can manage them centrally and reuse them across multiple test cases. This approach makes your tests easier to maintain. If an application’s UI changes, you can update the selector once in the repository instead of editing multiple test cases. Selectors can be **created, edited, and deleted** in the **Data Repository → Selectors** section. *** ### Selector Types TestFirst supports the following selector types: * **CSS Selectors** – commonly used for locating elements using CSS syntax * **XPath Selectors** – useful for locating elements in complex DOM structures Both selector types can be used to identify elements during automated test execution. *** ### Add a Selector To create a new selector: #### Step 1 - Select Selectors Open the Data Repository and select **Selectors** tab. #### Step 2 - Open the Add Item Modal You can add a selector in two ways: * Click the **New Item** icon in the Data Repository header * Right-click the folder where you want to add the selector and select **Add Item** The **Add Item** modal will appear. #### Step 3 - Enter Selector Details Provide the following information: * **Name** – The name used to identify the selector * **Folder** – Folder where the selector will be stored * **Environment** – The environment where the selector will be used * **Type** – Select the selector type (**CSS** or **XPath**) * **Value** – Enter the selector expression #### Step 4 - Save the Selector Click **SAVE**. The selector is now stored in the Data Repository and can be referenced in test cases. *** ### Edit a Selector To modify an existing selector: Right-click the selector, then select **Edit**. The **Edit Item** modal will appear. Update the fields as needed, then click **SAVE**. *** ### Delete a Selector Right-click the selector, then select **Delete**. The **Delete Item confirmation modal** will appear. Click **YES** to permanently remove the selector. {% hint style="danger" %} **Important** Deleted selectors **cannot be restored**. Once a selector is removed from the Data Repository, it is permanently deleted and cannot be recovered. Always ensure the selector is no longer used in test cases before deleting it. {% endhint %} ## Best Practices To keep selectors reliable and maintainable: * Use **clear and descriptive selector names** * Prefer **stable element attributes** such as IDs or data attributes * Avoid selectors that rely on dynamic values * Store frequently used selectors in shared folders * Update selectors in the repository instead of editing multiple tests Managing selectors properly helps keep automated tests **stable, reusable, and easier to maintain**. # Endpoints **Endpoints** in the Data Repository allow you to store connection targets used by automated tests. Endpoints are typically used when tests need to interact with external systems or services, such as servers accessed through **SSH connections**. By storing endpoints in the Data Repository, you can reuse them across multiple test cases and manage connection details from a single location. Endpoints can be created, edited, and deleted within the **Data Repository → Endpoints** section. *** ### Endpoint Types Currently, TestFirst supports the following endpoint type: * **SSH** – used to connect to remote servers via Secure Shell (SSH) Endpoints allow tests to interact with remote systems for actions such as: * executing commands * validating server responses * verifying remote system states Additional endpoint types may be supported in future versions. *** ### Add an Endpoint To create a new endpoint: #### Step 1 - Select Endpoints Open the **environment dropdown** in the Data Repository and select **Endpoints**. #### Step 2 - Open the Add Item Modal You can create an endpoint in two ways: * Click the **New Item** icon in the Data Repository header * Right-click the folder where you want to add the endpoint and select **Add Item** The **Add Item** modal will appear. #### Step 3 - Enter Endpoint Details Provide the following information: * **Name** – The endpoint name used to identify the connection * **Folder** – Folder where the endpoint will be stored * **Environment** – Environment where the endpoint will be used * **Type** – Select the endpoint type (currently **SSH**) * **Value** – The connection value or endpoint address #### Step 4 - Save the Endpoint Click **SAVE**. The modal will close and a confirmation message will appear. The endpoint is now available for use in your test cases. *** ### Edit an Endpoint To modify an existing endpoint: Right-click the endpoint, then select **Edit**. The **Edit Item** modal will appear. Update the fields as needed, then click **SAVE**. *** ## Delete an Endpoint To remove an endpoint: Right-click -> **Delete** from the context menu. The **Delete Item confirmation modal** will appear. Click **YES** to permanently remove the endpoint Right-click the endpoint, then select **Delete**. The **Delete Item confirmation modal** will appear. Click **YES** to permanently remove the endpoint. {% hint style="danger" %} ## Important Deleted endpoints **cannot be restored**. Once an item is removed from the Data Repository, it is permanently deleted and cannot be recovered. Always verify that the endpoint is no longer required before deleting it. {% endhint %} *** ## Best Practices To manage endpoints effectively: * Use **clear naming conventions** for endpoints * Organize endpoints into **folders based on environments or services** * Avoid duplicating the same endpoint across multiple items * Maintain consistent connection details across environments Keeping endpoints organized ensures that automated tests remain **stable, reusable, and easy to maintain**. # Manage Data Repository You can organize **Selectors, Variables, and Endpoints** using folders. Folders help structure your data and keep it easy to manage. ### Create a Folder 1. Right-click on any tab pane in data repository (**Selectors / Variables / Endpoints**) \ ![](/files/dz9AoW7LCeLM80du9X3G) 2. Click **Add Folder** 3. Choose a parent folder 4. Enter name and save {% hint style="info" %} Alternatively, you can click on more icon ![](/files/gd01YyIJufFGx1cBof4M)on toolbar and select **New Folder** {% endhint %} ### Edit a Folder * Right-click the folder * Click **Edit** * Update details and save ### Delete a Folder * Right-click the folder * Click **Delete** * Confirm the action {% hint style="danger" %} Deleting a folder also deletes all its contents (subfolders and items).\ This action cannot be undone. {% endhint %} ### Summary * Folders organize Data Repository items * Supported for Selectors, Variables, and Endpoints * Deletion is permanent and removes all nested data # Test Runs ### From Tests to Results, In One Place The **Test Runs** page brings together your selected test cases, runs them, and tracks results in one structured view. This gives you visibility, traceability, and confidence in every release. ### Overview The page is divided into two sections: #### **Test Runs List** Shows all test runs in your organization with key details. #### **Test Run Results Detail View** Selecting a test run opens a structured view of: * All included tests * Tests organized in the same hierarchy as the Test Case Library * Execution status and results 💡 You can resize panels by dragging the divider between them. ### Customize Your View You can control how data is displayed in both: * **Test Runs List** * **Test Run Results Detail View** #### Show / Hide Columns * Right-click on the table header * Select or deselect columns #### Filter Data Use filters to quickly find what matters: 1. Click the **filter (funnel) icon** on any column 2. Select criteria 3. Apply the filter * Active filters are highlighted * Use **Clear** to reset filters # Create and Manage Test Runs ## Create a Test Run {% hint style="success" icon="unlock" %} To create a test run, you need **Test Plan Management → Test Plan → Create/Edit** permission {% endhint %} #### Steps {% stepper %} {% step %} #### **Go to Test Execution** :arrow-right: **Test Runs**
{% endstep %} {% step %} #### **Click** :plus: **Add Test Run**
{% endstep %} {% step %} #### Enter Details * **Title** *(required)* * **Test Project** *(required)* * Select test cases: * By default, **Ready for Testing** tests are selected when you select the Test Project * You can manually include Draft tests * (Optional) Select **Environment** {% hint style="info" %} If the project includes at least one automated test and multiple environments are configured, the **Environment** field will be shown. You can select an environment from the Data Repository. If no environment is selected, tests will run using the **Default** environment. {% endhint %} * Select Assignee from **Assign To** dropdown {% hint style="info" %} You can assign tests one by one or select multiple tests later in the **Test Run Results Detail view**. {% endhint %} {% endstep %} {% step %} #### **Click Add** * The test run appears in the list * Selected test cases are added {% endstep %} {% endstepper %} ## Manage Test Runs ### **Re-create a Test Run** {% hint style="success" icon="unlock" %} To re-create a test run, you need **Test Plan Management → Test Plan → Create/Edit** permission {% endhint %} * Right-click :arrow-right: **Re-create** * Creates a new test run using the original configuration * Automatically includes: * Previously selected test cases * Any new **Ready for Testing** test cases added to the test case library {% hint style="info" %} 💡 Useful for rerunning tests with updated coverage {% endhint %} ### **Run a Test Run Automatically** {% hint style="success" icon="unlock" %} To run a test run automatically, you need **Test Plan Management → Test Plan → Run Automated Test** permission {% endhint %} * Right-click on a test run :arrow-right: **Run Automatically** * Automatically triggers execution for all **automated test cases** in the test run **What Happens** * Automated tests are: * Added to the [**Automated Test Queue**](/test-execution/automated-test-queue) * Executed remotely on the **cloud runner** {% hint style="info" %} If no automated tests are included, a toast message is shown: *“Test run contains no automated tests”* {% endhint %} ### **Copy Link to Share a Test Run** * Right-click :arrow-right: **Copy Link** * Share the link to provide direct access * Opening the link navigates users to the test run ### Edit a Test Run {% hint style="success" icon="unlock" %} To edit a test run, you need **Test Plan Management → Test Plan → Create/Edit** permission {% endhint %} * Open a test run by: * Right-click :arrow-right: **Edit** * Or double-click the test run * Update: * Test run **Title** * Included **test cases** {% hint style="info" %} The associated **project cannot be changed** {% endhint %} ### **Close a Test Run** {% hint style="success" icon="unlock" %} To close a test run, you need **Test Plan Management → Test Plan → Create/Edit** permission {% endhint %} * Right-click → **Close** * Confirm the action {% hint style="warning" %} Once closed: * No new results can be added * The test run cannot be reopened {% endhint %} ### **Delete a Test Run** {% hint style="success" icon="unlock" %} To delete a test run, you need **Test Plan Management → Test Plan → Delete** permission {% endhint %} * Right-click → **Delete** * Confirm the action {% hint style="danger" %} Deleting a test run is permanent and cannot be undone {% endhint %} # Test Actions ``` Manage and execute individual tests directly from a test run. You can access these actions by right-clicking on a test in the Test Run Results view. ``` ### **Assign Tests** * Select one or multiple tests * Right-click → **Assign** * Assign to a user **What happens:** * Assigned tests appear in the user’s **Manual Test Queue** * The same queue is available in the **Manual Testing App** {% hint style="info" %} 💡 Assigning tests helps to distribute testing work across team members. {% endhint %} ### **Run with TEM** * Right-click → **Run with TEM** Opens the test in the **Manual Testing App (Test Execution Module)** for full step-by-step manual execution. ### **Quick Run** Quick Run allows you to add a result **without executing the test step-by-step.** **How it works** * Right-click → **Quick Run**, then **Add Quick Result** modal is opened. * Select a status: * Passed * Failed * Blocked * Add an optional comment * Click **OK** **What happens** * A result is added instantly * No actual test execution is performed {% hint style="info" %} 💡 Useful for fast updates when execution is done outside the system. {% endhint %} ### **View Test** * Right-click → **View** * Opens the test details within the current view ### **View in New Tab** * Right-click → **View in New Tab** * Opens the test in a separate tab for easier navigation ### **Copy Link** * Right-click → **Copy Link** * Share direct access to the test ### **Reset Test** Resets a test back to its initial state. **How it works** * Right-click → **Reset Test** * Confirm the action **What happens** * All test results are deleted * Test status is set to **Untested** {% hint style="warning" %} Resetting a test is permanent and cannot be undone {% endhint %} {% hint style="success" icon="unlock" %} To reset a test, you need **Test Plan Management → Test → Reset** permission {% endhint %} ### **Set to Retest** Marks a test for re-execution. **How it works** * Right-click → **Set to Retest** * Enter an optional reason * Confirm **What happens** * Test status changes to **Retest** * A new empty result is created with: * Status: Retest * Comment: Reason (if provided) {% hint style="success" icon="unlock" %} To reset a test, you need **Test Plan Management → Test → Set to Retest** permission {% endhint %} > ### From Execution → Control > > TestFirst support both full execution and lightweight updates > > Users can control test lifecycle with reset and retest options # Download a Test Result as PDF You can export test results as a **PDF file** for sharing, reporting, or record-keeping. ## How to Download ### **From Test Runs** * Go to **Test Run → Test Run Results** View * Right-click on a test result * Click **Download as PDF**\
### **From Test View** * Open a test result * Right-click on the test result in Test Result table * Click **Download as PDF**
# Automated vs Manual Execution ``` Automated tests are system-driven tests. Manual tests are user-driven tests and both can exist in the same test run Execution is handled independently based on the test type ``` TestFirst supports both **automated** and **manual** test execution within the same test run. Each type follows a different execution path and requires the appropriate permissions. ### Automated Tests Automated tests are executed by the system using test runners. #### **How They Run** * Triggered via: * **Run Automatically** from Test Runs *(requires permission: Test Run → Run Automated Tests)* * Added to the **Automated Test Queue** * Executed on: * **Cloud runner** * Or **self-hosted runner** #### **Execution Behaviour** * Runs without user interaction * Follows predefined automation steps * Results are captured automatically * Includes: * Execution logs * Debug logs * Screenshots (on failure) *** ### Manual Tests Manual tests are executed by testers step by step. #### **How They Run** * Executed from: * Right-click on **Test** in **Test Run Results View** :arrow-right: **Run with TEM** *(requires permission: Test Plan Management → Test → Execute)* * Opened in the **Manual Testing App** #### **Execution Behavior** * Tester performs each step manually * Marks step status: * Pass / Fail * Can: * Add step comments/ test comments * Attach screenshots, attachments, recordings (*requires permission: Test Execution Module → Manage (Screenshot, Attachment, Recording)* * Log defects during execution ### Mixed Test Runs A single test run can include both automated and manual tests. #### **How They Are Handled** * **Run Automatically**: * Executes only automated tests * Manual tests are skipped * **Manual execution**: * Performed separately by testers # Automated Test Queue ### From Execution → Visibility The **Automated Test Queue** lets you track how your automated tests are executed in real time. It shows what’s waiting, what’s running, and what just finished — all in one place. The page is divided into two sections: * **Test Queue** → tests waiting or currently running * **Recently Finished** → latest completed executions ### Test Queue The **Test Queue** displays all automated tests that are: * Waiting for execution * Being picked up by a runner * Currently running Once execution completes, tests move to **Recently Finished**. #### **Execution States** * **LookingForRunner** → waiting for an available runner * **Starting** → runner assigned, preparing to start * **Running** → test execution in progress * **Postponed** → execution delayed #### **Available Actions** Right-click on a queued test to manage execution: * **Postpone** * Delays execution * Available when state = *LookingForRunner* * **Return to Queue** * Re-adds postponed test to queue * Available when state = *Postponed* * **Cancel** * Stops execution * Removes test from queue {% hint style="info" %} Refresh the page after actions to see updated state. {% endhint %} ### Recently Finished The **Recently Finished** section shows the latest executed automated tests. # Manual Test Queue *This article is currently being updated. Check back soon for the full details.* # Add a Screen Recording to a Test Result *This article is currently being updated. Check back soon for the full details.* # Cloud Runners Cloud Runners are responsible for executing your **automated tests**. They pick up tests from the queue and run them in a managed environment - no setup required. The **Cloud Runners** page gives you visibility into: * Available runners * Current execution state * Runner allocation during test runs ### **Runner States** * **Initializing** * Runner is starting up and preparing for execution * **Ready** * Runner is available and waiting for a test * **Running Test** * Runner is actively executing a test ### How It Works * Tests are added to the **Automated Test Queue** * A cloud runner is assigned automatically * The runner executes the test * Results are returned to Test Runs *** ### On-Premise Runners In addition to cloud runners, you can use your own infrastructure. #### **What They Are** On-premise runners are **self-hosted runners** that execute tests within your environment. ### Manage On-Premise Runners Right-click on a runner to perform actions: * **Enable / Disable** * Control whether the runner is used for execution * **Delete** * Removes the runner permanently * Invalidates its registration {% hint style="info" %} Disabled runners are excluded from execution\ Deleted runners must be re-registered to be used again {% endhint %} ### Generate Registration Token * Click **Generate Registration Token**\ * A registration token is copied * Use it to [set up a self-hosted on-premise runner](/test-execution/cloud-runners/set-up-an-on-premise-test-runner) # Set up an On-Premise Test Runner By default, TestFirst runs automated tests using **cloud runners**. If you need more control - such as running tests within your own network or infrastructure - you can set up an **on-premise test runner**. {% stepper %} {% step %} ### Step 1 - Install **Docker Desktop** * Install [Docker Desktop](https://www.docker.com/products/docker-desktop/) on the machine you are planning to run tests on. {% endstep %} {% step %} ### Step 2 - Register a Runner * Go to **Test Execution → Cloud Runners** * Click **GENERATE REGISTRATION TOKEN** * A **registration token** is copied to your clipboard {% endstep %} {% step %} ### Step 3 - Start the Runner Run the following command on your machine: * **Windows** → use PowerShell * **Mac / Linux** → use Terminal ``` docker run --env REGISTRATION_TOKEN= -d --name --restart unless-stopped --shm-size 2000000000 public.ecr.aws/testfirst/test-runner:browser-chrome ``` {% endstep %} {% endstepper %} Replace: * `` → token copied from TestFirst * `` → any name you prefer #### What Happens Next * It runner container connects to TestFirst * The runner appears in the **On-Premise Runners** list *** ### Managing the Runner You can control the runner in two places: #### **From Docker** * Stop / start the container anytime * Restart happens automatically (unless stopped manually) #### [**From TestFirst**](/test-execution/cloud-runners#manage-on-premise-runners) * Enable / disable the runner * Delete the runner * Monitor status (online/offline) *** ### When to Use On-Premise Runners Use them when you need: * Access to **internal environments** * **Custom execution environments** * **Security or compliance control** * Dedicated execution capacity # Reports ### Create a Test Execution Report {% hint style="info" %} To create a report, the user must have a role that includes the **Create/Edit** permission for **Reports**. See [Roles and Permissions](/administration/roles-and-permissions) for more details. {% endhint %} #### Steps to Create a Test Execution Report 1. In the left navigation panel, click **Test Plan Management**, then select **Reports** from the submenu. The **Test Execution Reports** page will be displayed. 2. Click **CREATE REPORT**. 3. Select the **test plan** you want to generate a report for. The selected test plan will be highlighted. 4. Click **CREATE REPORT**. A dialog opens to enter the report name and set up details.\ ![](/files/6dRV0LbDtcBitiyHkRvB) 5. Fill in the report details: * **Report Name** – enter a name for the report. * **Format** – select **CSV** or **PDF**. * **Include test results** – check this if you want test results in the report. * If checked, choose one of: * Include only the last test result associated with a test (default) * Include all test results associated with a test 6. Click **CREATE REPORT**. *** #### What Happens Next * The report will appear in the table with a **loading** indicator in the **Actions** column. * When generation is complete, the following actions will appear: * **View** * **Download** * **Delete** {% hint style="info" %} You can only view PDF reports. To open a CSV report, you need to download it first. {% endhint %} *** ### View a Report When a report is generated, click the **View** icon in the **Actions** column for the report you want to open. *** ### Download a Test Execution Report When a report is generated, click the **Download** icon in the **Actions** column for the report you want to download.
*** ### Delete a Test Execution Report {% hint style="info" %} The user must have a role that includes the **Delete** permission for **Reports** to delete report(s). See [Roles and Permissions](/administration/roles-and-permissions) for more details. {% endhint %} Click the **Delete** icon in the **Actions** column for the report you want to delete. A confirmation dialog will appear. Click **YES** to confirm the deletion, or **NO** to cancel. {% hint style="warning" %} Restoring deleted items is not supported. Once you delete a report, it cannot be recovered. {% endhint %} # Issues The **Issues** page lets you create, view, edit, and manage issues for your organization. ### Create an Issue 1. In the left navigation panel, click **Issue Tracker → Issues**. 2. Click **Create New Issue** at the top-right corner of the page. The **Create Issue** dialog will appear.
*UI under active update* 3. Fill in all **required fields** (Project, Issue Type, Summary, Status, Severity, Reporter). 4. *(Optional)* Expand **More Fields** to add details like Description, Assignee, Sprint, or Attachments. 5. Click **Create** to save. A confirmation toast will appear with a link to the new ticket. {% hint style="info" %} The system remembers your **last selected issue type**—the default type is **Task**. {% endhint %} *** ### View or Edit Issues * Update editable fields directly in the issue table (except metadata like *Created On*).
* Click any **Issue ID** to open detailed information. Learn more in [Issue Details Page](https://testfirst-1.gitbook.io/testfirst/oUIL6bReuPgXhqU6cZVM/issue-tracker/issues#issue-details-page). * Right-click an issue to open the context menu for quick actions: * **Copy Link** – Copy the issue link. * **Open** – View the issue details page. * **Delete** – Remove an issue (confirmation required).\ ![](/files/5URRHJvt7TvrFD8wUroX) #### Drag and Drop Issues Drag issues up or down in the table to adjust their priority or order. *** ### Issue Details Page 1. Click an **Issue ID** from anywhere in the Issue Tracker - such as the **Summary**, **Sprints**, or **Issues** page. 2. The **Issue Details Page** will open, displaying all key information about the issue, including its status, severity, and activity. 3. Use this page to **review progress**, **add comments**, and **manage attachments** for collaboration and tracking. {% hint style="info" %} Use comments and attachments to keep discussions clear and centralized. {% endhint %} *** ### Issue Tracker Email Notifications Email alerts keep you updated on issue changes, assignments, and deletions.\ When multiple updates occur close together, they’re grouped into a single message. You’ll receive notifications when: * You’re assigned an issue. * An issue you follow is updated. * An issue is deleted. *** ### Permissions Required to Use the Issue Tracker Access to the **Issue Tracker** is **permission-based**.\ Each action within the tracker requires specific permissions assigned to your role. * **View Issues** - Required for all users to access and view issues in the tracker. * **Manage Issues** - Allows users to create, edit, and delete issues. * **Manage Sprints** - Allows users to create, edit, and delete sprints. {% hint style="info" %} All roles have basic *Create/Edit* access by default.\ Specific actions (like deleting sprints) require explicit permissions. {% endhint %}
To check your assigned role, visit the Users section under Administration./spaces/ErSaU4WjIuLC7zfVEh8L/pages/QuHuGMHj51FnRGM4IBFI
To update or review role permissions, see the Roles and Permissions section in Administration./spaces/ErSaU4WjIuLC7zfVEh8L/pages/WlSj2F3SjTBfi6z2iJTl
# Sprints **Sprints** help you organize and track work progress efficiently. ### Create a Sprint 1. In the left navigation panel, click **Issue Tracker → Sprints**. The **Sprints** page will be displayed. 2. Click **CREATE NEW SPRINT** at the top of the page. 3. Enter sprint details (Name, Goal, Duration).
4. Click **SAVE**. *** ### Add Issues to a Sprint Add issues to a sprint by **dragging** them from the backlog or assigning them via the **Sprint field**.
*** ### Start a Sprint Click **START SPRINT** to begin. {% hint style="info" %} Only one sprint can be active at a time to ensure focus on current priorities. {% endhint %} *** ### Complete a Sprint Click **COMPLETE SPRINT** to close an active sprint. * Open issues can be moved to another sprint or backlog.\ ![](/files/HMucNLUr6GUMIvkAjV60) #### View Completed Sprints 1. On the **Sprints** page, click **VIEW COMPLETED SPRINTS**. 2. Review completed sprint details, including: * Completion date * Total issues completed * Sprint duration and goal *** ### Delete a Sprint Click **Delete** to remove a sprint (confirmation required). {% hint style="danger" %} Deleting a sprint is irreversible. Reassign all open issues first. {% endhint %} # Users The Users page under Admin helps you manage user invitations, activate or deactivate accounts, and control how collaboration happens across your projects. ## Invite a User to Your Organization 1. Getting to the Users Page 1. In the left navigation panel, click **Admin**. 2. Select **Users** from the sub-menu. The **Users** page will be displayed. ![](/files/PFT0PfT7ygNYaXGHH1CL)\ *Note: UI under active update* 2. Inviting a New Team Member 1. Click **INVITE USER** button. 2. Enter the user's email and click **INVITE**. An email invitation will be sent instantly. The user will appear in the **Invited Users** section of the page.

Click CANCEL in the ACTIONS column to revoke the invitation before it’s accepted.

***

Once your teammates are part of your organization, the next step is to assign roles and permissions to give each user the right level of access.

Learn about default roles and custom roles in:

/spaces/ErSaU4WjIuLC7zfVEh8L/pages/WlSj2F3SjTBfi6z2iJTl
Manage your subscription to access all the features that TestFirst has to offer./spaces/ErSaU4WjIuLC7zfVEh8L/pages/X1KcdCrbkacN6yMmhDeg
## Assign Roles to a User / Edit a User #### Steps to Assign a Role 1. In the left navigation panel, click **Admin**, then select **Users** from the sub-menu. The **Users** page will be displayed. 2. Find the user you want to update and click **Edit** in the **Actions** column. The **Edit User** dialog will appear. 1. To assign a new role: * Select the role from the **Available Roles** list. * Either **double-click** it or click the **>** button to move it to **Assigned Roles**.
*Note: UI under active update* 3. Click **Save**. The user’s **Role** column will now display the assigned role(s). #### You can also unassign roles from users * Open **Edit User** dialog. * Click the role you want to unassign in the **Assigned Roles** list. Double-click it, or click the **<** button, to move it to the **Available Roles** list. * Click **Save**. The user’s **Role** column will display the updated assigned role(s). {% hint style="info" %} You can **assign multiple roles** to a single user. The user’s combined permissions are determined by all assigned roles. {% endhint %} *** ## Deactivate a User As an **organization owner**, you can deactivate users who no longer need access to your workspace. #### Steps to Deactivate a User 1. In the left navigation panel, click **Admin** 2. Select **Users** from the sub-menu. The **Users** page will be displayed, showing all active users in your organization. 1. Find the user you want to deactivate and click **Deactivate** in the **Actions** column ![](/files/Htxcxbjvq5zAghjYCJTg) *Note: UI under active update* 3. Click **YES** in the confirmation dialog to confirm. The user will then appear in the **Inactive Users** section. {% hint style="info" %} You can activate an inactive user at any time from the **Inactive Users** section. {% endhint %} *** ## Activate a User As an **organization owner**, you can reactivate users who were previously deactivated. #### Steps to Activate a User 1. In the left navigation panel, click **Admin** 2. Select **Users** from the sub-menu. The **Users** page will be displayed. 3. In the **Inactive Users** section, find the user you want to reactivate. 4. Click **Activate** in the **Actions** column. An invitation email will be sent to the user, and they will appear in the **Invited Users** section.\ Once they accept the invitation, the user will then appear in the **Active Users** section. {% hint style="info" %} If the user hasn't accepted the invitation, you can cancel it by either: * clicking the **CANCEL** button for the user in the **Invited Users** section of the page, or * clicking the **CANCEL REACTIVATION** button for the user in the **Inactive Users** section of the page. {% endhint %} *** ## Transfer Ownership Only the **current organization owner** can transfer ownership to another user. #### Steps to Transfer Ownership 1. In the left navigation panel, click **Admin** 2. Select **Users** from the sub-menu. The **Users** page will be displayed. 3. Click **Transfer Ownership** at the top of the page. The **Transfer Ownership** dialog will appear.
4. From the **User** dropdown, select the user you want to make the new owner. 5. Click **TRANSFER** to confirm and send the ownership transfer request. * The request will appear in the **Ownership Transfer Requests** section. * The selected user will receive an email notification to accept the transfer. {% hint style="info" %} If the selected user has not yet accepted the ownership transfer, you can cancel the request at any time by clicking **Cancel** in the **Actions** column for the pending request. {% endhint %} {% hint style="warning" %} Note: Ownership transfers are **permanent** once accepted. To revert, the new owner must initiate another transfer back to you. {% endhint %} # Roles & Permissions Roles and permissions control what users can view, create, edit, or delete, ensuring each team member has the right level of access. When a new user joins your organization, they are automatically assigned a **Read-Only** role by default, allowing them to view information without making changes.
TestFirst provides a set of default roles, each with its own predefined permissions that you can assign to users.
Read more in Default Roles
Define your own roles to fit specific team workflows.
Learn how to configure permissions, manage dependencies, and save custom roles in Custom Roles
Assign roles to your teammates so they have the right level of access in TestFirst.
Learn more in Assign Roles to a User
# Default Roles TestFirst includes a set of **default roles** that define how users can interact with different areas of the platform. There are two types of these roles: * System roles * Owner – has all permissions available in the system. The Owner manages the organization, billing, users, and overall configuration. * Pre-Created Custom Roles * Admin - Has full control over users and features, except for organization-level settings. * Test Manager - Has full access to all TestFirst features, except for managing users and roles. * Test Designer - Can create and edit all test entities, but cannot delete anything. * Tester - Can execute tests, and create test plans and reports. * Test Automation Engineer - Can create, edit, and run automated tests. ### Permissions Matrix *This section is currently being updated. Check back soon for the full details.* # Custom Roles {% hint style="info" %} Available for users on **Plus**, **Pro**, and **Ultimate** subscriptions. {% endhint %} ### Create a Custom Role {% hint style="warning" %} To create custom roles, the user must have **Create/Edit** permission for *Roles*. {% endhint %} 1. In the left navigation panel, click **Admin** 1. Select **Roles and Permissions** from the submenu. The **Roles** page is displayed.
*UI under active update* 2. Click the **CREATE ROLE** button. The **Create Role** dialog will be displayed. The dialog contains a table with the list of permissions currently available in the system. 1. Enter the role’s **Name** and **Description**, then check the **Permissions** you want to grant. Make sure to check the corresponding permissions listed in **MANDATORY DEPENDENCIES**.
*UI under active update* 3. Click **SAVE**. The dialog will close, and the newly created role will appear on the **Roles** page. ### Edit a Custom Role You can edit any **custom role**, including the default custom roles available in your organization.\ The **Owner** role is a system role and **cannot be edited.** 1. Go to **Admin → Roles and Permissions**. The **Roles** page is displayed. 2. On the **Roles** page, find the role you want to update. Click **Edit** in that role’s row. 3. Update the **name**, **description**, or **permissions** as needed. 4. Click **Save** to apply your changes. ### Delete a Custom Role {% hint style="warning" %} To delete a role, your account must include the **Delete** permission for **Roles**. **Owner** role is a system role and **cannot be deleted**. {% endhint %} 1. Go to **Admin → Roles and Permissions**. The **Roles** page is displayed. 2. On the **Roles** page, find the role you want to delete. Click **Delete** in the **Actions** column. After confirmation, the role will be permanently removed from the list. {% hint style="info" %} Deleting a role unassigns it from all users and **cannot be undone**. {% endhint %} # Billing & Subscriptions # Subscriptions The **Subscriptions** page allows organization owners and authorized users to **view, purchase, edit, and cancel** [**subscription plans**](https://www.testfirst.com/plans) directly within the TestFirst application. All subscription management is handled **inside the TestFirst app** under **Administration → Billing & Subscriptions**. ### Accessing the Subscriptions Page 1. In the **left navigation panel**, click **Administration**. 2. Select **Billing & Subscriptions → Subscriptions** → The **Subscriptions** page will be displayed with active subscriptions shown by default. ### Buy a New Subscription Plan #### Steps to Buy a Plan 1. On the **Subscriptions** page, click **BUY NEW PLAN** → The **Pricing Plans** modal will open. 2. Toggle **Monthly / Yearly** to choose your billing period. * Prices shown represent the **monthly cost per seat**, even for yearly plans. 3. Select the plan you want and click **Buy Now**. * For the **Ultimate** plan, click **Contact Us** to request pricing or a demo. 4. In the **New Subscription** modal, configure: * **Number of seats** * **Billing period** (Monthly or Yearly) * **Payment method** (select an existing method or add a new one) 5. Review the total amount and click **BUY**. 6. A **Thank You for Your Purchase** modal will appear, showing: * Invoice number * Invoice date * Due date * Total amount (USD) * Line-item breakdown (plan, seats, pricing, tax) 7. Click **CLOSE** → You will be redirected to **Seats Assignment** to assign seats to users. {% hint style="info" %} You must assign seats before users can start using the new subscription. {% endhint %} *** ### View Subscriptions The **Subscriptions** page displays all subscriptions for your organization. #### Active vs Inactive Subscriptions * By default, only **Active** subscriptions are shown. * Enable **Show Inactive Subscriptions** to view cancelled or expired plans. #### Subscription Statuses | Status | Description | | ------------- | ------------------------------------------------------------------------------- | | **Active** | Subscription is valid and will renew automatically. | | **Cancelled** | Subscription is cancelled but still active until the end of the billing period. | | **Inactive** | Subscription has ended and is no longer valid. | *** ### Edit a Subscription #### Steps to Edit 1. On the subscription card, click **EDIT** → The **Edit Subscription** modal will open. 2. Available fields depend on subscription status: **Active subscription** * Subscription name * Number of seats * Payment method **Cancelled subscription** * Subscription name only **Inactive subscription** * Subscription name only 3. Click **UPDATE** to apply changes. *** ### Cancel a Subscription #### Steps to Cancel 1. On the subscription card, click **Cancel Subscription**. 2. In the confirmation modal: * Optionally select a reason for cancellation. 3. Click **CANCEL SUBSCRIPTION**. A confirmation toast will appear, and the subscription status will change to **Cancelled**. {% hint style="warning" %} Cancelling a subscription does **not** immediately revoke access.\ The subscription remains active until the end of the current billing period. {% endhint %} *** ### Related Pages * **Seats Assignment** – assign purchased seats to users * **Invoices** – view and download billing invoices * **Payment Methods** – manage saved payment methods # Seats Assignment The **Seats Assignment** page allows you to assign purchased subscription seats to users in your organization. Seats must be assigned before users can access features included in a subscription. *** ### Accessing Seats Assignment 1. In the **left navigation panel**, click **Administration**. 2. Select **Billing & Subscriptions → Seats Assignment** → The **Seats Assignment** page will be displayed. A table will appear showing: * **Users** listed in rows * **Subscriptions** listed in columns *** ### Assign Seats to Users #### Steps to Assign a Seat 1. Locate the user in the **Users** column. 2. In the corresponding **subscription column**, enable the toggle to assign a seat to that user. 3. The seat will be assigned immediately. *** ### Seat Assignment Rules * A user can only be assigned to **one seat per subscription**. * Toggles in the **Seats Assignment** table **cannot be turned off manually**. * To remove a seat from a user, you must: * Assign the seat to **another user**, or * Reassign seats according to your subscription’s seat limit. {% hint style="info" %} Seat availability depends on the number of seats purchased for each subscription. {% endhint %} *** ### Related Pages * **Subscriptions** – purchase or manage subscription plans * **Users** – manage organization users # Cloud Credits The **Cloud Credits** page allows you to **view your current credit balance**, **top up credits**, and **configure automatic top-ups** for your organization. Cloud credits are used for cloud-based executions and services within TestFirst. *** ### Accessing Cloud Credits 1. In the **left navigation panel**, click **Administration**. 2. Select **Billing & Subscriptions → Cloud Credits** → The **Cloud Credits** page will be displayed. {% hint style="info" %} Your **current credit balance** is shown at the top of the page. Click the balance amount to quickly refresh your credits. {% endhint %} *** ### Top Up Cloud Credits #### Steps to Top Up Credits 1. On the **Cloud Credits** page, click **TOP UP** → The **One-Time Top-Up** modal will open. 2. Configure the top-up details: * **Top-Up Amount** – Number of credits to purchase (minimum **600 credits**). * **Billing Amount** – Automatically calculated based on the selected credits. * **Payment Method** – Select an existing payment method or add a new one. * **Billing Email** – Auto-filled with the current user’s email. 3. Click **CHECKOUT**. 4. After successful purchase, a confirmation toast will appear, and your **credit balance will be updated**. *** ### Configure Auto Top-Up Auto top-up ensures your organization never runs out of cloud credits by automatically purchasing credits when the balance reaches a defined minimum. #### Steps to Configure Auto Top-Up 1. On the **Cloud Credits** page, click **Configure Auto Top-Up** → The **Edit Auto Top-Up** modal will open. 2. Set the auto top-up parameters: * **Minimum Balance for Top-Up** – Triggers auto top-up when reached. * **Top-Up Amount** – Credits purchased per top-up (minimum **600 credits**). * **Max Top-Ups per Day** – Limits how many auto top-ups can occur in a single day. * **Billing Amount** – Automatically calculated. * **Payment Method** – Select or add a payment method. * **Billing Email** – Auto-filled with the current user’s email. 3. Click **UPDATE**. A confirmation message will appear, and the **auto top-up configuration** will be displayed on the page. *** ### Edit Auto Top-Up #### Steps to Edit 1. Click the **EDIT** icon on the configured auto top-up section. 2. Update the required fields in the **Edit Auto Top-Up** modal. 3. Click **UPDATE** to save changes. The updated configuration will take effect immediately. *** ### Disable Auto Top-Up #### Steps to Disable 1. Toggle the **AUTO TOP-UP** switch **off**. 2. A confirmation toast will appear. 3. The **Configure Auto Top-Up** option will be displayed again. {% hint style="info" %} Disabling auto top-up does not affect your existing credit balance. {% endhint %} *** ### Related Pages * **Subscriptions** – manage subscription plans * **Seats Assignment** – assign seats to users * **Payment Methods** – manage saved payment methods * **Invoices** – view and download billing invoices # Invoices The **Invoices** page lets you view all invoices generated for your organization and download invoice PDFs for your records. *** ### Accessing Invoices 1. In the **left navigation panel**, click **Administration**. 2. Select **Billing & Subscriptions → Invoices** → The **Invoices** page will be displayed. *** ### Download an Invoice #### Steps to Download 1. Locate the invoice you want in the list. 2. In the **Document** column, click the **PDF link** to open or download the PDF. {% hint style="info" %} Invoice PDFs are generated automatically after successful purchases or renewals. {% endhint %} *** ### Related Pages * **Subscriptions** – manage subscription plans * **Cloud Credits** – view and top up cloud credits * **Payment Methods** – manage saved payment methods # Payment Methods The **Payment Methods** page shows all payment cards that have been used to purchase subscriptions for your organization.\ This page is **view-only**, except for removing existing cards. *** ### Accessing Payment Methods 1. In the **left navigation panel**, click **Administration**. 2. Go to **Billing & Subscriptions → Payment Methods** → The **Payment Methods** page will be displayed. *** ### Payment Methods Overview At the top of the page, you will see the list of saved payment cards with details. *** ### Linked Subscriptions Below the saved card details, the **Linked Subscriptions** table shows all subscriptions that use the selected payment method. This helps you understand **where a payment method is actively used** before taking any action. *** ### Removing a Payment Method #### Steps to Remove a Card 1. Locate the card you want to remove. 2. Click **Remove This Card**. 3. Review the confirmation message. 4. Confirm the action to permanently remove the card. {% hint style="warning" %} Removing a card may affect subscriptions that rely on it for renewal.\ Make sure another valid payment method is available before removal. {% endhint %} *** ### Related Pages * **Subscriptions** – manage active and inactive plans * **Seats Assignment** – assign subscription seats to users * **Cloud Credits** – manage cloud credit balance and auto top-ups * **Invoices** – view and download billing invoices # Integrations ## Jira Integration Overview Integrating **TestFirst** with **Jira** enables seamless collaboration between QA and development teams.\ Once connected, you can create, link, and view issues across both systems to streamline bug tracking and test management. *** #### What You Can Do With the Jira integration, you can: * **Create bug reports** in Jira directly from TestFirst. * **Link test cases** in TestFirst to Jira issues. * **View linked test cases** inside Jira issues for full visibility. *** ### Setup Requirements To enable the integration, complete the following steps: 1. **Create a TestFirst user**—we recommend using a **Service User** (sign up [here](https://www.testfirst.com/plans)). 2. **Install and configure** the TestFirst app in Jira - this should be done by your **Jira Administrator**. 3. **Configure Jira integration** in TestFirst - must be performed by a user with the required permissions. 4. **Authenticate in TestFirst** using your Jira credentials - each user must do this individually. *** ## Install and Configure TestFirst App in Jira To enable viewing **TestFirst test cases inside Jira issues**, you must install and configure the **TestFirst app** in your Jira instance.\ These steps only need to be completed **once** by a **Jira Administrator**. *** ### Steps to Install the TestFirst App 1. Open the [**TestFirst app installation page**](https://developer.atlassian.com/console/install/49abde0f-591f-457b-b369-49056705c065/?signature=d630569e60d8353ab7e15e7574685e520dacc84f52b6c7bcb75133b0bd44cbc3\&product=jira) in your browser. 2. Click **Get app**. An *Install ‘TestFirst‘ by FirstCall QA* dialog will appear. 3. Select the **Jira site** where you want to install the app. 4. Click **Install**. The app will be installed on the selected Jira instance. *** ### Steps to Configure the App 1. In your Jira instance, click **Settings** → **Marketplace Apps** in the top navigation. 2. Find **TestFirst** in the list and click it. You’ll see a message: *“For this app to display, you need to allow the app to access Atlassian products on your behalf.”* 3. Click **Allow Access**. A new tab will open with permission details. 4. Review the permissions and click **Accept**. The tab will close and the **TestFirst app welcome page** will load. 5. On the welcome page, click the link to open the **TestFirst Admin Panel**. 6. On the **Admin Panel**, enter the credentials for the **TestFirst user** created for this integration. 7. Click **Login**. A confirmation message will appear, and the Jira–TestFirst integration will become active.\ You can now view **linked TestFirst test cases** directly from Jira issues. *** ### Best Practices * ✅ **Use a dedicated TestFirst account** for Jira integration.\ Using a personal or shared user account may cause unstable connections between Jira and TestFirst. * 🔑 **Create a new user** by signing up [here](https://www.testfirst.com/plans) and ask your **Administrator** or **Owner** to invite that user to your organization. * 🚫 **Google authentication is not supported** in the Jira app.\ If your TestFirst account was created with Google login, reset your password to enable login with credentials. * 🏢 If the user belongs to multiple organizations, an additional screen will appear during login allowing you to select the organization. Click **Proceed** after selecting the correct one. {% hint style="info" %} After setup, all users in your Jira project will be able to view **linked TestFirst test cases** directly from issue pages — no additional configuration is required. {% endhint %} *** ## Configure Jira integration in TestFirst # Customizations ### Customize Test Case Status To customize test case statuses, you must have the **Manage** permission for **Customizations**.\ See [**Roles & Permissions**](/administration/roles-and-permissions) for more details. At the moment, **Status** is the only system field that can be customized. ### What You Can Customize The **Status** field controls the lifecycle of a test case.\ Customizing it allows you to align test case states with your team’s workflow. You can configure: * Dropdown options * Default status * Ready status ### Steps to Customize Test Case Status 1. In the **left navigation panel**, click **Customizations** → The **Customizations** page will be displayed. 2. Click the ✏️ **Edit** icon in the **Actions** column of the **System Fields** table → The **Edit System Field** dialog will open. 3. Update the required settings: * **Dropdown Options**\ Defines the selectable status values for a test case.\ Use the format: ``` x, value ``` * `x` → sequential number starting from `0` * `value` → label shown in the dropdown * Each line represents one status option. * **Default Value**\ The sequential number (`x`) of the status automatically assigned when a test case is created. * **Ready Status**\ When a test case is set to this status, it is considered **ready for testing**.\ Test cases with this status are selected by default during test plan creation. 4. Click **Save** to apply your changes. {% hint style="info" %} Carefully choosing **Ready** and **Default** statuses helps ensure only ready test cases are included during test execution. {% endhint %} # Organization Settings The **Organization Settings** page displays key information about your organization, including its name, ID, aliases, and creation date. It also provides options to edit basic details or request deletion (available only to owners). ### Overview of Fields | **Field** | **Description** | | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------ | | **Organization Name** |

Displays your current organization name.
Click the ✏️ Edit icon to rename your organization.

| | **Organization ID** |

A unique, system-generated identifier for your organization.
Click the 📋 Copy icon to copy the ID.

| | **Organization Alias** |

A short, user-friendly alias for your organization.
Click Add New Alias to create a new one.

| | **Created** | Displays the date and time the organization was created. | *** ### Danger Zone: Request to Delete This section is **visible only to organization owners**. #### Steps to Request Deletion 1. Scroll to the **Danger Zone** section. 2. Click **Request to Delete**. You will be redirected to **TestFirst Support** to submit a deletion request. {% hint style="danger" %} Deleting an organization is **permanent**. All associated data will be permanently removed and **cannot be recovered**. {% endhint %} # Automation Settings {% columns %} {% column %}
{% endcolumn %} {% column %} #### Automation Service User Manage the service user responsible for running automated tests in the cloud. Learn how service users work and how appropriateness scores are calculated. Learn more {% endcolumn %} {% endcolumns %} {% columns %} {% column %} #### Cloud Runner Settings Configure and manage cloud runner pools for your projects. Add, edit, or monitor cloud runners used for automated test execution. Learn more {% endcolumn %} {% column %}
{% endcolumn %} {% endcolumns %} # Automation Service User **Automation Service User** is a special user type responsible for running and reporting **automated tests** on the cloud. ### What Is a Service User? A **Service User** executes automated test runs and reports their results in the TestFirst cloud environment. *** ### Can FREE or PLUS Users Run Automated Tests? Yes.\ Users on **FREE** or **PLUS** plans can queue and execute automated tests on the cloud **through a Service User**.\ The Service User handles the execution, while team members can monitor the results. *** ### What Is the Appropriateness Score? The **Appropriateness Score** measures how suitable a user is for running automated tests in the cloud.\ It is **calculated automatically** based on each user’s access to required permissions for test execution. {% hint style="info" %} To ensure reliable test runs, select the **user with the highest appropriateness score** when assigning a Service User. {% endhint %} # Cloud Runner Settings The **Cloud Runner Settings** page allows you to manage **cloud runner pools**—groups of test runners that can be assigned to specific projects for executing automated tests. By default, every organization has a **Default** runner pool, which you can edit or replace with your own. *** #### Steps to Access Cloud Runner Settings 1. In the **left navigation panel**, click **Admin → Settings → Automation Settings → Cloud Runner Settings**. 2. The **Cloud Runner Settings** page will be displayed. *** #### Page Overview The page is divided into two sections: | **Cloud Runner Settings** | Displays all configured runner pools. | | -------------------------------- | ----------------------------------------------------------------------- | | **Runners in the Selected Pool** | Lists all runners (cloud and on-premise) included in the selected pool. | #### Cloud Runner Settings Table | **Name** |

The name of the cloud runner pool.
By default, a pool named Default is created for your organization.

| | ------------------------ | -------------------------------------------------------------------------------------------------------------------------------- | | **Assigned to Projects** | The list of projects assigned to the pool. Displays `` if the pool applies to all projects. | | **On-Premise Runners** | Number of on-premise runners assigned to the pool. | | **Max Cloud Runners** | The maximum number of cloud runners that can be deployed for test runs. | | **Cloud Runners** | The current number of active cloud runners. | ### Add a Cloud Runner Pool 1. On the **Cloud Runner Settings** page, click **ADD POOL** → The **Add Cloud Runner Settings** dialog will appear. 2. Enter the **Name**, set the **Max Cloud Runners**, and select the **projects** it applies to. * You can also check **Applies to All Projects** if the pool should cover all projects. 3. Click **SAVE** → The new pool will be added to the table. *** ### Edit a Cloud Runner Pool 1. On the **Cloud Runner Settings** page, right-click the pool you want to modify and select **Edit**.
2. Update the necessary fields in the **Edit Cloud Runner Settings** dialog. 3. Click **SAVE** to apply changes. *** ### Delete a Cloud Runner Pool 1. Right-click the pool you want to delete and select **Delete**. 2. Confirm your action in the **Confirmation** dialog. * Click **YES** to confirm deletion. * Click **NO** to cancel. {% hint style="warning" %} If you delete all test runner pools, you will not be able to run automated tests. Always keep at least one runner pool configured. {% endhint %} # Test Execution Module (TEM) *This article is currently being updated. Check back soon for the full details.* # Exploratory Testing

From Ideas to Coverage — Instantly

Exploratory Test Sessions let you create tests while you execute them manually.

No setup. No prewritten cases.
Just start testing, and build coverage as you go.

### Before You Start * Available only in the **Manual Testing App** {% hint style="info" %} You can download the **TestFirst Manual Testing App** from the **Utilities Pack** available in the TestFirst web application. 1. Open the TestFirst web application. 2. Scroll to the bottom of the left navigation panel. 3. Click **Utilities Pack** and download the installer. 4. Install and launch the **TestFirst Manual Testing App**. {% endhint %} * Requires **Run** permission for **Exploratory Testing** {% hint style="info" %} Get the **Manual Testing App** from the **Utilities Pack** link in the web app's bottom-left panel. {% endhint %} ### Start an Exploratory Test Session You can start a session from: * Open the **Manual Testing App** and go to **Exploratory Testing** * Click **Run Exploratory Test** to begin ### Test While You Think The session works like a normal manual test execution — with one key difference: 👉 You can **write steps as you test** {% stepper %} {% step %} ### For Each Step * Add a **Precondition** *(optional)* * Describe the **Action** * Define the **Expected Result** * Set the status (**Pass / Fail**) * Attach **screenshots** if needed 💡 Use Markdown for clarity and structure. {% endstep %} {% step %} ### Capture Results Instantly Every action you take becomes structured test data. * Steps are recorded as you write * Results are captured in real time * Failures can be turned into **bug reports** immediately {% endstep %} {% step %} ### End the Session When you're done: 1. Click **End Session** 2. Provide test details: * Title * Project * An optional hierarchy (Suite / Section / Subsection) * Optional Test Plan 3. Save {% endstep %} {% endstepper %} #### What Happens Next * Your session becomes a **test case** * The results are preserved * It is added to a **Test Plan** (or a new one is created) 👉 From exploration → structured coverage in one flow *** ### Pause Anytime Not finished? * Click **Stop** * Save as draft You can **resume or discard it** later from the **Exploratory Tests** section. *** ### Summary * Exploratory tests help you test without preparation * Capture coverage in real time * Turn exploration into reusable test cases * Report issues instantly Exploratory testing removes friction between **thinking, testing, and documenting**. You don’t just test — you **build coverage as you go**. # Import Test Cases {% hint style="info" icon="grid-2" %} Available only in the **TestFirst Manual Testing App** You can download the **TestFirst Manual Testing App** from the **Utilities Pack** available in the TestFirst web application. 1. Open the TestFirst web application. 2. Scroll to the bottom of the left navigation panel. 3. Click **Utilities Pack** and download the installer. 4. Install and launch the **TestFirst Manual Testing App**. {% endhint %} ### Overview TestFirst allows you to import test cases from a CSV file into the Test Case Library. This is useful when: * Migrating test cases from another tool * Bulk creating manual test cases * Importing existing QA documentation * Setting up projects quickly {% hint style="success" icon="unlock" %} ### Permissions Required To import test cases, users need: * **Test Case → Create/Edit permission** Depending on the imported structure, additional permissions may also be required for: * Projects * Suites * Sections * Subsections {% endhint %} {% stepper %} {% step %} ### Start the Import Wizard 1. Open the **Manual Testing App** 2. Click **Import Test Cases** from the left navigation panel The **Import from CSV Wizard** will open. {% endstep %} {% step %} ### Download the Template The wizard provides a downloadable CSV template. The template includes: * Required columns * Supported fields * Formatting instructions 💡 Use the template to ensure the import file matches the expected structure. {% endstep %} {% step %} ### Prepare the CSV File Fill the template with your test case data. The CSV file can contain: * Project * Suite * Section * Subsection * Title * Precondition * Status * Reference * Action * Expected results ⚠️ Maximum supported file size: **5 MB** {% endstep %} {% step %} ### Upload File & Configure Settings Select the CSV file and configure import settings. #### **CSV Delimiter** Usually: * `,` (comma) * `;` (semicolon) Depends on your system regional settings. #### **File Encoding** Default: * **Unicode (UTF-8)** Most editors support UTF-8 during save. {% endstep %} {% step %} ### Map Columns Map CSV columns to TestFirst fields. The wizard automatically matches columns with similar names where possible. You can also configure: * Dropdown value mappings * Custom system field mappings #### **Live Preview** Use **Live Preview** to verify how imported test cases will appear before import starts. {% endstep %} {% step %} ### Review Import Summary Before importing, TestFirst displays: * New project to be created * New suites/sections/subsections * Number of test cases * Validation issues or failures You can also preview the resulting Test Case Library structure. {% endstep %} {% step %} ### Start Import Click **Start Import** to begin importing test cases. During import: * Progress is displayed in real time * Failed records are identified * Error reasons are shown {% endstep %} {% endstepper %} ### Import Results After completion, the wizard displays: * Successfully imported test cases * Failed imports * Failure reasons * Retry options for failed rows You can also download an **Import Report** for reference. *** ### Finish the Import Click **Finish** to close the wizard. Imported test cases will appear in the **Test Case Library** after refreshing the page in web app. {% hint style="info" %} ### Notes * Close the CSV file before import to avoid file lock errors * Matching column names are mapped automatically * Validation issues are shown before import begins {% endhint %} # Help Center

What can we help you find?

Welcome to TestFirst Help Center - browse the topics, find quick answers, and troubleshooting advice all in one place..

Contact support

:leaf:

Getting startedGet help with the basics/spaces/ErSaU4WjIuLC7zfVEh8L/pages/PbYb0GukRhiS4qCHdRal

:plug:

IntegrationsExtend your workflow/spaces/ErSaU4WjIuLC7zfVEh8L/pages/YCGHCxqxVykeoFFSHdPD

:money-bill-wave:

Plans and billingGet help with your billing/spaces/ErSaU4WjIuLC7zfVEh8L/pages/X1KcdCrbkacN6yMmhDeg

:heart:

CommunityJoin our communityhttps://bit.ly/testfirst-slack

:computer-mouse:

AdminManage your account/spaces/ErSaU4WjIuLC7zfVEh8L/pages/7grt9XFWvVsXn7Nnicv2

:bullhorn:

Product updatesSee what’s newhttps://www.testfirst.com/whats-new
# Terms Of Service Latest update: 3 November 2024 ### Introduction These Terms of Service is a legally binding agreement between you as a user of TestFirst software and related services and FirstCall QA Pte. Ltd., the owner and provider of TestFirst software and related services (herein referred to as “we”, “us”, “our”). TestFirst Terms of Service (herein referred to as “these Terms” or “these Terms of Service”) contained in this agreement shall govern your use of TestFirst software, TestFirst website at and all related applications, website extensions and all services associated with it. The aforementioned scope of these Terms of Service are herein collectively referred to as “Services”. ### Agreement to Terms of Service By using the Services, you acknowledge that you have read, understood, and agree to be bound by these Terms of Service. Your use of the Services constitutes an express agreement with these Terms of Service. If you are not in agreement with all of these Terms of Service, you are prohibited from using the Services, and must discontinue their use immediately. ### Definitions/Terminology The following definitions apply to these Terms of Service, [Privacy Policy](https://docs.testfirst.com/legal-info/legal-information/privacy-policy), [EULA](https://docs.testfirst.com/legal-info/legal-information/end-user-license-agreement-eula), [Cookies Policy](https://docs.testfirst.com/legal-info/legal-information/cookies-policy) as well as any other legal agreements covering the use of the Services: * “You”, “User”, “End-User”, “Client”, “Customer” - refers to you, the person(s) acting as an individual or on behalf of a company. * “Company”, “We”, “Us”, “Our” - refers to FirstCall QA Pte. Ltd., the provider of the Services. * “Party”, “Parties” refers to both you and us * “Services” - refers to TestFirst software, TestFirst website at and all its subdomains, TestFirst support services, website extensions and all other services associated with providing access to and support for the abovementioned services. ### Intellectual Property Rights Other than the content you own and opted to include in the Services, under these Terms, we and/or our licensors own and reserve all intellectual property rights of the Services. You are granted a limited license, subject to the restrictions entailed in these Terms of Service, for purposes of using the Services. ### Services The content of the Services is not intended for use or distribution to any person or entity in any jurisdiction, geographical location, or country/state where such use or distribution will be contrary to the laws and regulations or subject the Services to any form of registration, claims, demands, costs, liabilities, damages, or expenses. The Services are intended for users who are at least 16 years of age. If you are under the age of 16, you cannot use or register to use the Services without parental permission or consent. By agreeing to these Terms of Service, you have the necessary legal capacity to comply and be bound by these Terms of Service. ### Acceptable Use You may use the Services as permitted by these Terms of Service and may not use the Services for any purpose other than for which we make the Services available. ### Cookies We employ the use of cookies on our website. By accessing our website, you agree to use cookies in Agreement with our [Cookies Policy](https://docs.testfirst.com/legal-info/legal-information/cookies-policy). ### Privacy Policy By using the Services, you may provide us with certain personal information. Our use, storage and disclosure of such information is regulated by our [Privacy Policy](https://docs.testfirst.com/legal-info/legal-information/privacy-policy) which is considered an integral part of these Terms of Service. ### License Unless otherwise stated, FirstCall QA Pte. Ltd. and/or its licensors own the intellectual property rights for all content provided in the Services, except user-created content. All intellectual property rights are reserved. The detailed list of the activities the user is prohibited from are set in the [End-User License Agreement (EULA)](https://docs.testfirst.com/legal-info/legal-information/end-user-license-agreement-eula) which is considered an integral part of these Terms of Service. ### Charges and Payments You agree to provide current, complete, and accurate purchase and account information for all purchases made via the Services. You further agree to promptly update account and payment information, including email address, and payment method, so that we can complete your transaction in a timely manner. Sales tax may be added to the Services price as required by the law. All prices for the Services listed in the Pricing page are exclusive of any sales tax. By using the Services, you agree that we can charge your debit card, credit card, or other payment provider selected by you from the list of available payment methods in accordance with the pricing valid at the time of the charge. You can be charged for all amounts due or owed for the use of the Services. All charges for the Services will be in US dollars. ### Subscriptions #### General Terms The Services are provided free of any charges, with limitations specified in the pricing page at (herein referred to as "Pricing", "Pricing page"). You can choose to upgrade your subscription as needed at the price specified in the Pricing page. If you agree to a then-current price of a plan, the price will remain for the duration of the billing cycle. We reserve the right in our sole discretion to change the price at the end of your billing cycle. The duration of your billing cycle is defined by the subscription term you choose. At the end of a billing cycle, your subscription will be automatically renewed and your selected payment method will be charged, without requiring additional consent. You may opt out of automatic renewal of the subscription. In such a case, you are solely responsible for the timely renewal of the subscription, as well as the loss of access to any features not included in the "FREE" plan. If you choose to upgrade your subscription to any pricing plan other than "FREE" as specified in the Pricing page, we will immediately bill you for the upgrade. If you upgrade to a higher level subscription plan from any paying plan, we will bill you immediately. You may change your plan at any time. If you choose to downgrade to a lower level subscription plan, you may immediately lose access to the features not provided in the plan after the downgrade. #### Refund Policy All purchases are non-refundable regardless of the remaining unused subscription term upon termination of your use of Services for any reason. #### Changes to Pricing We reserve the right, in our sole discretion, to update the Pricing as needed. Upon changes to the Pricing you will be notified via email. ### Indemnification As a condition for the use of the Services, the User agrees to indemnify TestFirst and its affiliates to the fullest extent, from and against all actions, claims, liabilities, losses, damages, costs, demands, and expenses (including reasonable attorney's fees) arising out of the User's use of the Services, including without limitation, any claim related to the breach of any of the provisions of these Terms of Service. If dissatisfied with any or all of the content of the Services or any or all of the Terms of Service, the User may discontinue using the Services. ### Termination The provisions of these Terms of Service shall remain in full force and effect while you use the Services. Users may terminate their use by following the instructions for terminating user accounts by contacting us at . We reserve the right and sole discretion to, and without notice or liability, deny access to and use of the Services (including blocking specific IP addresses) to any user for any reason including but not limited to breach of any representation, warranty, or Agreement in these Terms or any applicable law or regulation. We also reserve the right, if, in our sole discretion, we determine that your use of the Services is in breach of these Terms of Service or of any applicable law or regulation, to terminate your use of the Services or delete your account and any or all of your content, without warning or prior notice. Suppose we terminate or suspend your account for any reason set out under this section. In that case, you are prohibited from registering and creating a new account under your name, or a false identity, or the expression of a third party. In addition to terminating or suspending your account, we reserve the right to take appropriate legal action(s), including without limitation pursuing civil, criminal, and injunctive redress. ### General Provisions #### Language All correspondence made under this Agreement shall be in English. #### Governing Law & Jurisdiction These Terms of Service will be governed by and construed under the laws of Singapore. You hereby unconditionally submit to the non-exclusive jurisdiction of the courts located in Singapore for the resolution of any disputes. #### Severability Suppose any of these Terms is proven to be unenforceable or void under any applicable law. In that case, such shall not render the entirety of these Terms of Service unenforceable or invalid. As a result, any such provision shall be deleted without affecting the remaining provisions herein. The provisions of these Terms of Service that are unlawful, void, or unenforceable are deemed severable from these Terms of Service and do not affect any remaining provisions' validity and enforceability. #### Variation of Terms We reserve the right to revise these Terms at any time as we see fit. By using the Services, you are expected to review such Terms regularly to ensure you comprehend all the Terms of Service regarding the use of the Services. #### Assignment We reserve the right to assign, transfer, and subcontract our rights and/or obligations under this Agreement without any prior notification or consent required. Users shall not be permitted to assign, transfer, or subcontract any of your rights and/or obligations under these Terms. Furthermore, a person who is not a party to these Terms of Service shall have no right to enforce any provision contained therein. #### Preservation of Immunities Nothing herein shall constitute a limitation upon the privileges and immunities of the Company, which are specifically reserved. #### Waiver Our failure to exercise any or all of these Terms of Service provisions at any point in time shall not operate as a waiver of such right or provision. #### Entire Agreement These Terms of Service, including any legal notices and disclaimers provided in the Services, constitute the entire Agreement between us and you concerning your use of the Services. Ultimately, this Agreement supersedes all prior agreements and understandings concerning the same. ### Related Agreements Our [Privacy Policy](https://docs.testfirst.com/legal-info/legal-information/privacy-policy), [Cookies Policy](https://docs.testfirst.com/legal-info/legal-information/cookies-policy), [Data Retention Policy](https://docs.testfirst.com/legal-info/legal-information/data-retention-policy), and [EULA](https://docs.testfirst.com/legal-info/legal-information/end-user-license-agreement-eula) are integral parts of these Terms of Service. ### Limitations #### Warranty You understand and agree that the Services are provided “as is” and the Company, its affiliates, suppliers and resellers expressly disclaim all warranties of any kind, express or implied, including without limitation any warranty of merchantability, fitness for a particular purpose or non-infringement. The Company, its affiliates, suppliers and resellers make no warranty or representation regarding the results that may be obtained from the use of the Services, regarding the accuracy or reliability of any information obtained through the Services or that the Services will meet any user’s requirements, or be uninterrupted, timely, secure or error free. Use of the Services is at your sole risk. Any material and/or data downloaded or otherwise obtained through the use of the Services is at your own discretion and risk. You will be solely responsible for any damage to you resulting from the use of the Services. The entire risk arising out of use or performance of the Services remains with you. We cannot guarantee any specific results from use of the Services. Use is at your own risk. We reserve the right, in our sole discretion, to perform maintenance of the hardware and software employed in the provision of Services during a predefined period of time (herein referred to as "Maintenance window"). During the maintenance window, the Services may be partially or fully unavailable. The timing of the maintenance window is hereby set to 4 a.m. to 5 a.m. UTC on Sundays. We reserve the right to perform maintenance outside of the maintenance window if we, in our sole discretion, deem that the circumstances require it. #### Liability To the maximum extent permitted by applicable law, in no event will the Company or its affiliates, suppliers or resellers be liable for any special, incidental, indirect, exemplary or consequential damages whatsoever (including, without limitation, damages for loss of business profits, business interruption, loss of business information, or any other pecuniary loss or damage) arising out of the use of or inability to use the Services or the provision of or failure to provide technical or other support services, whether arising in tort (including negligence) contract or any other legal theory, even if the Company, its affiliates, suppliers or resellers have been advised of the possibility of such damages. In any case, the Company's, its affiliates’, suppliers’ and resellers’ maximum cumulative liability and your exclusive remedy for any claims arising out of or related to this agreement will be limited to the amount actually paid by you for the Services (if any) in the twelve (12) months preceding the event or circumstances giving rise to such claims. Because some states and jurisdictions do not allow the exclusion or limitation of liability, the above limitation may not apply to you. ### Contact us To resolve any complaint or obtain a clarification regarding the use of the Services or receive information concerning that, please contact us at . # Privacy Policy Latest update: 4 April 2023 ### Introduction At TestFirst (herein referred to as “we”, “us”), we collect and manage user data according to the following Privacy Policy (herein referred to as “Policy”). This Policy is applicable to the use of our website at (herein referred to as “Website”), our software provided as a service as well as our downloadable software, including but not limited to all the services associated with it. The aforementioned scope of this Policy is herein referred to as “the Services”. This Policy is a part of our [Terms of Service](https://docs.testfirst.com/legal-info/legal-information/terms-of-service) and [EULA](https://docs.testfirst.com/legal-info/legal-information/end-user-license-agreement-eula) agreements. ### Data Collected We collect several types of information through the Services. #### Information you provide to us We collect information you provide directly to us. The information is collected when you create an account, subscribe, participate in any interactive features of our services, fill out a form, request customer support or otherwise communicate with us. The types of information we may collect include your name, email address, username, payment method information and other contact or identifying information you choose to provide. We do not collect any sensitive information. #### Automatically collected data We collect anonymous data that does not contain any information allowing us to reveal user identity from every visitor of the Website to monitor traffic and fix bugs. The automatically collected data may include information on the usage of the Website, such as device type, OS version, browser type and version, IP address, language preferences, and other technical information. This information is used for internal purposes. We also collect information on our Website using cookies. For more details, refer to our [Cookies Policy](https://docs.testfirst.com/legal-info/legal-information/cookies-policy). #### Third-party information As a part of the Services, we provide the option to enable integrations with third-party services (herein referred to as “Third-Party Services”). In order to use this feature you may need to authenticate, sign up, log into Third-Party Services. When you provide authentication information in the Services we will collect the relevant data including your username and authentication token. This information is collected solely for the purpose of linking the Services with the chosen Third-Party Services and is stored in our database in an encrypted format. The collection and disclosure of this information is performed in accordance with this Policy. If you choose to use social media or your professional account to authenticate in the Services where applicable, we will receive certain information about you as a user which may include your name, email address, profile picture and other information you choose to make public on your social or professional profile. This information will be collected, stored and disclosed in accordance with the Policy. The policies under which the Third-Party Services information is stored on the Third-Party Services side is subject to the respective policies of said Third-Parties and is not in the scope of this Policy and outside of our area of responsibility. ### Use of Data We only use your personal information to provide you the Services or to communicate with you about the Services. We employ industry standard techniques to protect against unauthorized access of data about you that we store, including personal information. ### Sharing of Data We do not share personal information you have provided to us without your consent, unless: * Doing so is appropriate to carry out your own request * We believe it's needed to enforce our legal agreements or that is legally required * We believe it's needed to detect, prevent or address fraud, security or technical issues * We are legally binded to do so by the current legislation or authorities that hold such power Aggregated, anonymized data may be periodically transmitted to external services to help us improve the Service. We may allow third parties to provide analytics services. These third parties may use cookies, web beacons and other technologies to collect information about your use of the services and other websites, including your IP address, web browser, pages viewed, time spent on pages, links clicked and conversion information. ### Cookies We may use cookies on our site to remember your preferences. For more details, please review our [Cookies Policy](https://docs.testfirst.com/legal-info/legal-information/cookies-policy). ### Opt-Out, Communication Preferences You may modify your communication preferences and/or opt-out from specific communications at any time. Please specify and adjust your preferences. ### Security We take reasonable steps to protect personally identifiable information from loss, misuse, and unauthorized access, disclosure, alteration, or destruction. However, you should keep in mind that no Internet transmission is ever completely secure or error-free. If you believe your personal information might have been compromised, please contact us by the email address provided in the “Contact Us” section below. We will maintain your personal information for as long as it is required to provide the Services and for a year after the termination of Services. If you want to have your personal information removed sooner than in one year, please contact us by the email address provided in the “Contact Us” section of this Policy. ### Children’s Privacy The Website is not intended for children under the age of 16. We do not knowingly collect personally identifiable information via the Services from visitors in this age group. If you are a parent or guardian of a person under 16 years of age and you discover that that person’s information was provided to us, you may alert us of that and request that such information be deleted immediately by contacting us via the email address provided in the “Contact Us” section of this Policy. ### Changes to the Privacy Policy This Policy can be amended as needed. If any major changes are applied to this Policy, you will be notified of it via email or with an announcement on the Website. ### Contact Us You can contact us by sending an email to , or at: FirstCall QA Pte. Ltd. 1 Amber Gardens, #12-01, One Amber, Singapore # Data Retention Policy Latest update: 3 November 2024 ### Introduction The storage terms vary based on the type of data. The conditions of storage maintenance and storage terms are described in this Data Retention Policy (herein referred to as "this Policy"). All data created by a User while using the Services and stored on our servers, excluding personal data of the User, is subject to this Policy. Our User personal data storage policy is described in our Privacy Policy.This Policy is a part of our [Terms of Service](https://docs.testfirst.com/legal-info/legal-information/terms-of-service) and [EULA](https://docs.testfirst.com/legal-info/legal-information/end-user-license-agreement-eula) agreements. ### Definitions/Terminology The following definitions apply to this Policy: * "User", "you", "Client", "Customer" - refers to any user of the Services as a member of an organization within TestFirst * "Organization" - an entity created using the Services with the purpose of collaboration between Users * “Services” - refers to TestFirst software, TestFirst website at and all its subdomains, TestFirst support services, website extensions, and all other services associated with providing access to and support for the abovementioned services. * “Company”, “We”, “Us”, “Our” - refers to FirstCall QA Pte. Ltd., the provider of the Services * "Data" - for the purpose of this Policy, refers to entities created by the User while using the Services. The aforementioned entities include:
* screenshots * video recordings * attachments * test execution reports. * "Hot storage" - refers to the storage devices employed by TestFirst for the data that is accessed and maintained in real time. * "Cold storage" - refers to the storage devices employed by TestFirst for the data that hasn't been accessed in the term specified further in this Policy. Access to the data in cold storage might be slower than for hot storage. Upon a user accessing data in cold storage, it is moved to hot storage. * "Storage term" - refers to the period during which the data is retained * "Backup" - a copy of data stored for the purpose of restoring it in case of data loss or damage * "Data access", "Accessing data" - viewing, editing, or updating an entity. ### Storage Term The data created by the Customer while using the Services is stored for as long as it is required to provide the Services, or until a User deletes the data. Upon creation, the data is stored using Hot storage. If the data has not been accessed by any User in the Organization in the term specified below, the data is moved to Cold storage where it is retained for the remainder of the storage term.The data transfer between storage devices of different types is performed using a secure automated script on a daily basis. The term during which the data remains in hot storage without being accessed for each type of entity is presented in the table below: | Entity | Term of hot storage | | ---------------------- | ------------------- | | Screenshots | 1 year | | Video recordings | 1 year | | Attachments | 1 year | | Test execution reports | 1 year | Once the data in the Cold storage is accessed, it is moved to Hot storage. The process of moving data from cold storage to hot storage may take up to 24 hours. Upon the Services termination on the Organization level, the data is securely disposed of within 1 month of termination. The data may remain in the backup files for longer periods of time as specified in the Data Backup section of this Policy. Upon user request, the data may be manually disposed of before the 1-month term of the termination. ### Data Backup The data is backed up hourly using an automated script. The backup files are stored for 7 days. After 7 days, the backup files are securely disposed of. ### Data Security The data is stored in a secure server using industry-standard methods of data protection. Access to the data is only granted to authorized users. We may provide read-only access to the data to third parties if: * Doing so is appropriate to carry out your own request * We believe it's needed to enforce our legal agreements or that is legally required * We believe it's needed to detect, prevent, or address fraud, security or technical issues * We are legally bound to do so by the current legislation or authorities that hold such power ### Data Aggregation We may keep a record of your data in depersonalized, aggregated form for the purpose of statistical analysis for longer periods than specified in this Policy. This includes the number of entities of each type created within the Organization, as well as other aggregated data providing insight into the use of the Services. ### Suspension of Data Disposal in the Event of Litigation or Claims In case of any legal action taken against TestFirst, or in case of a government audit requiring submission of our data, we may suspend the data disposal until such litigation or audit is concluded. ### Changes to the Data Retention Policy This Policy can be amended as needed. If any major changes are applied to this Policy, you will be notified of it via email or with an announcement on the Website. ### Contact Us You can contact us by sending an email to . # End-User License Agreement (EULA) Latest update: 19 March 2026 ### Introduction This End-User License Agreement (herein referred to as "EULA") is a legal agreement between you and FirstCall QA Pte. Ltd. (herein referred to as “Licensor”). This EULA agreement governs your acquisition and use of our TestFirst software (herein referred to as "Software") directly from the Licensor or indirectly through a Licensor’s authorized reseller or distributor (herein referred to as "Reseller"). Please read this EULA agreement carefully before completing the installation process and using the Software. It provides a license to use the TestFirst software and contains warranty information and liability disclaimers. ### Applicability If you register for a free trial of the Software, this EULA agreement will also govern that trial. By clicking "accept" or installing and/or using the Software, you are confirming your acceptance of the Software and agreeing to become bound by the terms of this EULA agreement. If you are entering into this EULA agreement on behalf of a company or other legal entity, you represent that you have the authority to bind such entity and its affiliates to these terms and conditions. If you do not have such authority or if you do not agree with the terms and conditions of this EULA agreement, do not install or use the Software, and you must not accept this EULA agreement. This EULA agreement shall apply only to the Software supplied by the Licensor herewith regardless of whether other software is referred to or described herein. The terms also apply to any Software updates, supplements, Internet-based services, and support services for the Software, unless other terms accompany those items on delivery. If so, those terms apply. ### License Grant The Licensor hereby grants you a personal, non-transferable, non-exclusive license to use the Software on your devices in accordance with the terms of this EULA agreement. You are permitted to load the Software (for example a PC, laptop, mobile or tablet) under your control. You are responsible for ensuring your device meets the minimum requirements of the Software. You are not permitted to: * Edit, alter, modify, adapt, translate or otherwise change the whole or any part of the Software nor permit the whole or any part of the Software to be combined with or become incorporated in any other software, nor decompile, disassemble or reverse engineer the Software or attempt to do any such things * Reproduce, copy, distribute, resell or otherwise use the Software for any commercial purpose * Allow any third party to use the Software on behalf of or for the benefit of any third party * Use the Software in any way which breaches any applicable local, national or international law * use the Software for any purpose that the Licensor considers is a breach of this EULA agreement ### Intellectual Property and Ownership FirstCall QA Pte. Ltd. shall at all times retain ownership of the Software as originally downloaded by you and all subsequent downloads of the Software by you. The Software (and the copyright, and other intellectual property rights of whatever nature in the Software, including any modifications made thereto) are and shall remain the property of FirstCall QA Pte. Ltd.. FirstCall QA Pte. Ltd. reserves the right to grant licenses to use the Software to third parties. Any content generated by the end user of the Software within it is not subject to this EULA and remains the intellectual property of the user or the organization the license is granted to. ### Termination This EULA agreement is effective from the date you first use the Software and shall continue until terminated. You may terminate it at any time upon written notice to the Licensor. It will also terminate immediately if you fail to comply with any term of this EULA agreement. Upon such termination, the licenses granted by this EULA agreement will immediately terminate and you agree to stop all access and use of the Software. The provisions that by their nature continue and survive will survive any termination of this EULA agreement. ### Governing Law This EULA agreement, and any dispute arising out of or in connection with this EULA agreement, shall be governed by and construed in accordance with the laws of Singapore. ### Related Agreements By accepting this EULA you agree to comply with the Licensor’s [Terms of Service](https://docs.testfirst.com/legal-info/legal-information/terms-of-service) and [Privacy Policy](https://docs.testfirst.com/legal-info/legal-information/privacy-policy). The data created by users in the Software is subject to the Licensor's [Data Retention Policy](https://docs.testfirst.com/legal-info/legal-information/data-retention-policy). ### Contact Us If you have any questions regarding this EULA or any suspicion of fraudulent activity covered by this EULA, you may contact us at . # Cookies Policy Latest update: 4 April 2022 ### Introduction This website, (herein referred to as "Website"), is operated by FirstCall QA Pte. Ltd. This Cookies Policy (herein referred to as “Policy”) regulates the use of cookies on the Website, including but not limited to the Website’s support portal. This Policy is a part of our [Privacy Policy](https://docs.testfirst.com/legal-info/legal-information/privacy-policy). ### About Cookies Cookies are small text files that are stored in your web browser that allows the Website or a third party to recognize you. Cookies can be used to collect, store and share bits of information about your activities across websites, including on the Website. Cookies might be used for the following purposes: * To enable certain functions * To provide analytics * To store your preferences * To enable ad delivery and behavioral advertising The Website may use both session cookies and persistent cookies. A session cookie is used to identify a particular visit to our Website. These cookies expire after a short time, or when you close your web browser after using our Website. We use these cookies to identify you during a single browsing session, such as when you log into our Website. A persistent cookie will remain on your devices for a set period of time specified in the cookie. We use these cookies where we need to identify you over a longer period of time. For example, we would use a persistent cookie if you asked that we keep you signed in. ### Third-party usage of cookies Third party companies like analytics companies and ad networks generally use cookies to collect user information on an anonymous basis. They may use that information to build a profile of your activities on the Website and other websites that you've visited. ### Your cookies options If you don't like the idea of cookies or certain types of cookies, you can change your browser's settings to delete cookies that have already been set and to not accept new cookies. To learn more about how to do this, visit the help pages of your browser. Please note, however, that if you delete cookies or do not accept them, you might not be able to use all of the features we offer, you may not be able to store your preferences, and some of our pages might not display properly. ### Additional sources of information on cookies You can read more about cookies and how they are used at . Contact Us You can contact us by sending an email to , or at: FirstCall QA Pte. Ltd. 1 Amber Gardens, #12-01, One Amber, Singapore