# Solution Overview

Reduce Test Runs and CI Pipeline Build Time by 80% with Appsurify!

Overview of Appsurify TestBrain Solution: AI-Powered Risk Based Testing, Flaky Test Management, Your Model Insights & Performance, and Test Run Analytics. 

[Appsurify ](https://appsurify.com/)is a **QA Intelligence Platform** focused on optimizing CI pipelines and Automated Test Runs through its **patented** Risk-Based Testing Technology for Faster Test Feedback and Streamlined Workflows. 

## Patented Risk-based Testing Technology 

Appsurify's patented proprietary Risk-based testing technology leverages AI/ML to auto select and execute **only the tests relevant** to recent Developer changes on a per Commit basis. 

By only running a **Smart Subset** of tests, teams **optimize** their CI pipeline and get Test Feedback to QA & Developer **10x faster** - freeing up infrastructure resources and increasing team output. 

Appsurify is **code-language agnostic** and supports **all test types**, such as UI, E2E, API, Integration, Unit, etc. 

Best practice has Teams running dynamic smart subsets throughout the day with a schedule Full Run periodically to catch anything that may have been missed in the Smart Test Selection. 

This Best Practice is adopted by tech giants, Facebook and Google. Link [here](https://engineering.fb.com/2018/11/21/developer-tools/predictive-test-selection/).  

## Flaky Test Management

Appsurify has **two** underlying AI-Models, one for Risk Based Test Selection and another for **Flaky Test Management.** 

Appsurify's Flaky AI-Model can distinguish tests that have failed due to real defects versus tests that have failed due to Flakiness, i.e., no underlying change to the codebase. 

<figure><img src="/files/irTThvKpXr0WSS1IXwFK" alt="Stop Flaky Tests" width="469"><figcaption><p>Give Developers and QA Clean Signals throughout the Day! </p></figcaption></figure>

Flaky Tests or False Flags **distract** Developers and **QA** teams from the real-defects.&#x20;

By leveraging Appsurify's Flaky AI-Model, teams can optionally configure their Builds and Test Runs to fail only on **Real-Defects** even when there is a high percentage of Flakiness in their test runs to keep their Builds and Test Executions running optimally.&#x20;

Because giving **clean signals** back to Developers and QA **saves precious time** during the workday.&#x20;

## Your Model Insights & Performance

One of the latest features and value additions to the Appsurify **QA Intelligence Platform** has been the introduction of **Your Model Insights Page** in the UI.&#x20;

**Trust** is the cornerstone of AI/ML, and Your Model Page gives **full transparency** into your Model's Performance on a Per Run basis.&#x20;

<figure><img src="/files/9pOsOBAuLFFAIIop6hTr" alt="AI Model Performance" width="563"><figcaption><p>Test it! <strong>Select</strong> a Percentage of Tests to Run to See how Your Model Performs at the most Granular Level!</p></figcaption></figure>

**Simulate** how your Model will perform on a per Run Basis by selecting a Percentage of Tests to Run to see which tests are Optimized (not run), Prioritized (run), Regressions Found Early (defects caught in smart subset), and anything the AI-Model may have missed in Deferred Regressions (Defects that will be picked up at the next Full Run).&#x20;

Once Appsurify is engaged and actively Prioritizing your Tests, Your Model Insights page will **always be available for reference** to ensure you always have **visibility and trust** in an easy to understand Dashboard on how your Model is performing in Real-Time.&#x20;

More information on [Your Model Insights & Performance](/ui-and-value-features/your-model-insights).&#x20;

## Test Run Analytics

In your Summary Page, have a complete view to the value your Risk Based Test Selection is having on your team's newly optimized workflows and Test Run Analytics

<figure><img src="/files/kh9Y67hsSWKcK7CJrEE4" alt="CI Optimization Analytics" width="563"><figcaption><p>Dashboard into Real-Time Analytics</p></figcaption></figure>

Dynamically see how each test run is performing and bringing faster value to your organization.

* Follow the Health and Integration for the Project to Optimize.
* Gain insight into the Maturity of their Model for the active Project via the "Maturity Wheel"
* Visibility into the Value Appsurify brings through the "Time Savings" and "Risk Based Test Selection" Graphs.
* More information on the [Dashboard here](/ui-and-value-features/dashboard). <br>

## Next: [Getting Started! ](/getting-started/getting-started)


# Getting Started

Easy to Install and Easy to Use

## 3 Requirements to be Successful

1. Access to Developer Repository(s)
2. Access to CI Pipeline
3. Access to Tests

### Why do I need these:

* **Developer Repository**: To Push Developer Commit Metadata so we can see where changes are made, and therefore, prioritize test execution based on those changed areas.&#x20;
* **CI Pipeline:** To connect the Tests and Pipeline for optimization, and to execute the prioritized tests based on a per build/change basis.&#x20;
* **Access to Tests:** The automated testsuites you'd like to Optimize for faster feedback to catch regressions earlier and more economically.&#x20;

## Get Started in Steps: &#x20;

1. [Sign up and Create Account](/getting-started/sign-up-and-create-account)
2. [Create Project](/getting-started/step-1-create-project)
3. [Connect Developer Repository](/getting-started/step-2-connect-repository)
4. [Connect Tests in CI Pipeline](/getting-started/step-3-connect-tests)
5. [Start Prioritizing Tests](/getting-started/start-prioritized-testing)&#x20;

## Integrations

[Prebuilt Integrations](/integrations/integrations)

## Smart Test Selection Explained

[How and why we select tests. ](/getting-started/working-knowledge/smart-test-selection-explained)\ <br>

## Next: [Sign up and Create an Account!](/getting-started/sign-up-and-create-account)&#x20;


# Sign up and Create Account

Simple SaaS onboarding workflow 👌

### Open the Appsurify [Sign up Page](https://app.appsurify.com/login)

<figure><img src="/files/p0smbNgpos0Q4xxOGW3v" alt="appsurify create account"><figcaption></figcaption></figure>

### Confirm Email

<figure><img src="/files/Nbv1kdsARuKCBO5YeAWR" alt="appsurify confirm email"><figcaption></figcaption></figure>

### Enter you Appsurify Instance / Account

<figure><img src="/files/vih7lvU0Ic6dRfDml0wo" alt="appsurify welcome page"><figcaption><p>You'll be dropped into your Summary Page</p></figcaption></figure>

### Next Step: [Create a Project](/getting-started/step-1-create-project)


# Step 1: Create Project

A Project is defined as an Application that will be supported.

## About Accounts:

* One **Account** per Team / Company.
  * Each Account can support multiple Projects.&#x20;
  * Larger organizations can have multiple Accounts based on sub-divisions.&#x20;

### About Projects

* Each **Project** represents an Application that will be Tested against.&#x20;
  * For example, a Frontend Application, etc.&#x20;
* Each **Project** can have multiple Test-suites supported and optimized.
  * Multiple Repositories can be connected to each Project for Coverage.&#x20;

### Role-based Access&#x20;

Before the following, add new team members to your Team's Account in the top right-hand corner under **"User Admin"**. This will send each newly added member an **Email Invite** to access the Instance. This can be done later at any time.&#x20;

* **Owners** created the Project.
* **Admins** have editing right to each Project they are assigned.&#x20;
* **Users** only have viewing rights to a specific project to which they are granted access.&#x20;

To add team members to each project after they've gained access to the account via email invite, for a **select Project**, click on the **right hand column UI page "Users"**, to add team members to that Project.&#x20;

## Create a Project flow:

1. Click on "**Create a Project**" in the Summary Page

<figure><img src="/files/LOAZVQbFBSvH8NngjT4E" alt="create a project"><figcaption></figcaption></figure>

2. Pop up window will ask for Project details:
   * Name of application that will be supported.
   * Test suite framework that will be supported.
     * For example, Cypress, Playwright, Selenium, etc.&#x20;

<figure><img src="/files/gBfVpxFJJ4vTGLEucA1N" alt="create project flow"><figcaption></figcaption></figure>

3. Once Complete, a Green Popup should appear in right hand corner of screen Confirming the new Project was **Created**.&#x20;

<figure><img src="/files/W4W3JcHFrHAQWoXkHlHe" alt="create project success"><figcaption></figcaption></figure>

4. Next Pop up window will allow you to add your team memberes to the Project. You can also Skip this step and do later under "User Admin" on top right corner.&#x20;
   1. Note: You **cannot** add a New Member here until that New User has been added into the **Account** by the User Admin.&#x20;

<figure><img src="/files/rgSA2uqkQsmlCklIlGdg" alt="add new members to project"><figcaption></figcaption></figure>

You can add new Users to created projects at a later day easily once they've accepted the email invite to be added to the **Account**. For detail, see [User Admin](/getting-started/working-knowledge).&#x20;

## Select Repository Connection Type

1. With "Script" selected and underlined, click **SAVE** to confirm

<figure><img src="/files/ukL9JLOEUcQBlL0c4O0K" alt="appsurify repository connection options"><figcaption><p>Select Script as Repo Connection Type</p></figcaption></figure>

Unless directed by the Appsurify Team, select **"SCRIPT"** as the Repository Connection type.

**NOTE**: Important to Click the **SAVE** button to designate the Repository Connection Type.&#x20;

2. Click through next Pop ups and Finish

<figure><img src="/files/XPnSd1IIIegtsf7QHySX" alt="create project finish"><figcaption></figcaption></figure>

**Great work!** You've set up your Project - now it's time to Connect your Repository!

## Next: [Connect Repository](/getting-started/step-2-connect-repository)


# Step 2: Connect Repository

Start Pushing Commit Metadata

## Repositories Supported

Appsurify supports all **Git-based, Microsoft TFVC, SVN,** and **Perforce** Repositories.&#x20;

**Repository Architectures** Supported:

* Monolithic
* Multi-Repo
* Microservices

## Connect Repository via CLI Script

The below example shows the `--gittoappsurify` command to push Commit Metadata to Appsurify. This command will push the project details and bind the Developer Repository so that Appsurify can see the changes and base it's Predictive Test Selection criteria based on areas of change from recent Commits.&#x20;

### \*Need to have Python 3.7 installed or higher\*

### Step 1: Install AppsurifyCI&#x20;

Place script in CLI (as seen in image below, and **above** --gittoappsurify)

```
--pip install --upgrade pip
```

Then Enter:

```
--pip install appsurifyci --upgrade
```

### Step 2: Enter your Script

**Example**:

```
--pip install appsurifyci --upgrade
```

**Then**

```
--gittoappsurify --start "latest" --url "https://testbraindemo.appsurify.com" --project "application" --token "NTk65cD1Ua3doV3luNDRuMjNCMDRjV2EVkx0dwzz" --branch "branch" --repo_name "repo"
```

## Script Parameters Defined

| Parameters                                   | Definition                                                                                                                                 |
| -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
| `--gittoappsurify`                           | Connection to Appsurify Servers                                                                                                            |
| `--start "latest"`                           | Latest Commit, needs FULL SHA                                                                                                              |
| `--url "https://ABC.appsurify.com"`          | Your Domain                                                                                                                                |
| `--project "application"`                    | the name of your Project during initial setup                                                                                              |
| `--token "API Key"`                          | <p>API Key found under your username in top right hand corner dropdown menu.<br><br>API Key can be configured in CI Server as a Secret</p> |
| `--branch "branch"`                          | Developer Branch we are targeting                                                                                                          |
| `--repo_name "repo"`                         | Name of Developer Repository we are targeting                                                                                              |
| `--debug`                                    | Prints out more information for any issues                                                                                                 |
| `git fetch --all then git checkout [branch]` | Issues with Connecting Repository...                                                                                                       |

#### Once the project is pushed, Appsurify will look it up and your Repo Bind will turn <mark style="color:green;">Green</mark> in the Summary Page and Appsurify will begin receiving regular Developer Commits.

<figure><img src="/files/2sP3c4YPNzJxQ8CuWBxR" alt="appsurify repository connection good"><figcaption></figcaption></figure>

If have any questions or for troubleshooting, please contact Appsurify [Customer Success](https://appsurify.com/contact/)

## Next: [Connect Tests](/getting-started/step-3-connect-tests)

\
Other Connection Types:
-----------------------

* SSH Key
* GitHub / Bitbucket APIs via Oauth (approval likely needed)
* Microsoft TFVC via Script
* Perforce Connection via Script
* SVN Connection via Script

If you'd like to Connect a Repository other than Git, please contact[ Appsurify Customer Success](https://appsurify.com/contact/).&#x20;


# Updated New Script

This Script is faster, more powerful, and easier to implement.

## Appsurify Script Installation

***

### Index

* Installation Instructions
  * Requirements
  * Support OS / Python
  * Installation Command
* Repository Push / Git2TestBrain (git2appsurify)
  * Possible params
  * Usage Examples
* Repository Checkout
  * Possible Params
  * Usage Examples

## Installation Instructions

***

### Requirements

{% hint style="success" %}
Python 3.7+
{% endhint %}

### Support OS / Python

<table><thead><tr><th width="253">OS</th><th width="232">Python</th><th>Support</th></tr></thead><tbody><tr><td>Linux</td><td>3.7</td><td> 🟢</td></tr><tr><td>Linux</td><td>3.8</td><td> 🟢</td></tr><tr><td>Linux</td><td>3.11</td><td> 🟢</td></tr><tr><td>MacOS</td><td>3.7</td><td> 🟢</td></tr><tr><td>MacOS</td><td>3.8</td><td> 🟢</td></tr><tr><td>MacOS</td><td>3.11</td><td> 🟢</td></tr><tr><td>Windows</td><td>3.7</td><td> 🟢</td></tr><tr><td>Windows</td><td>3.8</td><td> 🟢</td></tr><tr><td>Windows</td><td>3.11</td><td> 🟢</td></tr></tbody></table>

### Installation Command

```
pip install appsurify-testbrain-cli
```

or

```
poetry add appsurify-testbrain-cli
```

{% hint style="info" %}
Note: Use -U or --upgrade for force upgrade to last version
{% endhint %}

### Docker image "appsurify-testbrain-cli"

#### Latest Version

```
docker pull appsurifyinc/appsurify-testbrain-cli
```

#### Specify version

```
docker pull appsurifyinc/appsurify-testbrain-cli:2023.10.24
```

## Repository Push | Git2Testbrain (git2appsurify)

***

This module is used to push changes in the repository to the Testbrain server for further analysis and testing optimization.

{% hint style="info" %}
This module can be used as an independent command in the OS or as a subcommand of the main CLI application "testbrain"
{% endhint %}

Alias #1

```
testbrain repository push --help
```

Alias #2

```
git2testbrain push --help
```

Alias #3

```
testbrain git2testbrain push --help
```

### Parameters

<table><thead><tr><th width="141">Required</th><th width="121">Parameter</th><th width="95">Default</th><th width="138">Env</th><th>Description</th></tr></thead><tbody><tr><td>Yes</td><td>--server</td><td></td><td>TESTBRAIN_SERVER</td><td>Enter your Testbrain server instance url.</td></tr><tr><td>Yes</td><td>--token</td><td></td><td>TESTBRAIN_TOKEN</td><td>Enter your testbrain server instance token or API Key. <br><br>Located in top-right hand corner of user-interface under user profile. </td></tr><tr><td>Yes</td><td>--project</td><td></td><td>TESTBRAIN_PROJECT</td><td>Enter your Testbrain projet name. </td></tr><tr><td>No</td><td>--work-dir</td><td>current dir</td><td>TESTBRAIN_WORK_DIR</td><td>Enter the testbrain script working directory. If not specified, the current working directory will be used. </td></tr><tr><td>No</td><td>--repo name</td><td></td><td>TESTBRAIN_REPO_NAME</td><td>Define repository name. If not specified, it will be automatically taken from the GitRepository repository.</td></tr><tr><td>No</td><td>--repo-dir</td><td>current dir</td><td>TESTBRAIN_REPO_DIR</td><td>Enter the git repository directory. If not specified, the current working directory will be used. </td></tr><tr><td>No</td><td>--branch</td><td>current</td><td>TESTBRAIN_BRANCH</td><td>Enter the explicit branch to process commits. If not specified, use current active branch. </td></tr><tr><td>No</td><td>--start / --commit</td><td>latest (HEAD)</td><td>TESTBRAIN_START_COMMIT</td><td>Enter the commit that should be starter. If not specified, it will be used 'latest' commit. </td></tr><tr><td>No</td><td>--number</td><td>1</td><td>TESTBRAIN_NUMBER_OF_COMMITS</td><td>Enter the number of commits to process. </td></tr><tr><td>No (unavailable)</td><td>--blame</td><td>false</td><td></td><td>Add blame information.</td></tr><tr><td>No</td><td>--minimize</td><td>false</td><td></td><td>Suppress commit changes information. [default; (False)]</td></tr><tr><td>No</td><td>--pr-mode</td><td>false</td><td>TESTBRAIN_PR_MODE</td><td>Activate PR mode</td></tr><tr><td>No</td><td>-l, --loglevel</td><td>INFO</td><td></td><td>Possible fatalities: DEBUG/INFO/WARNING/ERROR</td></tr><tr><td>No</td><td>--logfile</td><td>stderr</td><td></td><td>Saves logs to file</td></tr><tr><td>No</td><td>--quiet</td><td>fales</td><td></td><td>Quiet mode...every time exit with 0</td></tr></tbody></table>

### Usage Examples

Push to Testbrain server only one last commit from current branch:

```
git2testbrain --server https://demo.appsurify.com --token ************************************************************** --project DEMO
```

Or

```
git2testbrain push --server https://demo.appsurify.com --token ************************************************************** --project DEMO
```

Push to Testbrain server last 100 commits started from specify commit into specify branch:

```
git2testbrain --server https://demo.appsurify.com --token ************************************************************** --project DEMO --branch main --start latest --number 100
```

If need more process information - change logging level:

```
git2testbrain --server https://demo.appsurify.com --token ************************************************************** --project DEMO --branch main --start latest --number 100 --loglevel DEBUG
```

Add log file with full or relative path:

```
git2testbrain --server https://demo.appsurify.com --token ************************************************************** --project DEMO --branch main --start latest --number 100 --loglevel INFO --logfile ./git2testbrain.log
```

If any crash errors script will create crash dump file into {WORK\_DIR}/.crashdumps/

```
git2testbrain --server https://demo.appsurify.com --token ************************************************************** --project DEMO
```

You can see this message:

```
2023-11-05 21:16:03 INFO     testbrain.repository.cli push [repository/cli.py:184] Running...
2023-11-05 21:16:03 DEBUG    testbrain.terminal.process Process.__init__ [terminal/process.py:22] Set up execution working dir ...
Dumped crash report to <path_to_work_dir>/.crashdumps/git2testbrain-2023-10-23-11-27-39.dump
```

**Docker version usage**

$(pwd) - git repository path

```
docker run --rm -it \
-v $(pwd)/:/data \
appsurifyinc/appsurify-testbrain-cli git2testbrain --server https://demo.appsurify.com --token ************************************************************** --project DEMO
```

#### CI example (github actions)

.github/workflows/testbrain-git2testbrain.yml

```
name: "Testbrain"

on:
    workflow_dispatch:
    pull_request:
        branches:
            - "main"
            - "development"
    push:
        branches:
            - "main"
            - "releases/*.*.*"
            - "development"

jobs:
    push-changes:
        name: "Push changes to server"
        runs-on: ubuntu-latest
        permissions:
            contents: write
            pull-requests: write
            checks: write
        steps:
            - name: "Checkout repository"
              uses: actions/checkout@v4
              with:
                  fetch-depth: 0
            - name: "Extract branch name"
              shell: bash
              run: echo "branch=${GITHUB_HEAD_REF:-${GITHUB_REF#refs/heads/}}" >> $GITHUB_OUTPUT
              id: extract_branch
            - name: "Push"
              uses: addnab/docker-run-action@v3
              with:
                  image: appsurifyinc/appsurify-testbrain-cli:latest
                  options: -v ${{ github.workspace }}:/data -e TESTBRAIN_PR_MODE=${{ github.event_name == 'pull_request' }}
                  run: |
                      git2testbrain push --server ${{ vars.TESTBRAIN_SERVER }} --token ${{ secrets.TESTBRAIN_TOKEN }} --project ${{ vars.TESTBRAIN_PROJECT }} --branch ${{ steps.extract_branch.outputs.branch }} --start ${{ github.sha }} --number ${{ vars.TESTBRAIN_NUMBER_OF_COMMITS }} -l DEBUG
            - name: "Upload crash dumps"
              uses: actions/upload-artifact@v3
              if: failure()
              with:
                  name: "crashdumps"
                  path: ${{ github.workspace }}/.crashdumps/
                  retention-days: 1
```

### Repository Checkout

***

This module is used to checkout branches during the execution of CI pipelines or manually. **Cloning is not provided.**

Alias #1 &#x20;

```
testbrain repository checkout --help
```

Alias #2 &#x20;

```
git2testbrain checkout --help
```

Alias #3&#x20;

```
testbrain git2testbrain checkout --help
```

### Parameters

<table><thead><tr><th width="130">Required</th><th width="120">Parameter</th><th width="128">Default</th><th width="129">Env</th><th>Description</th></tr></thead><tbody><tr><td>No</td><td>--repo-dir</td><td>current dir</td><td>TESTBRAIN_REPO_DIR</td><td>Enter the git repository directory. If not specified, the current working directly will be used.</td></tr><tr><td>No</td><td>--branch</td><td>current</td><td>TESTBRAIN_BRANCH</td><td>Enter the explicit branch to process commits. If not specified, use current active branch. </td></tr><tr><td>No</td><td>--commit</td><td>latest (HEAD)</td><td>TESTBRAIN_START_COMMIT</td><td>Enter the commit that should be starter. If not specified, it will be used 'latest' commit.</td></tr><tr><td>No</td><td>--pr-mode</td><td>False</td><td>TESTBRAIN_PR_MODE</td><td>Activate PR mode</td></tr><tr><td>No</td><td>--work-dir</td><td>current dir</td><td>TEST_WORK_DIR</td><td>Enter the testbrain script working directory, the current working directory will be used. </td></tr><tr><td>No</td><td>-l, --loglevel</td><td>INFO</td><td></td><td>Possible Fatalities: DEBUG/INFO/WARNING/ERROR</td></tr><tr><td>No</td><td>--logfile</td><td>stderr</td><td></td><td>Save logs to file</td></tr><tr><td>No</td><td>--quiet</td><td>false</td><td></td><td>Quiet mode...every time exit with 0</td></tr></tbody></table>

### Usage Examples:

Checkout using Testbrain CLI

```
git2testbrain checkout --branch main -l INFO
```

Or

```
git2testbrain checkout --branch main --commit 75ec2f061868c33306963a27d5164211553c049b --pr-mode -l INFO
```

Or

```
git2testbrain checkout --branch main --commit 676c581 --pr-mode -l INFO
```

Docker version usage

$(pwd) - git repository path

```
docker run --rm -it \
-v $(pwd)/:/data \
appsurifyinc/appsurify-testbrain-cli git2testbrain checkout --branch main --commit 676c581 --pr-mode -l INFO
```


# Step 3: Connect Tests

Start pushing Test Results

## Add Script in CI Pipeline to Connect Tests

Need to add an executable script in the CI to call the TestBrain API with the test conditions.

## Requirements

* Required: **Python 3.7+**

## Installation Command

```
--pip install appsurifyci --upgrade
```

## Available Arguments

| Argument                  | Options                                                                                                                                                                                                                                      |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--runtestswithappsurify` | Call to Appsurify TestBrain API                                                                                                                                                                                                              |
| --`apikey`                | <p>API Key from Appsurify Instance. Found in top right hand corner drop-down menu.<br>Can be stored as a Secret in CI server secret storage capabilities.<br>Reference the Secret via variable Script execution in the CI configuration.</p> |
| `--url`                   | Url of Appsurify Instance i.e., <https://dummy.appsurify.com/>                                                                                                                                                                               |
| `--project`               | Name of the project                                                                                                                                                                                                                          |
| `--testsuite`             | Name of the Test Suite                                                                                                                                                                                                                       |
| `--branch`                | Name of the branch the tests are running against                                                                                                                                                                                             |
| `--commit`                | SHA of the commit (need full SHA)                                                                                                                                                                                                            |

## Recommended Arguments

| Argument         | Options                                                                                                                                                                                                                                                       |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--runtemplate`  | <p>Options - <strong>all tests, no tests, prioritized tests</strong>.<br><strong>See below for more details.</strong> </p>                                                                                                                                    |
| `--testtemplate` | <p>Options - mvn, pytest, cypress, mocha, mstest, vstest, opentest...etc. <br><br>See Integrations for more supported Test Frameworks</p>                                                                                                                     |
| `--runcommand`   | <p>Command to execute tests in the target environment, if command is custom to your test suite. <br><br>Note, <code>--runcommand</code> will override generic <code>--testtemplate</code> at time of final configuration and prioritized test execution. </p> |
| `--report`       | Location of XML reports created by the test run if this is not the default location for the test type.                                                                                                                                                        |
| `--pipeoutput`   | Additional logging is printed to the screen from the Test Execution runner to help with Debugging and Logs                                                                                                                                                    |

## Test Execution Parameters

|                       |                                                                                                                                                                        |
| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--all tests`         | <p>Will run all tests. Will fail on any failure.<br>Recommended for nightly or weekly test executions. <br><br><strong>Recommended for Appsurify to Learn</strong></p> |
| `--no tests`          | <p>Will run no tests. Will fail on any failure.<br>Recommended when starting with Appsurify to just upload data. </p>                                                  |
| `--prioritized tests` | <p>Requires the Percentage or Time based Argument.<br><br>Will fail the build on new / re-opened defects.<br><br>Predictive Test Selection Technology<br></p>          |

## Example

```
--runtestswithappsurify --url "https://ABC.appsurify.com" --apikey "api key" --project "project" --testsuite "testsuite" --runtemplate "all tests" --runcommand "mvn" --commit "commit id" --branch "branch" --report "report" --pipeout "true"
```

## Example in CI Pipeline

```
--runtestwithappsurify --url "https://testbraindemo.appsurify.com" --apikey "NTk6cD1Ua3doV3uNDMdWzz" --project "TestBrainDemoJunit" --testsuite "Selenium" --runtemplate "all tests" --runcommand "mvn" --commit "commit id" --branch "branch" --report "report" --pipeoutput "true"
```

## Confirmation: Test Bind Turns Green

Upon successful Test Connection, in your Summary Page - your Test Bind Icon turns <mark style="color:green;">Green</mark>.&#x20;

<figure><img src="/files/KtOB72lXSLTJLgU2d0J6" alt="appsurify test bind connection successful"><figcaption></figcaption></figure>

## Push tests as part of CI process to build Model Maturity

Now that you've successfully Connected your Tests, automate them as part of the CI build process  to build the Model Maturity wheel. \
\
Depending on how many Test Runs per day, this could take \~2-3 weeks. AKA, the more test data / runs - the stronger the results!&#x20;

Once Model Maturity wheel has hit 50 Test runs or 100%, your Model will be trained over the following weekend, and will be subsequently ready for Predictive Test Selection mode - and your team can begin to enjoy the time and resource savings!&#x20;

## Additional Arguments - For Customization

<table><thead><tr><th width="268">Argument</th><th width="188.33333333333331">Default</th><th>Options / Details</th></tr></thead><tbody><tr><td><code>--fail</code></td><td><code>newdefects</code><br><code>reopeneddefects</code></td><td>Options: <code>newdefects, reopeneddefects, flakybrokentests, newflaky, reopenedflaky, failedtests, brokentests</code></td></tr><tr><td><code>--rerun</code></td><td>"false"</td><td>whether failed tests should be rerun</td></tr><tr><td><code>--maxrerun</code></td><td>3</td><td>the number of times failed tests should be rerun</td></tr><tr><td><code>--failfast</code></td><td>"false"</td><td>whether after each set of tests runs to determine if the build has failed (tests will still be rerun if this has been selected)</td></tr><tr><td><code>--executioncommand</code></td><td>" "</td><td>command to be executed following completion of the script [[teststorun]] will be replaced with the formatted list of tests to run</td></tr><tr><td><code>--percentage</code></td><td>" "</td><td>Percentage based prioritized test selection and execution. <strong>RECOMMENDED</strong> to start ~30%. <br><br>Example: <br><code>--percentage "20"</code> would run top 20% of tests most likely to fail. </td></tr><tr><td><code>--time</code></td><td>" " </td><td>Time based prioritized test execution. <br><br>Example: <br>--time "45s" would run top 45 seconds of tests most likely to fail.<br><br>Example<br>--time "10m" would run top 10 minutes of tests most likely to fail. </td></tr></tbody></table>

## Next: [Start Test Prioritization](/getting-started/start-prioritized-testing)!


# Training AI Model

Learning Mode

## Learning Mode

Once you see the 'Test Bind' indicator turn Green on your Summary Dashboard, you'll need to remain in "Learning Mode" until the Maturity Wheel reaches 100% for the AI-Model to be fully trained and ready to go.&#x20;

To get your Model to Maturity as fast as possible, ensure the daily or nightly test runs are **automatically pushed to the Appsurify platform as part of the CI Build Process**, rather than manually pushing - as your AI-Model needs 50 Test Runs to be fully trained for the strongest results.

Depending on how many Test Runs per day, this could take \~2-3 weeks. AKA, the more test data / runs - the stronger the results!&#x20;

<figure><img src="/files/68AnqF2XW0jyb8T0RHg2" alt=""><figcaption><p>Model Begins to Build with every new Test Run</p></figcaption></figure>

Once Model Maturity wheel has hit 50 Test runs or 100%, your Model will be trained over the following weekend, and will be subsequently ready for Predictive Test Selection mode - and your team can begin to enjoy the time and resource savings!&#x20;

It will then **continually recalibrate every 25 Test Runs** to ensure it is up-to-date on the latest and greatest data.&#x20;

### For any newly added Test Script:

For any **new test script** that is introduced at any time, the Model will always prioritize this test for 10 runs to ensure robust Linkage between Test and Code.&#x20;

## Simulate your Model Performance in "Your Model Insights"

**\*Model must be Trained for Model Insights page to populate.**

See how your AI Model performs in real-time against your test runs to build trust and help with your implementation. Play around with different Percentage subsets to come to a comfort area of time and resource savings.&#x20;

Remember, when the AI-Model is 1st trained - it will be at it's youngest with a bright future ahead of it. Every 25 new test runs - the Model Recalibrates and grows stronger. Therefore, it will continue to grow stronger and stronger over time. If you are unsatisfied with the initial training of your Model, Best Practice would be to leave it in "Learning Mode" until it reaches a point of Maturity that brings value and confidence to your organization.&#x20;

[**Model Insights Page**](/ui-and-value-features/your-model-insights)


# Start Prioritized Testing

Leverage Predictive Test Selection Technology

## Start Test Prioritization

Now that your Model is 100% mature and trained, let's have you start reaping the benefits of Predictive Test Selection 🚀

Your model will recalibrate on a rolling basis every 25 runs. As more Test Runs are pushed, your Model becomes stronger and stronger for better results!&#x20;

As you update your Script, review [Best Practices before Turning On](/getting-started/start-prioritized-testing/best-practice-before-turning-on).&#x20;

## Update CI Script to "Prioritized Tests"

|                       |                                                                                                                                                                                                                                                                                             |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--all tests`         | <p>Will run all tests. Will fail on any failure.<br>Recommended for nightly or weekly test executions. </p>                                                                                                                                                                                 |
| `--no tests`          | Will run no tests                                                                                                                                                                                                                                                                           |
| `--prioritized tests` | <p>Runs Percentage or Time-based subset of tests based on Changes. <br><br><strong>Requires the Percentage or Time-based Argument.</strong> <br><br>Will fail the build on new / re-opened defects. <br><br>Recommended for your most frequent run type. </p>                               |
| `--percentage`        | <p>Percentage amount of tests to be selected in Smart Subset. <br><br>Example "30" will run Top 30% of highest priority tests most likely to Fail. </p>                                                                                                                                     |
| `--time`              | <p>Time based parameter for Maximum time allowed for Test Execution. <br><br>Example "45s" would run the Highest Priority Tests most likely to Fail within the 45 seconds timeframe. <br><br>Example "10m" would run the highest priority Tests most likely to Fail within 10 minutes. </p> |

## Example: Script running Prioritized 30% of Tests on each Test Run:

```
--runtestswithappsurify --url "https://dummy.appsurify.com" --apikey "api key" --project "application1" --testsuite "testsuite" --runtemplate "prioritized tests" --percentage "30" --testtemplate "mvn" --commit "commit id" --branch "branch" --report "report" --pipeoutput "true"
```

## Example with specific Project Details:

```
--runtestswithappsurify --url "https://dummy.appsurify.com" --apikey "NTk6cD1Ua3dwJZ8k3GnP2" --project "TestBrainDemoJunit" --testsuite "selenium" --runtemplate "prioritized tests" --percentage "30" --testtemplate "mvn" --commit "$GITHUB_SHA" --branch "branch" --report "report" --pipeoutput "true"
```

\
Summary page should begin to reflect optimized test runs with prioritized testing:

**Example Display** of how this may look, differs from Project to Project:

<figure><img src="/files/gsedZTqmbm4p9jyBupkF" alt="prioritized test execution"><figcaption><p>Dashboard will Populate accordingly</p></figcaption></figure>

Enjoy the **Value of Prioritized Testing** by reaping time and resource savings by only running the tests impacted by developer changes on a per change basis!

Some important considerations as you insert the AI-Model...

## IMPORTANT: Where to Insert your AI Model

Appsurify is designed to bring speed and resource saving while inserting a measured amount of risk into each test run i.e., Catch 99%+ of Bugs running a Smart Subset of 10-20% of Tests.&#x20;

Best Practice is to insert your AI-Model into a Pre-Merge environment where a scheduled Full-Run or Catch-All takes place before Release.&#x20;

A **Developer Branch** or **Feature branch** is a great example of where value is most realized. Activity is high, CI pipelines are busy, and the need for quick feedback is important.&#x20;

**Best Practice Placement:**

* **Pre-Commit Checks**
* **Pre-Merge CI Jobs**

Please consult with Appsurify Customer Success if you wish to implement in

* Post-Merge CI Jobs
* Pre-release / Nightly CI Jobs

Appsurify is designed to Save Time and Resources during the productivity day (or when CI pipelines are most active) and to ensure changesets are tested thoroughly before releasing.&#x20;

## IMPORTANT: Ensure to schedule Full Run as Catch-All

As you can see from the picture above, during the productivity day - Smart Subsets are being executed in the CI Pipeline for instant Developer Feedback, Boosted Output, and Resource Savings. Then periodically, execute a Full run as the Catch All Run to pick up any deferred regressions not caught in the Smart Subsets.&#x20;

Schedule your Full Run (timing configurable to your preference, such as Twice a Day, Nightly, or over the Weekend). This is customizable depending on your Test Strategy.&#x20;

Please feel free to contact Appsurify [Customer Success](https://appsurify.com/contact/) on the Best Strategy for You. <br>

## IMPORTANT: Ensure Fail-Safe Command is in Place before Turning On

If there's any disconnection or case where Appsurify is not synced, Appsurify will always by **default**  go back "Running All Tests." \
\
Ensure in the Command, there's a Fall-back Command enabled to default to running "All Tests" should there be any issue with Appsurify connection.&#x20;

For any questions here, please contact Appsurify Customer Success.&#x20;

If you have any questions about how best implement Prioritized Testing strategy that makes sense for your team, please reach out to [Appsurify Customer Success](https://appsurify.com/contact/).&#x20;


# Best Practice: Before Turning On

Important Reminders to have in place

## IMPORTANT: Where to Insert your AI Model

Appsurify is designed to bring speed and resource saving while inserting a measured amount of risk into each test run i.e., Catch 99%+ of Bugs running a Smart Subset of 10-20% of Tests.&#x20;

Best Practice is to insert your AI-Model into a Pre-Merge environment where a scheduled Full-Run or Catch-All takes place before Release.&#x20;

A **Developer Branch** or **Feature branch** is a great example of where value is most realized. Activity is high, CI pipelines are busy, and the need for quick feedback is important.&#x20;

**Best Practice Placement:**

* **Pre-Commit Checks**
* **Pre-Merge CI Jobs**

Please consult with [Appsurify Customer Success](https://appsurify.com/contact/) if you wish to implement in

* Post-Merge CI Jobs
* Pre-release / Nightly CI Jobs

Appsurify is designed to Save Time and Resources during the productivity day (or when CI pipelines are most active) and to ensure changesets are tested thoroughly before releasing.&#x20;

## IMPORTANT: Ensure to schedule Full Run as Catch-All

As you can see from the picture above, during the productivity day - Smart Subsets are being executed in the CI Pipeline for instant Developer Feedback, Boosted Output, and Resource Savings. Then periodically, execute a Full run as the Catch All Run to pick up any deferred regressions not caught in the Smart Subsets.&#x20;

Schedule your Full Run (timing configurable to your preference, such as Twice a Day, Nightly, or over the Weekend). This is customizable depending on your Test Strategy.&#x20;

Please feel free to contact Appsurify [Customer Success](https://appsurify.com/contact/) on the Best Strategy for You. <br>

## IMPORTANT: Ensure Fail-Safe Command is in Place before Turning On

If there's any disconnection or case where Appsurify is not synced, Appsurify will always by **default**  go back "Running All Tests." \
\
Ensure in the Command, there's a Fall-back Command enabled to default to running "All Tests" should there be any issue with Appsurify connection.&#x20;

For any questions here, please contact Appsurify Customer Success.&#x20;

If you have any questions about how best implement Prioritized Testing strategy that makes sense for your team, please reach out to [Appsurify Customer Success](https://appsurify.com/contact/).&#x20;

{% hint style="info" %}
Now that you known where to insert your AI-Model, when to run your Catch-All, and inserted the Fail-Safe Command, time to start [Prioritized Testing!](/getting-started/start-prioritized-testing)&#x20;
{% endhint %}

## Next: [Start Prioritized Testing](/getting-started/start-prioritized-testing)


# Build Value for CI Pipeline

Select Build Number / ID

Execution of CI Pipeline depends on the parameters that we pass while writing the command.

One of the important parameter is the build number, build ID. Most of the CI Pipelines auto populates these values through built-in environmental variables

Here, we have collected some of the most common used CI Pipelines and the corresponding link to get detail

| CI Pipeline    | Build Name               | Reference                                                                                                            |
| -------------- | ------------------------ | -------------------------------------------------------------------------------------------------------------------- |
| Azure DevOps   | `Build.BuildId`          | [Link](https://docs.microsoft.com/en-us/azure/devops/pipelines/build/variables?view=azure-devops\&tabs=yaml)         |
| Bitbucket      | `BITBUCKET_BUILD_NUMBER` | [Link](https://support.atlassian.com/bitbucket-cloud/docs/variables-and-secrets/)                                    |
| CircleCI       | `CIRCLE_BUILD_NUM`       | [Link](https://circleci.com/docs/2.0/env-vars/#built-in-environment-variables)                                       |
| GitHub Actions | `GITHUB_RUN_ID`          | [Link](https://docs.github.com/en/actions/learn-github-actions/environment-variables#default-environment-variables)  |
| GitLab CI      | `CI_JOB_ID`              | [Link](https://docs.gitlab.com/ee/ci/variables/predefined_variables.html)                                            |
| GoCD           | `GO_PIPELINE_LABEL`      | [Link](https://docs.gocd.org/current/faq/dev_use_current_revision_in_build.html#standard-gocd-environment-variables) |
| Jenkins        | `BUILD_TAG`              | [Link](https://www.jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables)                            |
| Travis CI      | `TRAVIS_BUILD_NUMBER`    | [Link](https://docs.travis-ci.com/user/environment-variables/#default-environment-variables)                         |
|                |                          |                                                                                                                      |


# Working Knowledge

User Admin, API Key, Firewall, etc.

## User Administration

* Appsurify is initially set-up with a single Admin user who is the initial contact for the integration.
* Adding additional users to your Appsurify Instance is a two‐step process:&#x20;
  * First, create the user in Admin Panel

<figure><img src="/files/H1unFsSs03boJkQ9pn6i" alt="appsurify add new users"><figcaption></figcaption></figure>

* 2nd, add the user to applicable projects.

### User Types

Users are classified as either Owner, Admin users,  or Regular users.

* **Regular Users** are limited to accessing the particular projects to which they are assigned. For those projects, they are able to view the Appsurify dashboard and review test results.
* **Admin Users** are able to view all test results across all projects and can make changes to the configuration.

### Adding Users to a Project

Add Team members to a Project once they are in the Account, and listed as either a **Admin** or **User**.&#x20;

An Admin/User must be assigned as a **member** of the project team to participate in the project. To assign users to the project.

* Under the Selected Project,&#x20;
  * Select Users in the left menu to open the User Panel for that particular Project:

<figure><img src="/files/8edtJFxmeZjaZ6LdX4PX" alt="add new users "><figcaption><p>Add Team Members to a Project once they are in the Account as either Admin or User </p></figcaption></figure>

* Users that are unassigned to this project are listed in the left column and members of the project team are listed on the right. Use the arrows in the middle to add or remove.&#x20;

## API Key

You can find your unique API Key under the top righthand corner drop-down menu:

<figure><img src="/files/GjmDDBghK9jnwhZXhzSU" alt="api key"><figcaption></figcaption></figure>

## Firewall

Firewall Rules: Appsurify's IP addresses are **52.24.102.236** and **34.214.213.229**


# Smart Test Selection Explained

Why do we choose some Tests and not others?

## How does Appsurify's Model determine Test Selection

Simple answer, based on recent developer changes and the trained model!

When Appsurify connects the Repository and begins to receive Incoming Commit data - Appsurify initially analyzes the Repository for basic structuring.&#x20;

Once the Automated Tests are connected, Appsurify leverages Patent-Pending proprietary AI-Risk Based Testing Technology to train each company's **unique AI-Model** based off of incoming commits and the corresponding test results. Over a period of 2-3 weeks, Appsurify trains a robust AI Model that links **Code to Tests** - because it will know which Commits impacted which Tests to form a union between the two.&#x20;

Once the AI Model is Trained, when a new Commit comes in, Appsurify will know which Tests are associated with that region of the Codebase - and subsequently; select and execute the relevant tests by order of Priority automatically in the CI/CD based on the Parameters set by the team

The AI Model is recalibrated on a rolling basis to ensure it's always up to date. For more information on on our Test Selection please see our [Test Selection Whitepaper](https://appsurify.com/resources/test-selection-with-appsurifys-testbrain/) on the Appsurify website.&#x20;

### **Will Appsurify catch every Failed Test?**&#x20;

**Appsurify is designed to catch as many defects as possible by running as few tests as possible.**

Appsurify is designed to be efficient in finding bugs in its Smart Subset while leaving room to find other potential defects that cause other test failures. \
\
1 Bug often causes more than 1 Test Failure, often multiple. To be efficient and fast, Appsurify is designed to catch as many bugs in as few tests as possible.&#x20;

{% hint style="info" %}
**Example:**

* 1000 Tests.
* 50 Bugs.
* 200 Tests Fail because of the 50 bugs.
* Appsurify: 10% Smart Subsets&#x20;

\
If Appsurify is enabled and running the **Top "10%"** of Tests, it will be forced to Select and Execute what the Model deems to be the most important 100 Tests most likely to Fail.&#x20;

\
Therefore, Appsurify will Prioritize and Run the Tests most likely to Catch the underlying Defects. \
\
**In this case**, Appsurify will run Smart Subset of **100 Tests**. In that example subset, it could be the case that 70 of them are Failed Tests and 30 of them are Passing Tests.&#x20;

The **IMPORTANT** thing to note is that the 70 Failed tests run cover the majority of those 50 underlying bugs and Raise them as New or Reopened Defects. \
\
As is often the case with a single defect, it will likely cause multiple Failed Tests. \
\
Therefore, Appsurify needs to execute only one or a portion of those Failed Tests in order to raise the Defect while saving room in the Smart Subset to catch other defects. \
\
To further this case, if the 50 Bugs caused 50 Tests to Fail **(1-to-1)**, if Appsurify's Smart Subset of 100 Tests caught 50 Failed Tests and 50 Passed Tests and still caught and Raised all 50 Bugs - that would be very successful.\
\
Appsurify is designed to find the underlying defect by running as few tests as possible. \
\
If the user decided to change the Smart Subset to **"5%"** in this case, Appsurify would still have room in the Smart Subset to find all 50 Bugs by only running 50 Tests. \ <br>
{% endhint %}


# Dashboard

Overview on a Per Project Basis

<figure><img src="/files/0Qqj6Y7RD8NnG19SszGV" alt="Test Analytics"><figcaption></figcaption></figure>

## Dashboard Actions

**Each Project has it's own Dashboard where Admins can:**

* Follow the Health and Integration for the Project to Optimize.
* Gain insight into the Maturity of their Model for the active Project via the "Maturity Wheel"
* Visibility into the Value Appsurify brings through the "Time Savings" and "Risk Based Test Selection" Graphs.&#x20;

{% hint style="info" %}

* **Repo Bind** - Upon success of Step 2 [Repo Connection](/getting-started/step-2-connect-repository) - <mark style="color:green;">Green</mark>
* **Tests Bind** - Upon success of Step 3 [Testsuite Connection](/getting-started/step-3-connect-tests)  - <mark style="color:green;">Green</mark>
* **Building Model** - Upon flow of Test Runs - <mark style="color:green;">Green</mark>
  * If any of these Turn <mark style="color:red;">Red</mark>, that means Appsurify has not received Data in the last Three Days and there might be a Connection Issue.&#x20;
  * Once data resumes flow, these will turn back to <mark style="color:green;">Green</mark>.&#x20;
* **Model Maturity Wheel**: Builds as your Model Matures from received Test Run Outputs. Once it hits 100%, your Model will Train over the following weekend and be ready use.&#x20;
  {% endhint %}

## Dashboard Insights

The Dashboard serves as the Central Hub for the project overall. Provides the team with meaningful insights into:

<figure><img src="/files/ySqKHiot7EUTCTsVpgBX" alt="Test Analytics Time Savings"><figcaption></figcaption></figure>

* **Visual Display of Value** generated from AI-Powered Risk Based Testing via "Time Savings" an "Risk Based Test Selection" Graphs:
  * High water mark serves as the "Before" or "Without" Appsurify.
  * Once Appsurify is enabled, Green lower line serves as the Value generated through Appsurify's Optimization for Time and Test Selection Execution.&#x20;

{% hint style="info" %}
Horizontal Bar above graphs explained:

* "Test Runs" dropdown tab to select the latest 30, 20, 10, 5, or 1 most recent Test Runs for the **TOTAL** of the selected criteria.&#x20;
  * For example, if select Last 5 Test Runs with a testsuite of 100 Tests, Tests Box will display 500 Tests.&#x20;
* Select "Test Suite" dropdown if you are optimizing more than 1 test suite.
* Once these are selected, the following Boxes will display the accumulated results for the total selected criteria.  &#x20;
  {% endhint %}

## Horizontal Boxes Defined:

* **Original Duration**: Total original Time it takes for **ALL TESTS** (100% of Testsuite) to complete.
* **Time Savings -** Total Time Saved through Prioritized Testing
  * Difference between Original Duration and New Duration.&#x20;
* **New Duration -** Total new Time of **optimized** Test Run execution.
* **Tests**: Total number of Tests in testsuite.&#x20;
* **Passed**: Total number of Tests Passed.
* **Failed**: Total number of Tests Failed.
* **Broken**: Total number of Broken Tests or Failed to run&#x20;
* **Optimized**: Total number of Tests Appsurify decided were **irrelevant** given recent Developer Changes and chose **Not To Run** for optimization purposes.&#x20;

{% hint style="info" %}
**Example**:\
**100 Tests** that take **10 Minutes** to complete with **1 Failed Test** in each Ru&#x6E;**.**

Latest **10 Test Runs** tab is Selected and Appsurify is at **90% Optimization**.

* Original Duration: 100 Min
* Time Savings: 90 Min
* New Duration: 10 Min
* Tests: 1000
* Passed: 990
* Failed: 10
* Broken: 0
* Optimized: 900
  {% endhint %}

## Test Run Summary at Bottom Defined

The latest 20 Test Runs are displayed with their individual characteristics on a per run basis:

<figure><img src="/files/8eaXP4Z5DX15ehaaot9f" alt="automation test efficiency graph"><figcaption><p>Per Test Run Summary </p></figcaption></figure>

* **Date**: Time stamp
* **Status**: Build either <mark style="color:green;">Passed</mark> or <mark style="color:red;">Failed</mark>
* **Build Name**: Name of the Build for reference.
* **Duration**: Duration of Run (factoring in Optimization or not)
* **Tests**: Total number of Tests in Testsuite (this should not change too much, only if adding tests to testsuite)
* **Passed**: Number of Tests that Passed
* **Failed**: Number of Tests Failed
* **Broken**: Number of Tests Broken or Failed to Run
* **Optimized**: Number of Tests that Appsurify's AI chose not to run due to them being **irrelevant** to the areas where Developers made changes.&#x20;
* **Efficiency**: If Optimization is engaged - at what efficiency was the Test Run executed at.&#x20;
  * For example, if Appsurify is Executing the Top 10% of Tests, Efficiency should hover around the \~90% Efficiency Mark.&#x20;
  * If Appsurify is not yet enabled, Efficiency should hover around \~0%.&#x20;

{% hint style="info" %}
**Example:**

**100 Tests** that take **10 Minutes** to complete with **1 Failed Test** in each Run with Appsurify's **Top 10%** of Tests most likely to Fail:&#x20;

**Duration: \~1 Min**

**Tests: 100**

**Passed: 9**

**Failed: 1**

**Broken: 0**

**Optimized: 90**

**Efficiency:&#x20;**<mark style="color:green;">**\~90%**</mark>
{% endhint %}

## How do we [TRUST these Results](/ui-and-value-features/your-model-insights)!


# Your Model Insights

Real-Time Insights into your Model's Performance on a Per Run Basis

Real-Time Insights into your Model's Performance on a Per Run Basis

Trust should be the biggest concern with AI/ML. In Appsurify's case, how can we TRUST the ML model to select the right tests given developer changes.&#x20;

Welcome to **Your Model Insights** page with Real-Time **Confidence Curve**

<figure><img src="/files/6qO14ROCBFW3xsL5sJGC" alt="AI Model Insights"><figcaption></figcaption></figure>

Whether you are already running Appsurify or still strengthening your Model, **Your Model Insights** allows any user to **SIMULATE** what would be chosen to run versus not chosen to run on a Per Run Basis. Works in both **Learning** or **Active Mode**. \
\
**Note: Your Model Insights will only Build / Simulate once your Model is Trained (See Dashboard for Maturity Wheel).**&#x20;

Users can select a Percentage Test Selection, such as 10, 20, 30,....90% of Tests in the Testsuite, and Appsurify will run the trained Model against the latest 20 test runs to display current performance on that chosen Percentage Subset against those latest 20 test runs.&#x20;

How the model performs on an [**Individual Run Basis**](#model-performance-per-run-basis) are lower on the page.&#x20;

{% hint style="info" %}
**Example:**

In the picture above, the user has chosen the Percentage Test Selection dropdown of "**20%"**

Appsurify will now run the Model against the most recent 20 Test Runs to display on Average it caught **95%** of Regressions Early in it's Smart Test Selection Subset.&#x20;
{% endhint %}

**Transparency** of results is everything for Quality Teams and to the Appsurify Team, and Appsurify's Model Insights Page displays unbiased view into the performance of the AI Model working for any Team.

<figure><img src="/files/LzfLdcJMjKpslK4mMevj" alt="Increase AI Model Performance"><figcaption></figcaption></figure>

{% hint style="info" %}
**Further Example:**

In the picture above, on the same project, the user has chosen the Percentage Test Selection dropdown of **"30%"**

Appsurify's model is run against the most recent 20 Test Runs to display on Average it caught **"97%"** of Regressions Early in it's Smart Test Selection Subset.&#x20;
{% endhint %}

If you find that the model is **not strong enough** for your standards, easy - simply keep or update the command to "ALL TESTS" and Appsurify's Model will continue to strengthen with each test run.

The Model will recalibrate on a rolling basis every 25 test runs.

## Model Use Cases and Terms Defined

The Model Insights page has been designed for teams to see how their Model is performing at any given time and to allow informed decisions on when and how to implement the model for best results based on Test Strategy and Risk Tolerance.&#x20;

### Use Cases

* **Low Risk Tolerance:**
  * Perhaps let the Model Train for a longer period of time and then start with a conservative test selection subset, such as 40% or 50% test subset.&#x20;
  * Still **halve** your test execution time and CI builds for faster feedback and resource savings.&#x20;
* **Medium Risk Tolerance:**
  * Start with a moderate subset around 30%
  * Optimize your test runs by 70% while catching vast majority of regressions.&#x20;
* **High Risk Tolerance:**
  * Can do an aggressive subset around 20% or steeper.&#x20;
  * Optimize your test runs by 80-90%+ for RAPID test feedback

### Terms Defined

<table><thead><tr><th width="255">Term</th><th>Definition</th></tr></thead><tbody><tr><td><strong>Tests Optimized</strong></td><td>Tests the AI chose NOT to run for purposes of efficiency and them NOT being relevant to recent Developer changes based on the incoming Commit Data. </td></tr><tr><td><strong>Tests Prioritized</strong> </td><td>Tests chosen to be run in the Smart Subset based on recent Developer activity</td></tr><tr><td><strong>Found Regressions</strong></td><td><strong>REAL</strong> Regressions / Failures / Bugs found in the Smart Subset</td></tr><tr><td><strong>Deferred Regressions</strong></td><td>Regressions / Failures/ Bugs not yet found in the Smart Subset and are subsequently picked up in the next Smart Subset or next Full Run / Catch All. <br><br><strong>Why are there sometimes more Deferred Regressions than Found Regressions?</strong><br><br>The AI-Model is designed to catch as many defects in as few tests as possible. For example, if 1 bug causes 10 Tests to Fail, the AI-Model only needs to pick up 1 of those 10 Failed Tests to raise the underlying Defect. That leaves room in the smart subset to find other underlying bugs efficiently. This is explained in more detail in <a href="/pages/3anwamyqKETf686XYNl7">Smart Test Selection Explained</a>. <br><br><strong>Additionally</strong>, Tests that are Broken, Flaky, or Not Run are lumped into "Deferred Regressions" column. <br></td></tr></tbody></table>

## Model Performance per Test Run <a href="#model-performance-per-run-basis" id="model-performance-per-run-basis"></a>

Transparency of results down to the most granular level, individual Test Runs.&#x20;

Each run is dynamically updated per the user's Test Selection Criteria to which tests would be Optimized, Prioritized, Found Regressions, and Deferred Regressions

#### At 10% Test Selection

Below, Appsurify caught the Bug by only running 10% of Tests! 🚀🚀🚀

<figure><img src="/files/oMfvTcedwmaRqAuztmCi" alt="AI Model performance"><figcaption><p>Caught Bug Early running only 10% of Tests! </p></figcaption></figure>

### Click a Run for Pop up: See Individual Tests Selected in All Categories

<figure><img src="/files/bQa3tdF8nSHPsqlbxE1u" alt="test analytics per run"><figcaption></figcaption></figure>

See both the overview of the latest 20 runs, and have the option to dive into each run as it's Dynamically Simulated to display the Performance of your Model on each Test Run.&#x20;

### Will the AI Model catch every Failed Test?&#x20;

**It isn't designed to.**&#x20;

**The AI-Model is designed to catch as many defects running as few tests as possible.**&#x20;

For example, if 1 bug causes 10 Tests to Fail, the AI-Model **only needs** to pick up 1 of those 10 Failed Tests to raise the underlying Defect. That **leaves room** in the smart subset selection to find other underlying bugs efficiently. This is explained in more detail in [Smart Test Selection Explained](/getting-started/working-knowledge/smart-test-selection-explained).&#x20;

**Additionally**, the AI Model is trained to catch real bugs caused by **Real Test Failures**, and cut through the noise of **Flaky Tests**. So if you have a high degree of Flakiness in your testsuite, it may appear that the Model isn't running Failed Tests when in fact those tests aren't real Failures and are indeed Flaky. These Flaky Tests are lumped into the "Deferred Regression" category, and in a subsequent test run - the user will see that these tests likely passed as they are indeed **Flaky**.&#x20;

The AI Model is designed to give Developers and Testers **clean signals** on their Builds and Test Runs and to raise Defects as quickly as possible and avoid Flaky tests distracting the team to failures that are not real.&#x20;

#### For Example:

Below, the AI Model **successfully Failed the Build early.**&#x20;

In this run, there were **5 newly introduced defects** that caused **97 tests to fail**. The AI Model **caught all 5 bugs** through the smart test selection only needing to run **18 Failed Tests** that correspond to the 5 newly introduced bugs.&#x20;

The 79 other failed tests were chosen not to be executed because the AI Model had already caught Failed Tests that raised the **5 underlying defects** in it's smart test selection and **Successfully Failed the Build/Run early.**&#x20;

<figure><img src="/files/jtj5MkrUC2uEzgTphUAv" alt="find regressions early"><figcaption><p>Successfully Failed the Build Early</p></figcaption></figure>

{% hint style="info" %}
By catching the bugs running fewer tests allows the AI Model to catch more bugs in the case there is a larger number of real defects that are introduced in the developer change.&#x20;
{% endhint %}

For more information on Failed Tests that were not selected to be run in the Smart Subset and Why, please see [Smart Test Selection Explained](/getting-started/working-knowledge/smart-test-selection-explained).&#x20;

## Model Curve and Performance will be different Project to Project

Every project is different, and so with that - each Your Model Insights Page may look different. Here are some examples:

<table><thead><tr><th width="200">Number of Failures</th><th width="201.33333333333331">Number of Test Runs</th><th>Model Display</th></tr></thead><tbody><tr><td>High </td><td>High (5+) Day</td><td>Your Model Curve will be round and full.</td></tr><tr><td>High</td><td>Low (less than 5 per day)</td><td>Your Model Curve will take longer to build as there are a low flow of test runs and data. </td></tr><tr><td>Low </td><td>High</td><td>Your Model Curve will be subject to swings as there aren't that many Failures to build the rounded Curve. It will look sharper and each Failure has a bigger impact on the Average Regressions Found. </td></tr><tr><td>Low </td><td>Low</td><td>Your Model will take longer to train and your Model Confidence curve will be subject to swings. (As we average across latest 20 Runs), even 1 deferred regression would be enough to alter the Confidence curve dramatically (even when Appsurify catches the underlying defect and fails the build early!) </td></tr></tbody></table>

&#x20;

### &#x20;


# Test Run Page

Individual Test Run Details

## Test Run Page

Once Test runs begin flowing, they will populate in here and all runs will remain in here historically. For the Dashboard and Your Model Insights pages, only the most recent 20 Test Runs are displayed.&#x20;

Here you'll have the opportunity to dig into each test run for more details about the run, such as:

* Test Results on each Run (<mark style="color:green;">Passed</mark>, <mark style="color:red;">Failed</mark>, Broken, Not Run)
* Edit **Test Suite** Test Execution
* **Test Analytics** Per Run
  * Groups Test Failures by **Underlying Defect**
    * **Value**: Pulls together all Failed Tests that were caused by a single underlying Defect for easy management.&#x20;

<figure><img src="/files/namgjoVRB1MIUtMSAGh9" alt="test run page"><figcaption><p>Blank Test Run Page before Tests are Connected</p></figcaption></figure>

## Test Runs and Results

<figure><img src="/files/qAqk6Wpa3PVlFde8JnzT" alt="test run analytics"><figcaption><p>Lists ALL Test Runs, Historical</p></figcaption></figure>

Provides standard information and results on individual test runs for Test Suite name, Test Run Name, Project, Start Time, and Results.&#x20;

## Edit Test Suite Execution

Dive into each test run and have the ability to determine how you want the Test Suite Executed per Appsurify. By default\ <br>

<figure><img src="/files/5i8QuSfEIFiCikh1BENz" alt="test run pass and failures"><figcaption></figcaption></figure>

<figure><img src="/files/Ql4iNTM8Y6kDZgjoemzz" alt="configure test runs"><figcaption></figcaption></figure>

### **Default Settings for Test Execution:**

* Number of **Reruns**: Set to 1
  * Can change based on preference.&#x20;
* Rerun **Flaky**:&#x20;
  * Set to "True"
    * Option to Turn off, "False"
* Auto **Raise** Defect
  * Set to "True"
  * When a test fails or group of tests fail, it raises an underlying defect for each unique failure.&#x20;
* Auto **Close** Defect
  * Set to "True"
  * When a test passes and the Defect has been fixed, the Defect will be auto Closed.&#x20;
* Report after **Failure**
  * Set to "True"<br>

## Test Analytics per Run

Dive into the granular results of each test run and see grouped Test Failures by **underlying defect**.&#x20;

<figure><img src="/files/6jMT0k4hCfm2QSWOFlvn" alt="pass fail rate"><figcaption><p>Cick over Test Results</p></figcaption></figure>

Click over Test results to go into Detail about that Run

In the below example, there were 4 Test Failures:

<figure><img src="/files/nKhg61uz1eTykrCwpUvY" alt="granular test run analytics"><figcaption><p>Test Failures  are Grouped by Underlying Defect</p></figcaption></figure>

### Group Test Failures by Underlying Defect

<figure><img src="/files/Kn9DUDU6Mi7LGtcIiAxy" alt="group failures by defect"><figcaption><p>4 Failed </p></figcaption></figure>

Consolidate Test Failures by the underlying defect that caused multiple failures for easy bug fixing.&#x20;

If One bug caused Multiple Tests to Fail, teams just want to find that ONE underlying bug as quickly as possible!

<figure><img src="/files/gVSrWLlyWB0MzuxJ7sBp" alt="group test failures by defect"><figcaption></figcaption></figure>

## Test Levels Defined

Tests are prioritized based on the likelihood of them Failing and Finding a Defect

They are prioritized into the following buckets:

* **High –** Tests which are very likely to fail, initially those associated with the files being changed
* **Medium –** Tests that may fail, initially those that are associated with either the areas being changed or dependencies.
* **Low –** Tests that are unlikely to fail.
* **Unassigned –** Tests which we have no information on, either they have not manually been linked to any area/file/folder or they have not failed.
* **Rerun –** Tests that should be rerun

When selecting which tests to run the tests can either be for a **single commit** or for a **set of commits**.

<br>


# Bug Tracking

Bug Tracking and Closing

## Connect Jira or other Bug Tracking tool for seamless Workflow.

Appsurify integrates with Jira and other popular bug tracking tools for each tracking and management of defects.&#x20;

## Defect Types:

* **Project –** The Standard Defect Type
* **Flaky –** Tests which fail due to defects of type ‘flaky’ and will not break the build unless otherwise specified.
* **Invalid Test –** Indicates that the test is or was invalid when the test failed.
* **Outside Scope –** Select this defect type when the failure is a consequence of another test failure.
  * For example, if Login breaks and your Login tests fail and create a defect and all your other tests fail and create a defect which is secondary, then this defect would be marked as ‘Outside Scope,’ essentially saying that we don’t want to prioritize this defect as it is a corresponding failure to the real defect.

## **Defect Lifecycle**

#### **Automatic Opening**

Defects will automatically open when tests fail. The type will depend on a number of factors. By default, they are opened as a project defect, but if the model indicates that these failure were flaky the default type will be set to flaky.

The model for determining flakiness looks at a large number of features, such as:

* Previous Defects
* Failure Messages
* Failure Types – fail vs. error vs. assert
* Average run time vs when the test failed
* History of that test
* Area of the change

#### Automatic Closing

Defects other than of type, ‘flaky,’ will be closed automatically when all the associated tests (tests that have failed because of this defect) pass on a commit which is a child of the commit which caused the defect.

#### **Defect Caused By Commits**

Defects that are caused by commits are the set of commits which caused the defect.

#### **Defects Closed By Commits**

Defects that are closed by commits are the set of commits which closed the defect.


# Management

Additional Information in your Appsurify Portal

## Additional UI Pages and Info

[Risk Map](/management/risk-map)

[Configure Alerts](/management/configure-alerts)


# Risk Map

Give Manual Testers a Map to the Bugs!

## Risk Map

TestBrain RiskMap is designed to assist the manual test team to prioritize which areas of the code to test.

RiskMap shows all commits for a specified period, their risk of containing at least one defect, and the functional areas of the code affected by each commit.

By showing the number of high-risk commits in each functional code area, RiskMap acts as a guide to prioritize which areas of the code to test first and how much time to spend testing each area.

The outer ring is a list of all commits, coded for risk:&#x20;

* <mark style="color:red;">Red</mark> for **high** risk,&#x20;
* <mark style="color:orange;">Orange</mark> for **medium** risk,&#x20;
* <mark style="color:green;">Green</mark> for **low** risk.&#x20;

The inner ring maps the commits to the functional areas of the code affected. Commits that affect multiple code areas are listed on the outer ring separately for each code area.&#x20;

In other words, if a commit affects 3 different code areas, the same commit will be shown in 3 separate places on the outer ring.

Code areas are colored to match the highest risk of any commit that touches that area. Code areas that are not shown in the inner ring have not been changed.

Give manual testers a Flash light in the dark to select a window of time and where to focus their Exploratory Testing!

<figure><img src="/files/6w6l1wmmpK8vuSm8bex4" alt="Riskmap to the bugs" width="563"><figcaption><p>Heat Map to the Bugs!</p></figcaption></figure>

By showing the number of high-risk commits in each functional code area, RiskMap acts as a guide to prioritize which areas of the code to test first and how much time to spend testing each area.


# Configure Alerts

Configure Email Alerts

## Configure Alerts to Failures based on your Preference

<figure><img src="/files/i6pcQXz742qqjBWcGqXZ" alt="configure alerts"><figcaption></figcaption></figure>

### Choose the desired alert type and frequency:

1. **Set the Alert Frequency:**
   1. **Immediate:** Alerts are sent out as soon as the specified risks occur.
   2. **Daily:** Alerts are combined into a single daily alert sent at the specified time.
   3. **Weekly:** Alerts are combined into a single weekly alert sent on the specified day of the week and time.
   4. **Monthly:** Alerts are combined into a single monthly alert sent on the specified date and time.
2. **Set Delivery Time:**
   1. Move the delivery hour and day next to period instead of below it.
3. **Set the Alert Type:**
   1. **High Risk Commit:** Any commit which TestBrain has identified as having a high risk of containing a defect.
   2. **Test Failure:** A test run with a failure that indicates a new defect. Test failures due to flaky tests and open bugs are automatically excluded.
   3. **Test Runs:** Completion of an automated test run, including details of pass or fail status.
   4. **Flagged Files:** A commit which modifies flagged files or functional code areas. Flagged file alerts can provide notification of changes to business-critical areas of the application or areas of the code known to be defect prone.
   5. **Test Prioritization Savings:** A report on the accuracy of Appsurify's automated test prioritization, showing the number of defects that would have been caught running Appsurify's high, medium, and low priority tests and the reduction in the number of tests required by executing only the high or medium priority tests.
   6. **Risk Analysis Results:** A report detailing the accuracy of Appsurify's risk analysis.  This report looks at the defects fixed in the time period specified and then determines the risk of the commits containing the defect and reports the results.  Thus, this report displays the accuracy of the commit risk analysis for the defects found in the time period.
   7. **Specified Risk Criteria:**  Choose your own risk criteria for each commit to generate an alert. Risk factors you can select include:
      1. More than the specified number of functional areas changed in the commit.
      2. More than the specified number of files changed in the commit.
      3. More than the specified number of folders changed in the commit.
      4. Commit made by a specified author.
      5. Commit made by an author who has not changed this area of the code before.
      6. Commit made at a specified time or date.
      7. Commit changes code older than a specified age.
4. **Add Alert Recipients**
   1. Enter the email for a single recipient for the alert or a list of recipients separated by semicolons.
5. **Click Save when done.**&#x20;


# Integrations

Ready to use Integrations!

## Code Language and Test Type Agnostic

Appsurify is **Code Language Agnostic**, supporting **ALL** underlying code languages i.e., Java, .Net, Python, C++, Go, JavaScript, Ruby, etc.&#x20;

Appsurify is **Test Type Agnostic**, supporting **ALL** Test Types i.e., UI, E2E, Integration, Regression, API, Unit, etc.&#x20;

## Code Repositories

Any Git-based Repositories, such as GitHub, Bitbucket, etc. &#x20;

<table data-view="cards"><thead><tr><th></th></tr></thead><tbody><tr><td><strong>GitHub</strong></td></tr><tr><td><strong>Bitbucket</strong></td></tr><tr><td><strong>Microsoft TFVC</strong></td></tr><tr><td><strong>Perforce</strong></td></tr><tr><td><strong>SVN</strong></td></tr></tbody></table>

## CI Pipelines

<table data-view="cards"><thead><tr><th></th><th data-type="files"></th></tr></thead><tbody><tr><td><strong>Jenkins</strong></td><td></td></tr><tr><td><strong>Buildkite</strong></td><td></td></tr><tr><td><strong>CircleCI</strong></td><td></td></tr><tr><td><strong>Bitrise</strong></td><td></td></tr><tr><td><strong>Azure DevOps</strong></td><td></td></tr><tr><td><strong>Codeship</strong></td><td></td></tr><tr><td><strong>TeamCity</strong></td><td></td></tr><tr><td><strong>Travis CI</strong></td><td></td></tr><tr><td><strong>GitLab</strong></td><td></td></tr><tr><td><strong>Bamboo</strong></td><td></td></tr><tr><td><strong>GitHub Actions</strong></td><td></td></tr><tr><td><strong>Codefresh</strong></td><td></td></tr></tbody></table>

## Test Frameworks

<table data-view="cards"><thead><tr><th></th></tr></thead><tbody><tr><td><strong>Cypress.io</strong></td></tr><tr><td><strong>Playwright</strong></td></tr><tr><td><strong>Selenium</strong></td></tr><tr><td><strong>Appium</strong></td></tr><tr><td><strong>Cucumber</strong></td></tr><tr><td><strong>Behave</strong></td></tr><tr><td><strong>Maven</strong></td></tr><tr><td><strong>Ant</strong></td></tr><tr><td><strong>Junit</strong></td></tr><tr><td><strong>TestNG</strong></td></tr><tr><td><strong>Nunit</strong></td></tr><tr><td><strong>Xunt</strong></td></tr><tr><td><strong>Mstest</strong></td></tr><tr><td><strong>Vstest</strong></td></tr><tr><td><strong>SmartBear TestComplete</strong></td></tr><tr><td><strong>Sahi</strong></td></tr><tr><td><strong>Mocha</strong></td></tr><tr><td><strong>Katalon Studio</strong></td></tr><tr><td><strong>KIF</strong></td></tr><tr><td><strong>Ruby</strong></td></tr><tr><td><strong>C#</strong></td></tr><tr><td><strong>Java</strong></td></tr><tr><td><strong>Robot Framework</strong></td></tr><tr><td><strong>Pytest</strong></td></tr><tr><td><strong>Ranorex</strong></td></tr><tr><td><strong>Webest</strong></td></tr><tr><td><strong>Jasmine</strong></td></tr><tr><td><strong>Opentest</strong></td></tr><tr><td><strong>ios</strong></td></tr><tr><td><strong>Android</strong></td></tr><tr><td><strong>Espresso</strong></td></tr><tr><td><strong>Xcodetest/XCUITest</strong></td></tr><tr><td><strong>Earlgray</strong></td></tr><tr><td><strong>Applitools</strong></td></tr><tr><td><strong>Testim</strong></td></tr></tbody></table>

## Cloud Testing Platforms

<table data-view="cards"><thead><tr><th></th></tr></thead><tbody><tr><td><strong>BrowserStack</strong></td></tr><tr><td><strong>SauceLabs</strong></td></tr><tr><td><strong>BitBar</strong></td></tr><tr><td><strong>LambdaTest</strong></td></tr><tr><td><strong>AWS Device Farm</strong></td></tr><tr><td><strong>Applitools</strong></td></tr><tr><td><strong>Kobiton</strong></td></tr></tbody></table>

## Don't see something?&#x20;

We build additional integrations all the time!&#x20;

Contact [Appsurify Customer Support](https://appsurify.com/contact/) for inquiry.&#x20;


# Security & Compliance

Security & Compliance

Appsurify’s commitment is to provide the latest security procedures to every enterprise subscriber.

Here, we will detail our approach to security so that our subscribers and users can better understand how their data is protected.

## **TERMS OF SERVICE**

Appsurify, Inc. Terms and Service found [Here](https://appsurify.com/saas-terms-of-service/).

## **PRIVACY POLICY**

Appsurify, Inc. (“Appsurify”, “we”, “us”, or the like) provides this Privacy Policy to inform users of our policies and procedures regarding the collection, use and disclosure of personally identifying information (or “PII”) received from users of our website and our software-as-a-service platform (the “Service” or “Website”). Full Privacy Policy found [Here](https://appsurify.com/privacy-policy/).

## Appsurify Trust Cloud

We actively monitor over 83 controls in our securely hosted Azure Infrastructure to ensure all best practices are up to date.&#x20;

Request Access to our [Trust Cloud Here](https://appsurify-trust-cloud.trustshare.com/home) for relevant security and compliance documentation.&#x20;


# SaaS or On-Prem

Learn whether Appsurify should be working as a SaaS or an On-Prem solution for your company

## SaaS and On-Premise Available

Appsurify offers two installations options:

### **SaaS - Recommended Option**

* Securely Hosted in Microsoft Azure and follows all Security & Compliance Best Practices.&#x20;
* No Direct Connection to Git-Required.&#x20;
  * Push-only **read** data of Commit Metadata. (No write access required).&#x20;
  * No access to files or folders, only code snippets.
  * Data is encrypted in transit & at rest.&#x20;
* Please visit our [Trust Cloud](https://appsurify-trust-cloud.trustshare.com/home) for documentation, etc.&#x20;

### **On-Premise**

* Fully secure, no outside connection. Completely behind client Firewall.
* No data shared externally.&#x20;
* Installed via Docker Image on internal VM.
* Available via Microsoft Commercial Marketplace.
  * Microsoft Offering [Here](https://azuremarketplace.microsoft.com/en-us/marketplace/apps/appsurifyinc1606933045773.appsurify3001).&#x20;
  * AWS Offering: Coming Soon!&#x20;

For On-Premise deployments help, please reach out to [Appsurify Customer Success](https://appsurify.com/qa-automation-tool-pricing/). <br>

### &#x20;<a href="#id-0-toc-title" id="id-0-toc-title"></a>

### &#x20;<a href="#id-0-toc-title" id="id-0-toc-title"></a>