# Core Concepts

# Project

Projects are the highest level at which you can organize your work. Each project has its own dedicated dashboard and access control.

We recommend organizing your testing activity using Projects, e.g., one project per domain tested, or per independent application under test.

# Goal

A goal is a testing scope within a project (i.e., a testing goal/objective). This can be part of an application to test, or the entire application.

A goal consists of a descriptive name, a starting URL and a set of optional testing configurations (e.g., screen resolution).

# Goal versions

Each goal's data is independently version-controlled. Each version contains information such as tests, application graph, and insights, for each individual goal.

# Goal version control lifecycles

Versions provide functionality similar to version control systems such as Git. Like git, once a version has been committed, it cannot be changed (i.e., it is saved permanently in the history).

You can roll back a goal to an older version at any time, or fork the goal from a specific version (e.g., to continue working from that version). Forking a version makes a full copy of the existing version but allows modifications in isolation, preserving the original version.

# Tests

Tests on Virtuoso take the form of journeys, representing an end-to-end journey that can be taken by a user on the application.

They are presented in natural language (e.g., plain English) and can be created manually, recorded, or automatically generated.

For each goal and at each version in its history, the tests are structured as follows:

  • Steps (or Test Steps): a single action a user can take to interact with the application (e.g., navigating to a page, clicking on a link/button, filling an input) or to make a validation (e.g., checking if a certain element exists, or a certain condition holds).
  • Checkpoint: a sequence of instructions for navigation from one state to another in the application.
  • Journey: a collection of checkpoints that can be executed on the application under test leading to some application state.

Read more about Virtuoso tests →

# Application graph

Journeys in Virtuoso are represented as an application graph, visualized in the form of a tree.

The nodes in the graph represent the states of the application at the end of each checkpoint, and the edges represent the action(s) taken to reach the state (the steps inside a checkpoint).

# Execution

Execution in Virtuoso represents a similar function as with any other test framework you are familiar with: executing an existing set of regression tests against the target application.

During this process, one or more journeys from a particular version of goal are executed.

Tests are executed in parallel

Virtuoso executes all journeys in parallel. This means that there should be no state dependency between the tests.

You can however configure the maximum level of parallelism (e.g., setting it to 1 would cause them to execute one at a time).

# Exploration

With Virtuoso, you can perform exploratory testing at scale.

Exploration is the process of discovering all possible application states, through autonomous interactions with the application.

This enables you to perform regression testing without the manual effort of test authoring, and to validate rules against your application at scale. You can for example:

  • Quickly and automatically discover application states, which you can later use for visual comparison after you have made a change;
  • Generate regression tests with embedded rules to be executed on your entire application.

# How does it work?

Virtuoso explores an application under test starting from a Starting URL, using the configurations set on the goal.

For each page, Virtuoso's bots automatically explore and interact with the page like a normal user would (e.g., clicking on links, filling forms, etc.). Optionally, using directives you can take control of the interactions and validations performed by Virtuoso.

# State discovery and unique graph

To avoid building a massive graph of duplicated states, Virtuoso builds a unique graph of the application states.

After every interaction, using its intelligent core backed by machine learning Virtuoso checks whether a new state has been discovered by asking itself the question "Have I seen this page before?".

Given the complex nature of web applications, Virtuoso makes a best effort evaluation of whether a page has been previously seen or not. States that are determined to be the same are grouped together for you to verify.

You can of course address any gaps in the exploration by manually adding additional journeys to cover these states.

# Determinism / predictability of tests and exploration

Virtuoso explores applications similar to a user, and so the exploration is not expected to be deterministic. Across repeated explorations, Virtuoso may use different inputs, or browse pages in different orders.

Nevertheless, once journeys are generated, execution of tests is expected to be deterministic (subject to predictable behaviour in the underlying application under test).

Shortest-path graph

The application graph presented in the UI contains a tree with only the shortest paths to reach a given state from the starting URL, which also represents the journeys that are generated. This does not include all edges that may exist between pages.

Last Updated: 12/17/2020, 8:54:08 AM