# BELLATRIX

URL: https://bellatrix.solutions/
Updated: 2026-10-13

BELLATRIX is an open-source (Apache-2.0) cross-platform test automation framework for Web, Mobile (Android and iOS), Desktop and API testing. It is available for C# (.NET 8), Java and JavaScript/TypeScript, and is built and maintained by Automate The Planet Ltd (Sofia, Bulgaria).

---

# Web Test Automation Features

URL: https://bellatrix.solutions/features/web/
Updated: 2020-08-04

BELLATRIX open-source test framework will give you control on the whole execution workflow - change browsers or reuse them and retry failing tests.

- [AI Integration](https://bellatrix.solutions/features/web/ai-integration/): AI for web test automation in BELLATRIX: find elements by prompt, assert in natural language, self-heal broken locators and get smart failure analysis.
- [Image Recognition](https://bellatrix.solutions/features/web/image-recognition/): BELLATRIX Image Recognition library can be used to verify hard-to-assert functionalities such as PDFs, charts, and similar. For Web test automation.
- [Web Controls](https://bellatrix.solutions/features/web/web-controls/): Test web controls with BELLATRIX: 30+ ready-to-use controls with actions and properties, plus an API that makes HTML grid and table testing easy.
- [Accelerate Test Creation](https://bellatrix.solutions/features/web/accelerate-test-creation/): BELLATRIX open-source test framework includes element snippets, handy elements locators, smart wait for the elements, more than 200 elements actions.
- [Accelerate Test Execution](https://bellatrix.solutions/features/web/accelerate-test-execution-web/): Open-source test framework that can speed up your web test execution by retrying failed requests enhanced finding and waiting of elements and much more.
- [Extend The Framework to Fit Your Needs](https://bellatrix.solutions/features/web/extend-the-framework-to-fit-your-needs/): BELLATRIX open-source test framework will provide you with a wider test execution life cycle with the ability to plug-in everywhere. For Web test automation.
- [Troubleshooting Easiness](https://bellatrix.solutions/features/web/troubleshooting-easiness/): BELLATRIX open-source test framework helps you with full-page screenshots, video recording, log reports, and failure analysis. For Web test automation.
- [Test Responsive Layouts](https://bellatrix.solutions/features/web/test-responsive-layouts/): Test responsive layouts with BELLATRIX open-source test framework, based on the test location of objects relative to each other on the page.
- [Boost Test Reliability](https://bellatrix.solutions/features/web/boost-test-reliability/): Make web tests reliable with BELLATRIX: smart waits handle timeouts and guarantee elements are found before every action, removing flaky failures.
- [Human Readable Tests](https://bellatrix.solutions/features/web/human-readable-tests/): Write human-readable web tests with BELLATRIX: built-in page objects and 30+ web controls with ready-to-use actions, properties and assertions.
- [Easy Knowledge Transfer](https://bellatrix.solutions/features/web/easy-knowledge-transfer/): Everything that your team needs to know about BELLATRIX open-source test automation framework, from installation to the most complex features.
- [Unified Team Conventions](https://bellatrix.solutions/features/web/unified-team-conventions/): Unify web test code with BELLATRIX: two static analysis modules enforce coding standards and naming, plus 3 item templates for standard page objects.

---

# AI Integration (Web)

URL: https://bellatrix.solutions/features/web/ai-integration/
Updated: 2025-08-07

## Overview

## Overview 

BELLATRIX introduces four advanced AI-powered features for web automation using LLMs:

-   **Element Finding by Prompt**: Locate elements using natural language instructions.
-   **AssertByPrompt / ValidateByPrompt**: Perform assertions and validations using descriptive instructions.
-   **Native Self-Healing via LLM**: Automatic healing of broken tests when the UI changes.
-   **Smart AI Analysis**: Automated root cause analysis, evidence comparison, and failure diagnostics with BDD logging and page snapshots.

These capabilities drastically reduce test maintenance, increase test reliability, and enable true prompt-driven automation for any web application.

[Learn more about Overview](https://docs.bellatrix.solutions/web-automation/ai-features/)

---

# Image Recognition (Web)

URL: https://bellatrix.solutions/features/web/image-recognition/
Updated: 2021-11-29

## Overview

## Overview 

BELLATRIX Image Recognition library can be used to verify hard-to-assert functionalities such as PDFs, charts, and similar. But our computer vision library is much more than that. You can even interact with everything on your screen. Perform clicks, set text, drag and drop, double click, and more. Our library uses a machine learning engine for comparing images of your screen. Basically, you add screenshots to your project and embed them to it. Afterward, you need to mention the name of the picture.

To use the library you need to install the Bellatrix.ImageRecognition.SikuliX NuGet package

[Learn more about Overview](https://docs.bellatrix.solutions/web-automation/image-recognition/)

---

# Web Controls (Web)

URL: https://bellatrix.solutions/features/web/web-controls/
Updated: 2021-11-29

## Simple Controls

## Simple Controls

#### Over 30 well-known web controls with actions and properties that are most relevant to them.

Since WebDriver is not a test framework, it is written in most generic manner. All web elements share a common IWebElement interface- containing the same methods and properties. For example- you use SendKeys method to type text in the text field, to click a button using Enter key or upload a file. Or why do you need Click method for DIV or text field?

**WebDriver example**

```
IWebElement agreeCheckBox = driver.FindElement(By.Id("agreeChB"));
agreeCheckBox.Click();
IWebElement firstNameTextField = driver.FindElement(By.Id("firstName"));
firstNameTextField.SendKeys("John");
IWebElement avatarUpload = driver.FindElement(By.Id("uploadAvatar"));
avatarUpload.SendKeys("pathTo\myAvatar.jpg");
IWebElement saveBtn = driver.FindElement(By.Id("saveBtn"));
agreeCheckBox.SendKeys(Keys.Enter); 
```

One more thing, if you don’t use suffixes in the names of your variables or properties, you won’t know what type of elements they are. In the case that you want to perform specific verifications, this might be important. For example, anchor web elements cannot be disabled, although buttons can. BELLATRIX offers over 30 strongly-typed web controls such as: anchor, button, text field, checkbox, etc. Each specific control contains well-named actions and properties that are most relevant to it.

**BELLATRIX Example**

```
CheckBox agreeCheckBox = App.ElementCreateService.CreateById<CheckBox>("agreeChB");
agreeCheckBox.Check();
TextField firstNameTextField = App.ElementCreateService.CreateById<TextField>("firstName");
firstNameTextField.SetText("John");
InputFile avatarUpload = App.ElementCreateService.CreateById<InputFile>("uploadAvatar");
avatarUpload.Upload("pathTo\myAvatar.jpg");
Button saveBtn = App.ElementCreateService.CreateById<Button>("saveBtn");
saveBtn.ClickByEnter();
```

While reading the code, you can quickly find out the type of the elements since it is the first thing you see. Moreover, the specific action methods and properties make the code more self-explanatory.

[Learn more about Simple Controls](https://docs.bellatrix.solutions/web-automation/simple-components/)

## Complex Controls (Grid, Table)

## Complex Controls (Grid, Table) 

#### Learn how to use BELLATRIX grid and table controls

The difference between a table and grid is that usually, the grids are more complex than a regular HTML table. In them, you can have dynamic data. Moreover, inside the column, you can have other HTML elements such as buttons, text fields, selects, other tables. Or you can filter, sort the columns, and have paging for the grid. Instead of getting specific cells or rows by custom locators- we have created the Table and Grid controls, which ease the selection of cells/rows and assertion of the data. Moreover, in many cases there isn’t a unique item which you can use to select the row/cell.

### Table

```
private static Table Table => App.ElementCreateService.CreateById<Table>("table1")
    .SetColumn("Last Name")
    .SetColumn("First Name")
    .SetColumn("Email")
    .SetColumn("Due")
    ////.SetColumn("Web Site")
    .SetColumn("Action");
```

BELLATRIX gives you API for easing the work with HTML tables. Through the SetColumn you map the headers of the table if for some reason you don’t want some column, just don’t add it. The method returns a list of all rows’ data as C# data mapped to the map you provided. Since we haven’t the SetColumn for the WebSite- this property won’t be asserted if you use the AssertTable method.

[Learn more about Complex Controls (Grid, Table)](https://docs.bellatrix.solutions/web-automation/complex-components/)

### Grids

```
public Grid TestGrid => App.ElementCreateService.CreateById<Grid>("sampleGrid")
    .SetColumn("Order", typeof(TextField), Find.By.Tag("input"))
    .SetColumn("Firstname")
    .SetColumn("Lastname")
    .SetColumn("Email Personal")
    .SetColumn("Email Business")
    .SetColumn("Actions", typeof(Button), Find.By.Xpath("./input[@type='button']"));
```

BELLATRIX gives you API for easing the work with HTML grids. Through the SetColumn you map the headers of the table if for some reason you don’t want some column, just don’t add it. The method returns a list of all rows’ data as C# data mapped to the map you provided. Since we haven’t the SetColumn for the WebSite- this property won’t be asserted if you use the AssertTable method. You can get the cell converted to the element specified by the grid SetColumn method. Also, since some of this simple controls sometimes are wrapped inside DIV or SPAN elements, you can specify additional locator for finding the element.

[Learn more about Complex Controls (Grid, Table)](https://docs.bellatrix.solutions/web-automation/complex-components/)

---

# Accelerate Test Creation (Web)

URL: https://bellatrix.solutions/features/web/accelerate-test-creation/
Updated: 2021-11-29

## Speed Test Writing with Element Snippets

## Speed Test Writing with Element Snippets

#### By giving you a corresponding snippet for more than 30 web elements out of the box, BELLATRIX will dramatically speed up your test writing.

Code snippets are small blocks of reusable code that can be inserted in a code file using a context menu command or a combination of hotkeys. In Visual Studio there are expansion snippets, which are added at a specified insertion point and may replace a snippet shortcut. For example, to generate a TextField property, you need to type somewhere in you class wtextfield and press Tab.

```
public TextField CouponCode => Element.CreateById<TextField>("coupon_code");
```

On the first press of tab, the above code is generated. The first placeholder that is selected is the name of the property. Once you change it, you can press Tab. Then, the second placeholder is chosen- the By locator’s type, by default, it is set to Id, press Tab again and change the actual locator.

## 15+ Handy Elements Locator

## 15+ Handy Elements Locator

#### 7 element locators on top of the vanilla WebDriver and an easy way to add new locators will make element location much easier.

For example, in vanilla WebDriver, you have 8 default By locators (Id, TagName, XPath) and you cannot add your own. However, in many cases, especially if your website uses a CMS system, the IDs of the elements are generated automatically. Meaning they can get quite hard to use- sf\_colsOut-sf\_1col\_1\_100-promotions. You might use locator- ID ending with.

BELLATRIX comes with the default WebDriver locators and brings 7 more. Such as:

-   ID ending with
-   ID containing
-   value ending with
-   Class containing
-   inner text containing
-   Name ending with
-   Attributes containing

[Learn more about 15+ Handy Elements Locator](https://docs.bellatrix.solutions/web-automation/locate-elements/)

## API Usability- Locate Elements

## API Usability- Locate Elements

#### Additional methods and ability to add custom locators.

For example, in WebDriver to find an element, we use the FindElement method while specifying the locator through By class.

**WebDriver Example**

```
IWebElement agreeCheckBox = driver.FindElement(By.Id("agreeChB"));
agreeCheckBox.Click();
```

However, this syntax requires additional effort. It is not fluent since you had to begin a new “chain” using the By static class. Also, it is not extendable if you want to add custom locators.

**BELLATRIX Example**

```
CheckBox agreeCheckBox =
App.ElementCreateService.CreateById<CheckBox>("agreeChB");
agreeCheckBox.Check();
```

BELLATRIX provides you with a CreateBy method for each locator. Everything follows the natural writing flow, leveraging to the maximal degree on IntelliSense. If you add your custom locator, your method will appear as well.  
One of the coolest things that the BELLATRIX element includes, is the By property (knowing how it was located).

[Learn more about API Usability- Locate Elements](https://docs.bellatrix.solutions/web-automation/locate-and-wait-elements/)

## API Usability- Wait for Elements

## API Usability- Wait for Elements

#### Smart wait for elements that will solve 80% of all use cases.

All elements are internally waited to exist before usage. This solves 80% of all use cases. After that as part of the CreateBy API, we added additional ToBe methods which you can chain. Which means you can specify an unlimited number of conditions for each element that needs to be fulfilled before the element is returned.

**Example**

```
var promotionsLink = App.ElementCreateService.CreateByLinkText<Button>("Promotions").ToBeVisible().ToBeClickable().ToExists();
promotionsLink.Click();
```

BELLATRIX comes with 8 default ToBe methods.

-   ToExists
-   ToNotExists
-   ToBeVisible
-   ToNotBeVisible
-   ToBeClickable
-   ToHasContent
-   ToHasStyle
-   ToBeDisabled

Moreover, it is relatively easy to add your custom ToBe methods if needed.

[Learn more about API Usability- Wait for Elements](https://docs.bellatrix.solutions/web-automation/locate-and-wait-elements/)

## 200+ Additional Elements Actions

## 200+ Additional Elements Actions

#### BELLATRIX saves you a lot of effort and code with extended elements and services APIs.

For example, there are 15+ HTML5 web controls that cannot be automated out of the box with vanilla WebDriver.

```
Phone billingPhone = App.ElementCreateService.CreateById<Phone>("billing_phone");
billingPhone.SetPhone("+00359894646464");
Color carColor = App.ElementCreateService.CreateById<Color>("car_color");
carColor.SetColor("#f00030");
Time timeElement = App.ElementCreateService.CreateById<Time>("time");
timeElement.SetTime(12, 12);
```

Also, instead of using other 3rd party libraries we ease the usage of default web controls as well.

```
Select billingCountry = App.ElementCreateService.CreateById<Select>("billing_country");
billingCountry.SelectByText("Bulgaria");
```

Or we bring new useful methods to default controls such as Focus and Hover.

```
var confirmBtn = App.ElementCreateService.CreateById<Button>("confirm");
confirmBtn.Hover();
confirmBtn.Focus();
```

Most the important attributes of each web control are included, as well as their assertion alternatives.

```
var confirmBtn = App.ElementCreateService.CreateById<Button>("confirm");
confirmBtn.EnsureAccessKeyIs(5);
var productQuantity = App.ElementCreateService.CreateById<Number>("qt_number");
productQuantity.EnsureMaxIs(5);
```

[Learn more about 200+ Additional Elements Actions](https://docs.bellatrix.solutions/web-automation/simple-components/)

## HTTP Traffic Capturing and Validations

## HTTP Traffic Capturing and Validations

#### Control each request and response made by the browser and have the option to modify it or make assertions against it.

You just need to set the shouldCaptureHttpTraffic to true in the Browser attribute.  
**Examples**

```
[Browser(BrowserType.Chrome, BrowserBehavior.RestartEveryTime, shouldCaptureHttpTraffic: true)]
```

You can access the proxy through the BELLATRIX App service. The proxy service includes several useful assert methods.

Assert that no error codes are present in the requests.

```
App.ProxyService.AssertNoErrorCodes();
```

Assert that a specific request was made.

```
App.ProxyService.AssertRequestMade("http://demos.bellatrix.solutions/favicon.ico");
```

Beyond validations, you can even modify the HTTP traffic.

You can set various URLs to be redirected. This is useful if you do not have access to production code and want to use a mock service instead.

```
App.ProxyService.SetUrlToBeRedirectedTo( "http://demos.bellatrix.solutions/favicon.ico", "http://demos.bellatrix.solutions/logo.svg");
```

To make web pages load faster, you can block some not required services- for example, analytics scripts, and you do not need them in test environments.

```
App.ProxyService.SetUrlToBeBlocked("http://demos.bellatrix.solutions/favicon.ico");
```

[Learn more about HTTP Traffic Capturing and Validations](https://docs.bellatrix.solutions/web-automation/capture-http-traffic/)

## Angular Locators and Support Methods

## Angular Locators and Support Methods

#### BELLATRIX fully supports testing of Angular apps. It comes with 4 Angular specific locators and many convenient methods for managing asynchronous behavior.

For example, BELLATRIX can find elements through Angular locators, for example, by the Angular ng-model attribute.

```

var textField = App.ElementCreateService.CreateByNgModel("yourName");

```

#### BELLATRIX comes with 4 Angular specific locators:

-   NgBinding
-   NgModel
-   NgRepeater
-   NgSelectedOption

If the automatic wait for Angular is turned off, you can tell the framework explicitly to wait.

```

App.BrowserService.WaitForAngular();

```

[Learn more about Angular Locators and Support Methods](https://docs.bellatrix.solutions/web-automation/angular/)

---

# Accelerate Test Execution (Web)

URL: https://bellatrix.solutions/features/web/accelerate-test-execution-web/
Updated: 2021-11-29

## Optimized Element Finding and Waiting

## Optimized Element Finding and Waiting

#### Better finding and waiting of elements out of the box and flexible setup.

One of the most significant problems in test automation is handling timeouts and performing actions on elements which may not be on the page right now.

If you use global timeouts such as WebDriver implicit wait.

```
IWebDriver driver = new ChromeDriver(); 
driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(30);
```

In some cases, you may need a larger wait interval. What do you do if this happens? One option is to increase the global timeout, but this will affect all existing tests, slowing down the whole test run significantly.

Another option is to use the global timeout and occasionally add hard-coded pauses in your tests where needed.

```
Thread.Sleep(2000);
```

However, this is the worst thing you can do. One time you may need to wait 1 second, and another time 5 seconds. If you always use the biggest possible pause, your tests will get slower and slower.

BELLATRIX hides the whole complexity of searching and waiting for elements. All elements are returned immediately when they are present on the page in the right state.

## Optimized Browser Life Cycle Control

## Optimized Browser Life Cycle Control

#### Reuse the browser and configure it when to restart.

Two of the operations that take the most time in web tests are related to starting and closing the web browsers. Each of these operations can take from a fraction of a second to several seconds. If you open and close the browser for each test and you have thousands of tests, this can make your test runs more than twice as long!

To battle this problem, BELLATRIX offers an automatic way of handling the browser life cycle across multiple tests. You need to set this lifecycle in the Browser attribute applied to each test class.

```
[Browser(BrowserType.Firefox, Lifecycle.ReuseIfStarted)]
public class BellatrixBrowserBehaviourTests : WebTest
```

#### The browser lifecycle is configured through the browser lifecycle property. Available options:

-   ### RestartEveryTime
    
    For each test a separate WebDriver instance is created and the previous browser is closed.
    
-   ### RestartOnFail
    
    The browser is only restarted if the previous test failed.
    
-   ### ReuseIfStarted
    
    The browser is only restarted if the previous test’s browser was different. In all other cases, the browser is reused if possible.
    

If you use one of the “restart on fail” or “reuse if started” options, it can significantly decrease the test execution time, eliminating the additional time for browser initialization and disposal.  
[Learn more about Optimized Browser Life Cycle Control](https://docs.bellatrix.solutions/web-automation/control-browser/)

## Run Tests in Headless Mode

## Run Tests in Headless Mode

#### Your tests execute even faster if you use the so-called headless mode.

BELLATRIX supports all 5 major browsers- Chrome, Firefox, Edge, Opera and Internet Explorer. In this mode, tests run in the browser but the browser’s UI is not rendered. In theory, it should be faster.  
BELLATRIX can run tests in headless mode using Chrome and Firefox engines.

You just need to set the ChromeHeadless or FirefoxHeadless for browser type in the Browser attribute.

```
[Browser(BrowserType.FirefoxHeadless, BrowserLifecycle.ReuseIfStarted)]
```

All tests in the class will be executed in Firefox browser in headless mode.  
[Learn more about Run Tests in Headless Mode](https://docs.bellatrix.solutions/web-automation/control-browser/)

## Execute Tests in Docker Containers using Selenoid

## Execute Tests in Docker Containers using Selenoid 

![Execute Tests in Docker Containers using Selenoid](https://bellatrix.solutions/images/uploads/selenoid-ui-videos-1-1400x797.png)

Selenoid is a robust implementation of the Selenium hub using Docker containers to launch browsers. No need to manually install browsers or dive into WebDriver documentation. Any browser session can be saved to the H.264 video. An API to list, download, and delete saved log files. Suitable for personal usage and in big clusters.

[Learn more about Execute Tests in Docker Containers using Selenoid](https://docs.bellatrix.solutions/web-automation/execute-tests-selenoid/)

---

# Extend The Framework to Fit Your Needs (Web)

URL: https://bellatrix.solutions/features/web/extend-the-framework-to-fit-your-needs/
Updated: 2021-11-29

## Extended Test Execution Life Cycle and Plugins

## Extended Test Execution Life Cycle and Plugins

#### Have a full control over your test execution.

All test frameworks give you the possibility to execute logic at certain points before or after tests. Typically tests are placed inside test classes. The standard test workflow for MSTest and NUnit is:

1\. **Execute Assembly Initialize** – once for the whole project  
2\. **Execute Class Initialize** – once for the test class  
3\. **Execute Test Initialize** – executed before each test  
4\. **Execute Test**  
5\. **Execute Test Cleanup** – executed after each test  
6\. **Execute Class Cleanup** – once for the test class  
7\. **Execute Assembly Cleanup** – once for the whole project

### Why do you need to extend the standard workflow?

Usually, you want to use these primary methods to execute business test-related logic. Sample use cases:

-   Take screenshots of test failure
-   Take videos on test failure
-   Fail tests if not executed under a certain time
-   Log test results in a 3rd party system
-   Control the browser life cycle

In order to meet these requirements and allow you to write custom plugins, BELLATRIX comes with an extended test execution life cycle. When you write a plugin, you can execute logic in various phases of the new life cycle- before TestInitialize, after TestInitialize, before TestCleanup, after TestCleanup and more. For each test, all registered plugins logic is executed. This is how some of the BELLATRIX features work such as video and screenshot on test failure, browser life cycle, and more.

### You can easily write your custom plugins. See how it is done.

In BELLATRIX, we have a feature called “execution time under”. Here you specify for the test class the maximal allowed test execution time if some of the tests take longer to run- it fails automatically. This is done through a test workflow plugin.

This is how we specify the maximal allowed time.

```
 [ExecutionTimeUnder(2)]
 public class MeasuredResponseTimesTests : WebTest
```

This is part of the plugin.

```
public class ExecutionTimeUnderTestWorkflowPlugin : TestWorkflowPlugin
{
    protected override void PostTestInit(object sender, TestWorkflowPluginEventArgs e)
    {
        // get the start time
    }
    protected override void PostTestCleanup(object sender, TestWorkflowPluginEventArgs e)
    {
        // total time = start time - current time
        // IF total time > specified time ===> FAIL TEST
    }
}
```

In PostTestInit we start a stopwatch. We get the number placed inside the attribute in the PostTestCleanup method. Then stop the stopwatch and compare the actual and specified times. In case first took longer, we fail the test.  
[Learn more about Extended Test Execution Life Cycle and Plugins](https://docs.bellatrix.solutions/web-automation/extensibility-test-workflow-hooks/)

## Element Action Hooks

## Element Action Hooks

#### Another way to extend BELLATRIX is to use the controls hooks.

This is how the BDD logging and highlighting are implemented. For each control’s method, there are two hooks- one that is called “before the action” and one “after”. For example, the available hooks for the button are:

-   **Clicking** – an event executed before button click
-   **Clicked** – an event executed after the button is clicked
-   **Hovering** – an event executed before button hover
-   **Hovered** – an event executed after the button is hovered
-   **Focusing** – an event executed before button focus
-   **Focused** – an event executed after the button is focused

You need to implement the event handlers for these events and subscribe to them.

```
public void ClickingEventHandler(object sender, ElementActionEventArgs arg)
{
    Logger.LogInformation($"Click {arg.Element.ElementName}");
}
public void HoveringEventHandler(object sender, ElementActionEventArgs arg)
{
    Logger.LogInformation($"Hover {arg.Element.ElementName}");
}
```

These are two sample event handlers for the BELLATRIX button where we log messages before clicking and hovering a button.

[Learn more about Element Action Hooks](https://docs.bellatrix.solutions/web-automation/extensibility-element-action-hooks/)

## Common Services Action Hooks

## Common Services Action Hooks

#### Another way to extend BELLATRIX is to use hooks for its common services.

This is how the failed test analysis works. Here is a list of some common services events you can subscribe to: NavigationService – UrlNotNavigatedEvent, called if the WaitForPartialUrl throws an exception ElementWaitService – OnElementNotFulfillingWaitConditionEvent, called if the Wait method throws an exception.

-   **ScrollingToVisible** – called before scrolling
-   **ScrollingToVisible** – called before scrolling
-   **ScrolledToVisible** – called after scrolling
-   **SettingAttribute** – called before setting a web attribute
-   **AttributeSet** – called after setting a value to a web attribute
-   **CreatingElement** – called before creating the element
-   **CreatedElement** – called after the creation of the element
-   **CreatingElements** – called before the creation of nested element
-   **CreatedElements** – called after the creation of nested element
-   **ReturningWrappedElement** – called before searching for a native WebDriver element

```
public static void OnElementNotFound(object sender, ExceptionEventArgs args)
{
    var exceptionAnalyser = new ExceptionAnalyser();
    exceptionAnalyser.Analyse(args.Exception);
    throw args.Exception;
}
```

This is one of the event handlers we use to call exception analysation engine if an element is not found.  
[Learn more about Common Services Action Hooks](https://docs.bellatrix.solutions/web-automation/extensibility-common-services-action-hooks/)

## Extend Existing UI Elements

## Extend Existing UI Elements

#### You have the ability to add new methods to existing BELLATRIX UI elements. You can add new methods in two ways.

### Extension Methods

One way to extend an existing element is to create an extension method for the additional action.

```
public static class ButtonExtensions
{
    public static void SubmitButtonWithEnter(this Button button)
    {
        var action = new Actions(button.WrappedDriver);
        action.MoveToElement(button.WrappedElement).SendKeys(Keys.Enter).Perform();
    }
}
```

To use the new method, add a using statement to the extension methods’ namespace.

```
proceedToCheckout.SubmitButtonWithEnter();
```

Click the “proceed to checkout” button via the Enter key instead of clicking on it.  
[Learn more about Extend Existing UI Elements](https://docs.bellatrix.solutions/web-automation/extensibility-extend-existing-elements-extension-methods/)

### Child Elements

The second way of extending an existing element is to create a child element. Inherit the UI control you want to extend.

```
public class ExtendedButton : Button
{
    public void SubmitButtonWithEnter()
    {
        var action = new Actions(WrappedDriver);
        action.MoveToElement(WrappedElement).SendKeys(Keys.Enter).Perform();
    }
}
```

Next in your tests, use the ExtendedButton instead of the regular Button to have access to these methods.

```
ExtendedButton proceedToCheckout = 
 App.ElementCreateService.CreateByClassContaining<ExtendedButton>("checkout-button button alt wc-forward");
```

[Learn more about Extend Existing UI Elements](https://docs.bellatrix.solutions/web-automation/extensibility-extend-existing-elements-child-elements/)

## Extend Common Services

## Extend Common Services

#### Ability to add a new method to BELLATRIX common services.

For example, a new special way of navigating or custom logic for handling dialog alerts.  
To extend the BELLATRIX common services you can create an extension method for the additional action.

```
public static class NavigationServiceExtensions
{
    public static void NavigateViaJavaScript(this NavigationService navigationService, string url)
    {
        var javaScriptService = new JavaScriptService();
        javaScriptService.Execute($"window.location.href = '{url}';");
    }
}
```

To use the new method, add a using statement to the extension methods’ namespace.

```
App.NavigationService.NavigateViaJavaScript("http://demos.bellatrix.solutions/");
```

[Learn more about Extend Common Services](https://docs.bellatrix.solutions/web-automation/extensibility-extend-common-services/)

## Add New Find Locators

## Add New Find Locators

#### The ability to avoid code duplication and complex locate expressions by adding a custom find locators.

Here is a sample implementation of the locator for finding all elements starting with ID.  
First, we need to create the By locator.

```
public class ByIdEndingWith : By
{
    public ByIdEndingWith(string value)
        : base(value)
    {
    }
    public override OpenQA.Selenium.By Convert() => OpenQA.Selenium.By.CssSelector($"[id^='{Value}']");
}
```

In the Convert method, we use a standard WebDriver By locator, and in this case we implement our requirements through a little CSS. To ease the usage of the locator, we need to create an extension method of ElementCreateService.

```
public static TElement CreateByIdStartingWith<TElement>(this ElementCreateService repository, string idStarting)
    where TElement : Element
{
    repository.Create<TElement, ByIdStartingWith>(new ByIdStartingWith(idStarting));
}
```

This is everything after that you can use your new locator as it was originally part of BELLATRIX.  
[Learn more about Add New Find Locators](https://docs.bellatrix.solutions/web-automation/extensibility-add-new-find-locators/)

## Add New Element Wait Methods

## Add New Element Wait Methods

#### Ability to add your custom element wait logic.

Imagine that you want to wait for an element to have a specific style. First, create a new class and inherit the BaseUntil class.

```
public class UntilHasStyle : BaseUntil
{
    private readonly string _elementStyle;
    public UntilHasStyle(string elementStyle, int? timeoutInterval = null, int? sleepInterval = null)
        : base(timeoutInterval, sleepInterval)
    {
        _elementStyle = elementStyle;
    }
    public override void WaitUntil<TBy>(TBy by) => WaitUntil(ElementHasStyle(WrappedWebDriver, by), TimeoutInterval, SleepInterval);
    private Func<IWebDriver, bool> ElementHasStyle<TBy>(ISearchContext searchContext, TBy by)
        where TBy : By => driver =>
                                    {
                                        try
                                        {
                                            var element = FindElement(searchContext, by);
                                            return element != null && element.GetAttribute("style").Equals(_elementStyle);
                                        }
                                        catch (StaleElementReferenceException)
                                        {
                                            return false;
                                        }
                                    };
}
```

The important part is located in the ElementHasStyle function. There we find the element and check the current value in the style attribute. The internal WaitUntil will wait until the value changes in the specified time. The next and final step is to create an extension method for all UI elements.

```
public static TElementType ToHasStyle<TElementType>(this TElementType element, string style, int? timeoutInterval = null, int? sleepInterval = null)
    where TElementType : Element
{
    var until = new UntilHasStyle(style, timeoutInterval, sleepInterval);
    element.EnsureState(until);
    return element;
}
```

After UntilHasStyle is created, it is important to be passed on to the element’s EnsureState method. From now on, the method is available as it was originally part of the framework.  
[Learn more about Add New Element Wait Methods](https://docs.bellatrix.solutions/web-automation/extensibility-add-new-element-wait-methods/)

---

# Troubleshooting Easiness (Web)

URL: https://bellatrix.solutions/features/web/troubleshooting-easiness/
Updated: 2021-11-29

## Full-page Screenshot on Test Failure

## Full-page Screenshot on Test Failure

#### BELLATRIX automatically creates a full-page screenshot if the test fails.

One of the best ways to detect what was the cause of the test failure is to see a screenshot of the web page at that moment. At least 50% of the time, action is happening in the invisible part of the screen since the web pages are more than one screen long. BELLATRIX screenshots show the whole page – even the invisible parts.

```
[TestClass]
[Browser(BrowserType.Chrome, BrowserBehavior.ReuseIfStarted)]
public class FullPageScreenshotsOnFailTests : WebTest
{
    [TestMethod]
    public void PromotionsPageOpened_When_PromotionsButtonClicked()
    {
        App.NavigationService.Navigate("http://demos.bellatrix.solutions/");
        var promotionsLink = App.ElementCreateService.CreateByLinkText<Anchor>("Promotions");
        promotionsLink.Click();
    }
}
```

If the test fails a screenshot is saved in the location you specified in the configuration file.  
[Learn more about Full-page Screenshot on Test Failure](https://docs.bellatrix.solutions/web-automation/troubleshooting-full-page-screenshots-on-fail/)

## Video on Test Failure

## Video on Test Failure

#### BELLATRIX automatically saves a video recording if the test fails.

Another great way to see what was the cause of test failure is to watch a video of the whole test execution. Since only the visible part of the screen can be recorded, video recording can be combined with the scroll to visible feature. If it is enabled in the configuration, before performing an action on an element, BELLATRIX scrolls until the element is visible on the screen.  
Another enhancement of the videos is the highlighting of elements. Before each action, the element is highlighted, which makes it easier to spot later in the videos.

```
[TestClass]
[Browser(BrowserType.Chrome, Lifecycle.ReuseIfStarted)]
public class VideoRecordingTests : WebTest
{
    [TestMethod]
    public void PromotionsPageOpened_When_PromotionsButtonClicked()
    {
        App.NavigationService.Navigate("http://demos.bellatrix.solutions/");
        var promotionsLink = App.ElementCreateService.CreateByLinkText<Anchor>("Promotions");
        promotionsLink.Click();
    }
}
```

[Learn more about Video on Test Failure](https://docs.bellatrix.solutions/web-automation/troubleshooting-video-recording/)

## Measure Test Execution Times

## Measure Test Execution Times

Sometimes it is useful to use your functional tests to measure performance or just to make sure that your app is not slow. To do this, BELLATRIX libraries offer the ExecutionTimeUnder attribute whereby you specify a timeout. If the test is executed over it, the test fails.

```

[ExecutionTimeUnder(2)]
public class MeasuredResponseTimesTests : WebTest
```

[Learn more about Measure Test Execution Times](https://docs.bellatrix.solutions/web-automation/troubleshooting-video-recording/)

---

# Test Responsive Layouts (Web)

URL: https://bellatrix.solutions/features/web/test-responsive-layouts/
Updated: 2021-11-29

## 200+ Assertions Based on Coordinates

## 200+ Assertions Based on Coordinates

#### Layout testing always seemed like a complex task. BELLATRIX offers a simple solution: test the location of objects relative to each other on the page.

BELLATRIX resizes your browser or app. It then finds the elements and makes various calculations and assertions based on their coordinates and whether an element is above, below, left, right, etc. in relation to another one. BELLATRIX comes with 200+ layout assertion methods.

```
[Browser(BrowserType.Chrome, DesktopWindowSize._1280_1024,  BrowserBehavior.RestartEveryTime)]
[TestClass]
public class LayoutTestingTests : WebTest
{
    [TestMethod]
    public void TestPageLayout()
    {
        App.NavigationService.Navigate("http://demos.bellatrix.solutions/");
        Select sortDropDown = App.ElementCreateService.CreateByNameEndingWith<Select>("orderby");
        Anchor protonRocketAnchor = 
		App.ElementCreateService.CreateByAttributesContaining<Anchor>("href", "/proton-rocket/");
        Div saturnVRating = saturnVAnchor.CreateByClassContaining<Div>("star-rating");
        sortDropDown.AssertAboveOf(protonRocketAnchor, 41);
        LayoutAssert.AssertAlignedHorizontallyAll(sortDropDown, protonRocketAnchor);
        saturnVRating.AssertInsideOf(saturnVAnchor);
        saturnVRating.AssertHeightLessThan(100);
        saturnVRating.AssertWidthBetween(50, 70);
    }
}
```

Depending on what you want to check, BELLATRIX gives lots of options. You can test px perfect or just that some element is below another. Check that the popularity sort dropdown is above the Proton rocket image.

```
sortDropDown.AssertAboveOf(protonRocketAnchor); 
```

Assert with the exact distance between them.

```
sortDropDown.AssertAboveOf(protonRocketAnchor, 41);
```

For each available method, you have variations of it such as, >, >=, <, <=, between and approximate to some expected value by specified %.

```
sortDropDown.AssertAboveOfGreaterThan(protonRocketAnchor, 40);
sortDropDown.AssertAboveOfGreaterThanOrEqual(protonRocketAnchor, 41);
sortDropDown.AssertAboveOfLessThan(protonRocketAnchor, 50);
sortDropDown.AssertAboveOfLessThanOrEqual(protonRocketAnchor, 43); 
```

The expected distance is ~40px with 10% tolerance.

```
sortDropDown.AssertAboveOfApproximate(protonRocketAnchor, 40, percent: 10);
```

You can test whether different web elements are aligned correctly.

```
LayoutAssert.AssertAlignedHorizontallyTop(protonRocketAnchor, protonMAnchor, saturnVAnchor);
LayoutAssert.AssertAlignedHorizontallyCentered(protonRocketAnchor, protonMAnchor, saturnVAnchor);
LayoutAssert.AssertAlignedHorizontallyBottom(protonRocketAnchor, protonMAnchor, saturnVAnchor);
LayoutAssert.AssertAlignedVerticallyAll(falcon9Anchor, falconHeavyAnchor);
 
```

Verify the height and width of elements.

```
saturnVRating.AssertHeightLessThan(100);
saturnVRating.AssertWidthBetween(50, 70);
```

You can use for all layout assertions the special web elements- Viewport and Screen.

```
saturnVRating.AssertInsideOf(SpecialElements.Viewport);
saturnVRating.AssertInsideOf(SpecialElements.Screen);
```

[Learn more about 200+ Assertions Based on Coordinates](https://docs.bellatrix.solutions/web-automation/layout-testing/)

## 15+ Predefined Resolutions

## 15+ Predefined Resolutions

#### BELLATRIX comes with 15+ of most often used resolution for desktop, mobile and tablet.

You can access them through DesktopWindowSize, MobileWindowSize and TabletWindowSize enumerations. The Browser attribute gives you the option to resize your browser window so that you can test the rearrangement of the web elements on your pages.

### DesktopWindowSize

![resolution for desktop testing](https://bellatrix.solutions/images/uploads/resolution-for-desktop-testing.png)

```
[Browser(BrowserType.Firefox, DesktopWindowSize._1280_1024,  BrowserBehavior.RestartEveryTime)]
```

### MobileWindowSize

![resolution for mobile testing](https://bellatrix.solutions/images/uploads/resolution-for-mobile-testing.png)

```
[Browser(BrowserType.Firefox, MobileWindowSize._360_640,  BrowserBehavior.RestartEveryTime)]
```

### TabletWindowSize

![resolution for mobile testing](https://bellatrix.solutions/images/uploads/resolution-for-tablet-testing.png)

```
[Browser(BrowserType.Firefox, TabletWindowSize._600_1024,  BrowserBehavior.RestartEveryTime)]
```

[Learn more about 15+ Predefined Resolutions](https://docs.bellatrix.solutions/web-automation/layout-testing/)

## Custom Resolutions

## Custom Resolutions

#### If you cannot find the resolution you would like to test on, you can specify your own.

```
[Browser(BrowserType.Firefox, width: 600, height: 900, behavior: BrowserBehavior.RestartEveryTime)]
```

[Learn more about Custom Resolutions](https://docs.bellatrix.solutions/web-automation/layout-testing/)

## Cloud Integration

## Cloud Integration

#### Easily integrate tests with all major cloud providers.

![Cloud Integration](https://bellatrix.solutions/images/uploads/logos_Cloud_Integration.png)

Some companies have their own farms of devices and computers with various browser configurations. However, nowadays the cloud providers such as SauceLabs, BrowserStack or CrossBrowserTesting are a reasonable solution to the problem.

In BELLATRIX, we make that possible through the usage of a single attribute which is placed over the test class.

```
[SauceLabs(BrowserType.Chrome,
    "62",
    "Windows",
    BrowserBehavior.ReuseIfStarted,
    recordScreenshots: true,
    recordVideo: true)]
[BrowserStack(BrowserType.Chrome,
    "62",
    "Windows",
    "10",
    BrowserBehavior.ReuseIfStarted,
    captureNetworkLogs: true,
    captureVideo: true,
    consoleLogType: BrowserStackConsoleLogType.Verbose,
    debug: true,
    build: "myUniqueBuildName")]
[CrossBrowserTesting(BrowserType.Chrome,
    "62",
    "Windows 10",
    BrowserBehavior.ReuseIfStarted,
    recordVideo: true,
    recordNetwork: true,
    build: "myUniqueBuildName")]
```

These integrations can help you to perform pixel perfect layout testing on various devices.

-   [Selenium Grid](https://docs.bellatrix.solutions/web-automation/execute-tests-selenium-grid/)
-   [SauceLabs](https://docs.bellatrix.solutions/web-automation/execute-tests-saucelabs/)
-   [BrowserStack](https://docs.bellatrix.solutions/web-automation/execute-tests-browserstack/)
-   [CrossBrowserTesting](https://docs.bellatrix.solutions/web-automation/execute-tests-crossbrowsertesting/)

[Learn more about Cloud Integration](https://docs.bellatrix.solutions/web-automation/execute-tests-saucelabs/)

## Style Testing

## Style Testing 

#### Style testing is a module from BELLATRIX that allows you to test the CSS styles of your website, such as background, border, other colors, font size, size, weight, and many others.

![Style Testing](https://bellatrix.solutions/images/uploads/style_testing.png)

In the case where you have a style guide for how different elements should look like consistently in your app, you can create a base class containing the tests for checking these styles. For example, you can have a base class for buttons, anchors, tables, and so on. After that, instead of copy-pasting these tests each time, you can derive from these base classes and navigate to the particular page, which should be checked.  
[Documentation](https://docs.bellatrix.solutions/web-automation/style-testing/)

---

# Boost Test Reliability (Web)

URL: https://bellatrix.solutions/features/web/boost-test-reliability/
Updated: 2021-11-29

## Handle All Synchronization Issues

## Handle All Synchronization Issues

#### BELLATRIX performs elements actions seamlessly, handling timeouts automatically.

One of the biggest problems in test automation is handling timeouts and performing actions on elements which may not be on the page right now. In the WebDriver world, you have to constantly worry about how to solve these problems with an implicit wait, explicit wait, or WebDriverWait class. BELLATRIX hides the whole complexity of searching and waiting for elements. When you perform an action or assertion against an element we guarantee that once returned is there.

## Lazy Loading of Elements

## Lazy Loading of Elements

#### Lazy loading means that BELLATRIX finds elements once you requested specific actions to be performed on the element.

In the time gap between selecting an element and finding it, the element’s state may change. That’s why we have an internal logic that locates elements upon request instead of when they are selected. This way, we prevent failing tests because the element state is different.

**WebDriver Example**

```
var agreeCheckBox = driver.FindElement(By.Id("agreeChB"));
var confirmButton = driver.FindElement(By.Id("confirm"));
agreeCheckBox.Click();
confirmButton.Click();
```

The problem with vanilla WebDriver is that it finds the elements immediately. If you use the element later and its state was changed, an error occurs.  
In the above example, the first agree checkbox is found, and then the confirm button. You uncheck the checkbox and the state of the button is changed. Once you perform the button click, an error occurs.

**BELLATRIX Example**

```
var agreeCheckBox = driver.FindElement(By.Id("agreeChB"));
var confirmButton = driver.FindElement(By.Id("confirm"));
agreeCheckBox.Click();
confirmButton.Click();
```

With BELLATRIX’s lazy loading, the checkbox is found during just before the unchecking. When you call the button click, then BELLATRIX searches for the button and it is returned with its updated state.

## Smart Wait Assertions

## Smart Wait Assertions

#### Additional methods which internally handle the whole complexity of waiting for some conditions to happen.

A major part of your tests are the assertions- actually checking whether some conditions are met. This might be checking whether some text is shown or whether some button has been disabled.  
However, this often doesn’t happen immediately. In the era of web pages with heavy JavaScript usage, most things happen asynchronously.

In most cases, if you just call the following code snippet, your test will fail because the DIV with a correct message might be displayed asynchronously with JS code.

```
Assert.AreEqual("Order Completed", successDiv.Text);
```

To handle such scenarios, we created elements Validate methods. They internally handle the whole complexity of waiting for some condition to happen.

Waits for the message alert to get disabled.

```
updateCart.ValidateIsDisabled();
```

Wait for message alert to disappear.

```
messageAlert.ValidateIsNotVisible();
```

You can even fine-tune the timeouts.

```
totalSpan.ValidateInnerTextIs("120.00€", timeout: 30, sleepInterval: 2);
```

For each specific element- button, span, anchor, image, etc. only the relevant Validate methods are displayed. Moreover, we hide the whole complexity of how the specific property is gotten, saving you tons of code and duplication.

![Smart wait assertions](https://bellatrix.solutions/images/uploads/smart_wait-_assertions.png)

[Learn more about Smart Wait Assertions](https://docs.bellatrix.solutions/web-automation/validate-assertions/)

---

# Human Readable Tests (Web)

URL: https://bellatrix.solutions/features/web/human-readable-tests/
Updated: 2021-11-29

## 30+ UI Elements Ready to Use

## 30+ UI Elements Ready to Use

#### Over 30 well-known web controls with actions and properties that are most relevant to them.

Since WebDriver is not a test framework, it is written in most generic manner. All web elements share a common IWebElement interface- containing the same methods and properties. For example- you use SendKeys method to type text in the text field, to click a button using Enter key or upload a file. Or why do you need Click method for DIV or text field?

**WebDriver example**

```
IWebElement agreeCheckBox = driver.FindElement(By.Id("agreeChB"));
agreeCheckBox.Click();
IWebElement firstNameTextField = driver.FindElement(By.Id("firstName"));
firstNameTextField.SendKeys("John");
IWebElement avatarUpload = driver.FindElement(By.Id("uploadAvatar"));
avatarUpload.SendKeys("pathTo\myAvatar.jpg");
IWebElement saveBtn = driver.FindElement(By.Id("saveBtn"));
agreeCheckBox.SendKeys(Keys.Enter); 
```

One more thing, if you don’t use suffixes in the names of your variables or properties, you won’t know what type of elements they are. In the case that you want to perform specific verifications, this might be important. For example, anchor web elements cannot be disabled, although buttons can. BELLATRIX offers over 30 strongly-typed web controls such as: anchor, button, text field, checkbox, etc. Each specific control contains well-named actions and properties that are most relevant to it.

**BELLATRIX Example**

```
CheckBox agreeCheckBox = App.ElementCreateService.CreateById<CheckBox>("agreeChB");
agreeCheckBox.Check();
TextField firstNameTextField = App.ElementCreateService.CreateById<TextField>("firstName");
firstNameTextField.SetText("John");
InputFile avatarUpload = App.ElementCreateService.CreateById<InputFile>("uploadAvatar");
avatarUpload.Upload("pathTo\myAvatar.jpg");
Button saveBtn = App.ElementCreateService.CreateById<Button>("saveBtn");
saveBtn.ClickByEnter();
```

While reading the code, you can quickly find out the type of the elements since it is the first thing you see. Moreover, the specific action methods and properties make the code more self-explanatory.

[Learn more about 30+ UI Elements Ready to Use](https://docs.bellatrix.solutions/web-automation/simple-components/)

## Hide Low-level Details with Page Objects

## Hide Low-level Details with Page Objects

#### Page objects are classes that group elements, actions, and assertions that are related to a specific web page.

### Page objects benefits:

-   Reuse elements locators
-   Fix elements locators in a single place
-   Combine elements in use case methods
-   Hide low-level API details- such as waiting for elements
-   Reuse assertion exception messages

BELLATRIX comes with enhanced built-in page objects. Each page object can be spread among three files. Each file holds a specific group of methods and properties. We can have one for actions, one for declaring elements, and one more for assertions.

This speeds up test development and maintenance, since you can find different parts of the page object more quickly. For example, if you need to fix the element locator, you open the Page.Elements file.

Page objects significantly improve the test’s readability. This is because their actions and assertion methods can have names which are more relatable to your business domain.

**BELLATRIX Example**

```
var homePage = App.GoTo<HomePage>();
homePage.FilterProducts(ProductFilter.Popularity);
homePage.AddProductById(28);
homePage.ViewCartButton.Click();
var cartPage = App.Create<CartPage>();
cartPage.ApplyCoupon("happybirthday");
cartPage.UpdateProductQuantity(1, 2);
cartPage.AssertTotalPrice("95.00");
cartPage.ProceedToCheckout.Click(); 
```

[Learn more about Hide Low-level Details with Page Objects](https://docs.bellatrix.solutions/web-automation/page-objects/)

---

# Easy Knowledge Transfer (Web)

URL: https://bellatrix.solutions/features/web/easy-knowledge-transfer/
Updated: 2021-11-29

## Starter Kits

## Starter Kits

#### The starter kit provides you with everything that your new members need to onboard themselves by themselves.

![Starter Kits](https://bellatrix.solutions/images/uploads/Starter_kits.png)

A frequent problem teams face is helping/teaching new members how to write “proper” tests using the team’s framework. Usually, one of most senior people spends countless hours on this process. Starter kits are an automated way allowing new people to learn by themselves. These are projects that have examples with explanations on how to write tests and why we use a particular method or not.

For each test technology, we created a similar starter kit for BELLATRIX. Each of them explains the features of the framework with detailed real-world examples. Moreover, they also contain detailed comments for each part. After each chapter, they offer exercises that people can do, and this makes it ideal for self-learning. Different features are grouped in separate folders, and at the end of each chapter, there is a TODO file containing the exercises.

[Learn more about Starter Kits](https://docs.bellatrix.solutions/general-information/how-to-use-starter-kits/)

## Rich Documentation

## Rich Documentation

#### Find out how every feature works.

Each BELLATRIX feature is explained with lots of examples and explanations in our documentation. You can find the various use cases of each API, as well as find out how to customize it through configurations or extend it. Even the most complicated parts of the framework are fully documented- how to write new plugins or controls, for instance.

[Learn more about Rich Documentation](https://docs.bellatrix.solutions/overview/)

---

# Unified Team Conventions (Web)

URL: https://bellatrix.solutions/features/web/unified-team-conventions/
Updated: 2021-11-29

## Enforce Coding Standards and Naming Conventions

## Enforce Coding Standards and Naming Conventions

#### BELLATRIX comes with two static analysis modules for applying coding standards.

Coding standards define a programming style. A coding standard does not usually concern itself with wrong or right in a more abstract sense. It is merely a set of rules and guidelines for the formatting of source code.

### Benefits:

-   **Seamless code integration**
-   **Team member integration**
-   **Easy to debug and maintain**
-   **Readability**
-   **Minimizes communication**
-   **Minimizes performance pitfalls**
-   **Saves money due to fewer man hours**

BELLATRIX comes with two modules for helping you apply coding standards in your tests- .editorconfig and StyleCop. The EditorConfig project consists of a file format for defining coding styles and a collection of text editor plugins that enable editors to read the file format and adhere to defined styles.

StyleCop is an open source static code analysis tool from Microsoft which checks C# code for conformance to StyleCop’s recommended coding styles, a subset of Microsoft’s .NET Framework Design Guidelines.

Static analysis integrates with all versions of Visual Studio. It contains a set of style and consistency rules. The code is checked on a build. If some of the rules are violated, warning messages are displayed. This way, you can quickly locate the problems and fix them.

![StyleCope](https://bellatrix.solutions/images/uploads/StyleCope.png)

All BELLATRIX projects come with predefined StyleCop and .editorconfig rules.

In the files, you can enable and disable particular rules and configure the severity of violations reported by individual rules.

![StyleCope](https://bellatrix.solutions/images/uploads/StyleCope_2.png)  
[Learn more about Enforce Coding Standards and Naming Conventions](https://docs.bellatrix.solutions/web-automation/static-analysis/)

## Structured Code Using Page Object Templates

## Structured Code Using Page Object Templates

#### 3 item templates for generating standardized page objects.

Page objects as any design pattern can be created in various ways and can easily pollute your code if you don’t have a way to enforce all engineers to write them in a unified way. This is done in case each page object is created in a different way – such as one in a single file and another with partial classes or navigation properties – as this can make your code harder to navigate, read, and maintain. To solve this problem, BELLATRIX comes with standardized page object item templates.

![Project templates](https://bellatrix.solutions/images/uploads/Templates.png)

### Choose one of the 3 web page objects templates

-   **Bellatrix-AssertedNavigatableWebPage** – contains 3 files- one for actions, one for element declarations and one for assertions (all of them make single page object).
-   **Bellatrix-NavigatableWebPage** – one for actions and one for elements (all of them make single object).
-   **Bellatrix-WebPage**– one for actions and one for elements (all of them make single page object), they don’t have methods for navigation.

![install templates](https://bellatrix.solutions/images/uploads/template_2.png)

The files are generated automatically. This way, all page objects have the same structure, parent classes, properties, usages, etc.  
[Learn more about Structured Code Using Page Object Templates](https://docs.bellatrix.solutions/web-automation/page-objects/)

---

# Android Test Automation Features

URL: https://bellatrix.solutions/features/android/
Updated: 2020-08-03

BELLATRIX Android test automation features: AI integration, faster test creation and execution, responsive layout checks, reliable waits and rich reports.

- [AI Integration](https://bellatrix.solutions/features/android/ai-integratio/): AI for Android test automation in BELLATRIX: find elements by prompt, validate UI state in plain language, self-heal broken locators and analyse failures.
- [Accelerate Test Creation](https://bellatrix.solutions/features/android/accelerate-test-creation/): BELLATRIX open-source framework can speed up your test creation by providing element snippets, handy elements locators, smart wait for the elements.
- [Accelerate Test Execution](https://bellatrix.solutions/features/android/accelerate-test-execution-android/): open-source test framework that can speed up your android tests execution by finding and waiting of elements and providing wider app life cycle control.
- [Extend The Framework to Fit Your Needs](https://bellatrix.solutions/features/android/extend-the-framework-to-fit-your-needs/): Extend BELLATRIX for Android testing: plug into every step of the test execution life cycle with plugins, extensibility points and custom locators.
- [Troubleshooting Easiness](https://bellatrix.solutions/features/android/troubleshooting-easiness-android-testing/): Troubleshoot Android tests faster with BELLATRIX: screenshots and video recording on failure plus detailed logs and reports for every test run.
- [Test Responsive Layouts](https://bellatrix.solutions/features/android/test-responsive-layouts-android/): Test responsive layouts based on test location of objects relative to each other on your Android application with BELLATRIX open-source test framework.
- [Boost Test Reliability](https://bellatrix.solutions/features/android/boost-test-reliability/): Make Android tests reliable with BELLATRIX: smart waits handle timeouts and guarantee elements are found before every action, removing flaky failures.
- [Human Readable Tests](https://bellatrix.solutions/features/android/human-readable-tests/): BELLATRIX open-source test framework generates test cases understandable for non-technical people. Built-in page objects and over 18 Android controls.
- [Easy Knowledge Transfer](https://bellatrix.solutions/features/android/easy-knowledge-transfer/): Everything that your team needs to know for BELLATRIX open-source test framework, from installation to the most complex features. For Android test automation.
- [Unified Team Conventions](https://bellatrix.solutions/features/android/unified-team-conventions/): BELLATRIX open-source framework comes with two static analysis modules with coding standards and item templates for generating standardized page objects.

---

# AI Integration (Android)

URL: https://bellatrix.solutions/features/android/ai-integratio/
Updated: 2025-08-07

## Overview

## Overview 

BELLATRIX Mobile Android now brings all advanced AI-powered features to native and hybrid app automation:

-   **Element Finding by Prompt:** Locate elements using plain English, not brittle selectors.
-   **Smart Scrolling Locators:** The AI generates intelligent UiAutomator expressions that auto-scroll to the correct element.
-   **AssertByPrompt / ValidateByPrompt:** Validate or assert UI states using natural language.
-   **Native Self-Healing via LLM:** Automatic healing when element locators break.
-   **Smart AI Analysis:** Root cause analysis and recommendations for failures.

These features make your Appium tests maintainable, robust, and accessible to non-coders.

[Learn more about Overview](https://docs.bellatrix.solutions/android-automation/ai-features/)

---

# Accelerate Test Creation (Android)

URL: https://bellatrix.solutions/features/android/accelerate-test-creation/
Updated: 2021-11-29

## API Usability- Locate Elements

## API Usability- Locate Elements

#### Additional methods and ability to add custom locators.

For example, in WebDriver to find an element, we use the FindElement method while specifying the locator through By class.

### WebDriver Example

```
IWebElement agreeCheckBox = driver.FindElement(By.Id("agreeChB"));
agreeCheckBox.Click();
```

However, this syntax requires additional effort. It is not fluent since you had to begin a new “chain” using the By static class. Also, it is not extendable if you want to add custom locators.

### BELLATRIX Example

```
var textField = App.ElementCreateService.CreateByIdContaining<TextField>("edit");
```

BELLATRIX provides you with a CreateBy method for each locator. Everything follows the natural writing flow, leveraging to the maximal degree on IntelliSense. If you add your custom locator, your method will appear as well.  
One of the coolest things that the BELLATRIX element includes, is the By property (knowing how it was located).

[Learn more about API Usability- Locate Elements](https://docs.bellatrix.solutions/android-automation/locate-elements/)

## API Usability- Wait for Elements

## API Usability- Wait for Elements

#### Smart wait for elements that will solve 80% of all use cases.

All elements are internally waited to exist before usage. This solves 80% of all use cases. After that as part of the CreateBy API, we added additional ToBe methods which you can chain. Which means you can specify an unlimited number of conditions for each element that needs to be fulfilled before the element is returned.

### Example

```
var button = App.ElementCreateService.CreateByIdContaining<Button>("button").ToBeClickable().ToBeVisible();
button.Click();
```

BELLATRIX comes with 7 default ToBe methods.

-   ToExists
-   ToNotExists
-   ToBeVisible
-   ToNotBeVisible
-   ToBeClickable
-   ToHasContent
-   ToBeDisabled

Moreover, it is relatively easy to add your custom ToBe methods if needed.

[Learn more about API Usability- Wait for Elements](https://docs.bellatrix.solutions/android-automation/wait-for-elements/)

## 150+ Additional Elements Actions

## 150+ Additional Elements Actions

#### BELLATRIX saves you a lot of effort and code with extended elements and services APIs.

BELLATRIX exposes 18+ Android controls. Each of them includes only the actions that you should be able to do with the specific control and nothing more.

```
var button = App.ElementCreateService.CreateByName<Button>("button");
button.Click();
var calendar = App.ElementCreateService.CreateByAutomationId<Calendar>("calendar");
Assert.AreEqual(false, calendar.IsDisabled);
var checkBox = App.ElementCreateService.CreateByName<CheckBox>("checkBox");
checkBox.Check();
Assert.IsTrue(checkBox.IsChecked);
var password = App.ElementCreateService.CreateByAutomationId<Password>("passwordBox");
password.SetPassword("topsecret");
```

The most important attributes of each Android control are included, as well as their assertion alternatives.  

```
var label = App.ElementCreateService.CreateByName<Label>("Result Label");
Assert.IsTrue(label.IsPresent);
Assert.AreEqual("Meissa Is Beautiful!", textField.InnerText);
```

[Learn more about 150+ Additional Elements Actions](https://docs.bellatrix.solutions/android-automation/common-components/)

---

# Accelerate Test Execution (Android)

URL: https://bellatrix.solutions/features/android/accelerate-test-execution-android/
Updated: 2021-11-29

## Optimized Element Finding and Waiting

## Optimized Element Finding and Waiting

#### Better finding and waiting of elements out of the box and flexible setup.

One of the most significant problems in test automation is handling timeouts and performing actions on elements which may not be on the screen right now.

If you use global timeouts such as WebDriver implicit wait.

```
AndroidDriver<AppiumWebElement> driver = new AndroidDriver<AppiumWebElement>(new Uri("http://127.0.0.1:4723/wd/hub", desiredCaps));
driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(30);
```

In some cases, you may need a larger wait interval. What do you do if this happens? One option is to increase the global timeout, but this will affect all existing tests, slowing down the whole test run significantly.  
Another option is to use the global timeout and occasionally add hard-coded pauses in your tests where needed.

```
Thread.Sleep(2000);
```

However, this is the worst thing you can do. One time you may need to wait 1 second, and another time 5 seconds. If you always use the biggest possible pause, your tests will get slower and slower.

BELLATRIX hides the whole complexity of searching and waiting for elements. All elements are returned immediately when they are present on the page in the right state.

## Optimized App Life Cycle Control

## Optimized App Life Cycle Control

#### Reuse the app and configure it when to restart.

Two of the operations that take the most time in Android tests are related to starting and closing the application under test. Each of these operations can take from a fraction of a second to several seconds. If you open and close the app for each test and you have thousands of tests, this can make your test runs more than twice as long!

To battle this problem, BELLATRIX offers an automatic way of handling the app life cycle across multiple tests. You need to set this behavior in the Android attribute applied to each test class.

```
[Android(Constants.AndroidNativeAppPath,
    Constants.AndroidDefaultAndroidVersion,
    Constants.AndroidDefaultDeviceName,
    Constants.AndroidNativeAppAppExamplePackage,
    ".view.Controls1",
    AppBehavior.RestartEveryTime)]
```

#### The app life cycle is configured through the AppBehavior property. Available options:

-   ### RestartEveryTime
    
    For each test a separate Appium instance is created and the previous app is closed.
    
-   ### RestartOnFail
    
    The app is only restarted if the previous test failed.
    
-   ### ReuseIfStarted
    
    The app is only restarted if the previous test’s app was different. In all other cases, the app is reused if possible.
    

If you use one of the “restart on fail” or “reuse if started” options, it can significantly decrease the test execution time, eliminating the additional time for browser initialization and disposal.  
[Learn more about Optimized App Life Cycle Control](https://docs.bellatrix.solutions/android-automation/control-app/)

## Execute Tests in Docker Containers using Selenoid

## Execute Tests in Docker Containers using Selenoid

![Execute Tests in Docker Containers using Selenoid](https://bellatrix.solutions/images/uploads/selenoid-ui-videos-1400x797.png)

Selenoid is a robust implementation of the Selenium hub using Docker containers to launch browsers. No need to manually install browsers or dive into WebDriver documentation. Any browser session can be saved to the H.264 video. An API to list, download, and delete saved log files. Suitable for personal usage and in big clusters.

To use BELLATRIX with Selenoid, you should use the Selenoid attribute instead of Browser. Selenoid has the same parameters as Browser but adds to additional ones- browser version, record video and save logs. As with the Browser attribute you can override the class behavior on Test level.

[Documentation](https://docs.bellatrix.solutions/web-automation/execute-tests-selenoid/)

---

# Extend The Framework to Fit Your Needs (Android)

URL: https://bellatrix.solutions/features/android/extend-the-framework-to-fit-your-needs/
Updated: 2021-11-29

## Extended Test Execution Life Cycle and Plugins

## Extended Test Execution Life Cycle and Plugins

#### Have a full control over your test execution.

All test frameworks give you the possibility to execute logic at certain points before or after tests. Typically tests are placed inside test classes. The standard test workflow for MSTest and NUnit is:

1\. **Execute Assembly Initialize** – once for the whole project  
2\. **Execute Class Initialize** – once for the test class  
3\. **Execute Test Initialize** – executed before each test  
4\. **Execute Test**  
5\. **Execute Test Cleanup** – executed after each test  
6\. **Execute Class Cleanup** – once for the test class  
7\. **Execute Assembly Cleanup** – once for the whole project

### Why do you need to extend the standard workflow?

Usually, you want to use these primary methods to execute business test-related logic. Sample use cases:

-   Take screenshots of test failure
-   Take videos on test failure
-   Fail tests if not executed under a certain time
-   Log test results in a 3rd party system
-   Control the app life cycle

In order to meet these requirements and allow you to write custom plugins, BELLATRIX comes with an extended test execution life cycle. When you write a plugin, you can execute logic in various phases of the new life cycle- before TestInitialize, after TestInitialize, before TestCleanup, after TestCleanup and more. For each test, all registered plugins logic is executed. This is how some of the BELLATRIX features work such as video and screenshot on test failure, app life cycle, and more.

### You can easily write your custom plugins. See how it is done.

In BELLATRIX, we have a feature called “execution time under”. Here you specify for the test class the maximal allowed test execution time if some of the tests take longer to run- it fails automatically. This is done through a test workflow plugin.

This is how we specify the maximal allowed time.

```
 [ExecutionTimeUnder(2)]
 public class MeasuredResponseTimesTests : AndroidTest
```

This is part of the plugin.

```
public class ExecutionTimeUnderTestWorkflowPlugin : TestWorkflowPlugin
{
    protected override void PostTestInit(object sender, TestWorkflowPluginEventArgs e)
    {
        // get the start time
    }
    protected override void PostTestCleanup(object sender, TestWorkflowPluginEventArgs e)
    {
        // total time = start time - current time
        // IF total time > specified time ===> FAIL TEST
    }
}
```

In PostTestInit we start a stopwatch. We get the number placed inside the attribute in the PostTestCleanup method. Then stop the stopwatch and compare the actual and specified times. In case first took longer we fail the test.

[Learn more about Extended Test Execution Life Cycle and Plugins](https://docs.bellatrix.solutions/android-automation/extensibility-custom-test-workflow-plugins/)

## Element Action Hooks

## Element Action Hooks

#### Another way to extend BELLATRIX is to use the controls hooks.

This is how the BDD logging is implemented. For each control’s method, there are two hooks- one that is called “before the action” and one “after”.  
For example, the available hooks for the button are:

-   **Clicking** – an event executed before button click
-   **Clicked** – an event executed after the button is clicked
-   **Hovering** – an event executed before button hover
-   **Hovered** – an event executed after the button is hovered

You need to implement the event handlers for these events and subscribe to them.

```
public void ClickingEventHandler(object sender, ElementActionEventArgs<AndroidElement> arg)
{
    Logger.LogInformation($"Click {arg.Element.ElementName}");
}
public void HoveringEventHandler(object sender, ElementActionEventArgs<AndroidElement> arg)
{
    Logger.LogInformation($"Hover {arg.Element.ElementName}");
}
```

These are two sample event handlers for the BELLATRIX button where we log messages before clicking and hovering a button.

[Learn more about Element Action Hooks](https://docs.bellatrix.solutions/android-automation/extensibility-element-action-hooks/)

## Common Services Action Hooks

## Common Services Action Hooks

#### Another way to extend BELLATRIX is to use hooks for its common services.

The base class for all web elements- Element provides a few special events as well:

-   **ScrollingToVisible** – called before scrolling
-   **ScrolledToVisible** – called after scrolling
-   **CreatingElement** – called before creating the element
-   **CreatedElement** – called after the creation of the element
-   **CreatingElements** – called before the creation of nested element
-   **CreatedElements** – called after the creation of nested element
-   **ReturningWrappedElement** – called before searching for a native WebDriver element

[Learn more about Common Services Action Hooks](https://docs.bellatrix.solutions/android-automation/extensibility-common-services-action-hooks/)

## Extend Existing UI Elements

## Extend Existing UI Elements

#### You have the ability to add new methods to existing BELLATRIX UI elements. You can add new methods in two ways.

### Extension Methods

One way to extend an existing element is to create an extension method for the additional action.

```
public static class ButtonExtensions
{
   public static void SubmitButtonWithScroll(this Button button)
   {
      button.ToExists().ToBeClickable().WaitToBe();
      button.ScrollToVisible();
      button.Click();
   }
}
```

To use the new method, add a using statement to the extension methods’ namespace.

```
button.SubmitButtonWithScroll();
```

Click the button with first scrolling to it.

[Learn more about Extend Existing UI Elements](https://docs.bellatrix.solutions/android-automation/extensibility-extend-existing-elements-extension-methods/)

### Child Elements

The second way of extending an existing element is to create a child element. Inherit the UI control you want to extend.

```
public class ExtendedButton : Button
{
    public void SubmitButtonWithScroll()
    {
         this.ToExists().ToBeClickable().WaitToBe();
         ScrollToVisible();
         Click();
    }
}
```

Next in your tests, use the ExtendedButton instead of the regular Button to have access to these methods.

```
ExtendedButton button = App.ElementCreateService.CreateByIdContaining<ExtendedButton>("button");
```

[Learn more about Extend Existing UI Elements](https://docs.bellatrix.solutions/android-automation/extensibility-extend-existing-elements-child-elements/)

## Extend Common Services

## Extend Common Services

#### Ability to add a new method to BELLATRIX common services.

For example, a new way of login into your application. To extend the BELLATRIX common services you can create an extension method for the additional action.

```
public static class AppServiceExtensions
{
    public static void LoginToApp(this AndroidAppService appService, string userName, string password)
    {
        var elementCreateService = new ElementCreateService();
        var userNameField = elementCreateService.CreateByIdContaining<TextField>("textBox");
        var passwordField = elementCreateService.CreateByIdContaining<Password>("passwordBox");
        var loginButton = elementCreateService.CreateByIdContaining<Button>("loginButton");
        userNameField.SetText(userName);
        passwordField.SetPassword(password);
        loginButton.Click();
    }
}
```

To use the new method, add a using statement to the extension methods’ namespace.

```
App.AppService.LoginToApp("bellatrix", "topSecret");
```

[Learn more about Extend Common Services](https://docs.bellatrix.solutions/android-automation/extensibility-extend-common-services/)

## Add New Find Locators

## Add New Find Locators

#### The ability to avoid code duplication and complex locate expressions by adding a custom find locators.

Here is a sample implementation of the locator for finding all elements starting with ID. First, we need to create the By locator.

```
public class ByIdStartingWith : By<AndroidDriver<AndroidElement>, AndroidElement>
{
    private readonly string _locatorValue;
    public ByIdStartingWith(string name)
        : base(name) => _locatorValue = $"new UiSelector().resourceIdMatches("{Value}.*");";
    public override AndroidElement FindElement(AndroidDriver<AndroidElement> searchContext) 
        => searchContext.FindElementByAndroidUIAutomator(_locatorValue);
    public override IEnumerable<AndroidElement> FindAllElements(AndroidDriver<AndroidElement> searchContext) 
        => searchContext.FindElementsByAndroidUIAutomator(_locatorValue);
    public override AppiumWebElement FindElement(AndroidElement element) 
        => element.FindElementByAndroidUIAutomator(_locatorValue);
    public override IEnumerable<AppiumWebElement> FindAllElements(AndroidElement element) 
        => element.FindElementsByAndroidUIAutomator(_locatorValue);
    public override string ToString() => $"ID starting with = {Value}";
}
```

We override all available methods and use UIAutomator regular expression for finding an element with ID starting with. To ease the usage of the locator, we need to create an extension method of ElementCreateService.

```
public static TElement CreateByIdStartingWith<TElement>(this ElementCreateService repo, string id)
  where TElement : Element<AndroidDriver<AndroidElement>, AndroidElement>
{
    return repo.Create<TElement, ByIdStartingWith, AndroidDriver<AndroidElement>, AndroidElement>(new ByIdStartingWith(id));
}
```

This is everything after that you can use your new locator as it was originally part of BELLATRIX.

[Learn more about Add New Find Locators](https://docs.bellatrix.solutions/android-automation/extensibility-add-new-find-locators/)

## Add New Element Wait Methods

## Add New Element Wait Methods

#### Ability to add your custom element wait logic.

Imagine that you want to wait for an element to have a specific content. First, create a new class and inherit the BaseUntil class.

```
public class UntilHaveSpecificContent<TDriver, TDriverElement> : BaseUntil<TDriver, TDriverElement>
    where TDriver : AppiumDriver<TDriverElement>
    where TDriverElement : AppiumWebElement
{
    private readonly string _elementContent;
    public UntilHaveSpecificContent(string elementContent, int? timeoutInterval = null, int? sleepInterval = null)
        : base(timeoutInterval, sleepInterval)
    {
        _elementContent = elementContent;
        TimeoutInterval = timeoutInterval ?? ConfigurationService.Instance.GetMobileSettings().ElementToHaveContentTimeout;
    }
    public override void WaitUntil<TBy>(TBy by) 
        => WaitUntil(ElementHasSpecificContent(WrappedWebDriver, by), TimeoutInterval, SleepInterval);
    private Func<TDriver, bool> ElementHasSpecificContent<TBy>(TDriver searchContext, TBy by)
        where TBy : By<TDriver, TDriverElement>
    {
        return driver =>
        {
            try
            {
                var element = by.FindElement(searchContext);
                return element.Text == _elementContent;
            }
            catch (NoSuchElementException)
            {
                return false;
            }
            catch (InvalidOperationException)
            {
                return false;
            }
        };
    }
}
Expand
```

The important part is located in the ElementHasSpecificContent function. There we find the element and check the current value in the Text attribute. The internal WaitUntil will wait until the value changes in the specified time.  
The next and final step is to create an extension method for all UI elements.

```
public static TElementType ToHaveSpecificContent<TElementType>(
	this TElementType element, 
	string content, 
	int? timeoutInterval = null, 
	int? sleepInterval = null)
where TElementType : Element
{
    var until = new UntilHaveSpecificContent<AndroidDriver<AndroidElement>, AndroidElement>(content, timeoutInterval, sleepInterval);
    element.EnsureState(until);
    return element;
}
```

After UntilHaveSpecificContent is created, it is important to be passed on to the element’s EnsureState method.  
From now on, the method is available as it was originally part of the framework.

[Learn more about Add New Element Wait Methods](https://docs.bellatrix.solutions/android-automation/extensibility-add-new-element-wait-methods/)

---

# Troubleshooting Easiness (Android)

URL: https://bellatrix.solutions/features/android/troubleshooting-easiness-android-testing/
Updated: 2021-11-29

## Screenshot on Test Failure

## Screenshot on Test Failure

#### BELLATRIX automatically creates a screenshot if the test fails.

One of the best ways to detect what was the cause of the test failure is to see a screenshot of the app at that moment.

```
[TestClass]
[Android(Constants.AndroidNativeAppPath,
    Constants.AndroidDefaultAndroidVersion,
    Constants.AndroidDefaultDeviceName,
    Constants.AndroidNativeAppAppExamplePackage,
    ".view.Controls",
    Lifecycle.ReuseIfStarted)]
public class ScreenshotsOnFailTests : AndroidTest
{
    [TestMethod]
    public void ButtonClicked_When_CallClickMethod()
    {
        var button = App.ElementCreateService.CreateByIdContaining<Button>("button");
        button.Click();
    }
}
```

If the test fails, a screenshot is saved in the location you specified in the configuration file.

[Learn more about Screenshot on Test Failure](https://docs.bellatrix.solutions/android-automation/troubleshooting-screenshots-on-fail/)

## Video on Test Failure

## Video on Test Failure

#### BELLATRIX automatically saves a video recording if the test fails.

Another great way to see what was the cause of test failure is to watch a video of the whole test execution.

```
[TestClass]
[Android(Constants.AndroidNativeAppPath,
    Constants.AndroidDefaultAndroidVersion,
    Constants.AndroidDefaultDeviceName,
    Constants.AndroidNativeAppAppExamplePackage,
    ".view.Controls",
    Lifecycle.ReuseIfStarted)]
public class VideoRecordingTests : AndroidTest
{
    [TestMethod]
    public void ButtonClicked_When_CallClickMethod()
    {
        var button = App.ElementCreateService.CreateByIdContaining<Button>("button");
        button.Click();
    }
}
```

[Learn more about Video on Test Failure](https://docs.bellatrix.solutions/android-automation/troubleshooting-video-recording/)

## Measure Test Execution Times

## Measure Test Execution Times

Sometimes it is useful to use your functional tests to measure performance or just to make sure that your app is not slow. To do this, Bellatrix libraries offer the ExecutionTimeUnder attribute whereby you specify a timeout. If the test is executed over it, the test fails.

```
[TestClass]
[ExecutionTimeUnder(2000, TimeUnit.Milliseconds)]
[Android(Constants.AndroidNativeAppPath,
    Constants.AndroidDefaultAndroidVersion,
    Constants.AndroidDefaultDeviceName,
    Constants.AndroidNativeAppAppExamplePackage,
    ".view.Controls1",
    Lifecycle.ReuseIfStarted)]
public class MeasureTestExecutionTimesTests : AndroidTest
```

[Learn more about Measure Test Execution Times](https://docs.bellatrix.solutions/android-automation/measure-test-execution-times/)

---

# Test Responsive Layouts (Android)

URL: https://bellatrix.solutions/features/android/test-responsive-layouts-android/
Updated: 2021-11-29

## 200+ Assertions Based on Coordinates

## 200+ Assertions Based on Coordinates

#### Layout testing always seemed like a complex task. BELLATRIX offers a simple solution- test the location of objects relative to each other.

BELLATRIX finds the elements and makes various calculations and assertions based on their coordinates and whether an element is above, below, left, right, etc. in relation to another one.

```
[TestMethod]
public void TestPageLayout()
{
    var button = App.ElementCreateService.CreateByIdContaining<Button>("button");
    var secondButton = App.ElementCreateService.CreateByIdContaining<Button>("button_disabled");
    var checkBox = App.ElementCreateService.CreateByIdContaining<CheckBox>("check1");
    var secondCheckBox = App.ElementCreateService.CreateByIdContaining<CheckBox>("check2");
    var mainElement = App.ElementCreateService.CreateById<Element>("android:id/content");
    button.AssertAboveOf(checkBox);
    checkBox.AssertNearBottomRightOf(button);
    button.AssertNearTopLeftOf(checkBox);
    LayoutAssert.AssertAlignedHorizontallyAll(button, secondButton);
    LayoutAssert.AssertAlignedVerticallyAll(secondCheckBox, checkBox);
    button.AssertInsideOf(mainElement);
    button.AssertHeightLessThan(100);
    button.AssertWidthBetween(50, 80);
}
```

Depending on what you want to check, BELLATRIX gives lots of options. You can test px perfect or just that some element is below another. Check that the purchase button is above the calendar.

```
button.AssertAboveOf(checkBox);
```

Assert with the exact distance between them.

```
button.AssertAboveOf(checkBox, 105);
```

For each available method, you have variations of it such as, >, >=, <, <=, between and approximate to some expected value by specified %.

```
button.AssertAboveOfGreaterThan(checkBox, 100);
button.AssertAboveOfGreaterThanOrEqual(checkBox, 105);
button.AssertAboveOfLessThan(checkBox, 110);
button.AssertAboveOfLessThanOrEqual(checkBox, 105);
```

The expected distance is ~104px with 10% tolerance.

```
button.AssertAboveOfApproximate(checkBox, 104, percent: 10);
```

You can assert the position of elements again each other in all directions- above, below, right, left, top right, top left, below left, below right. Assert that the checkbox is positioned near the top right of the button.

```
checkBox.AssertNearBottomRightOf(button);
button.AssertNearTopLeftOf(checkBox);
```

You can test whether different Android elements are aligned correctly.

```
LayoutAssert.AssertAlignedHorizontallyAll(button, secondButton);
LayoutAssert.AssertAlignedHorizontallyTop(button, secondButton);
LayoutAssert.AssertAlignedHorizontallyCentered(button, secondButton, secondButton);
LayoutAssert.AssertAlignedHorizontallyBottom(button, secondButton, secondButton);
LayoutAssert.AssertAlignedVerticallyAll(secondCheckBox, checkBox);
```

Verify the height and width of elements.

```
button.AssertHeightLessThan(100);
button.AssertWidthBetween(50, 80);
```

Assert that the elements are aligned vertically only from the left side.

```
button.AssertInsideOf(mainElement);
```

[Learn more about 200+ Assertions Based on Coordinates](https://docs.bellatrix.solutions/android-automation/layout-testing/)

## Cloud Integration

## Cloud Integration

#### Easily integrate tests with all major cloud providers.

![Cloud Integration](https://bellatrix.solutions/images/uploads/logos_Cloud_Integration-1.png)

Some companies have their own farms of devices and computers with various browser configurations. However, nowadays the cloud providers such as SauceLabs, BrowserStack or CrossBrowserTesting are a reasonable solution to the problem.

In BELLATRIX, we make that possible through the usage of a single attribute which is applied to the test class.

```
[AndroidSauceLabs("sauce-storage:ApiDemos.apk",
    "7.1",
    "Android GoogleAPI Emulator",
    Constants.AndroidNativeAppAppExamplePackage,
    ".view.ControlsMaterialDark",
    AppBehavior.RestartEveryTime)]
[AndroidBrowserStack("pngG38y26LZ5muB1p46P",
    "7.1",
    "Android GoogleAPI Emulator",
    Constants.AndroidNativeAppAppExamplePackage,
    ".view.ControlsMaterialDark",
    AppBehavior.RestartEveryTime,
    captureVideo: true,
    captureNetworkLogs: true,
    consoleLogType: BrowserStackConsoleLogType.Disable,
    debug: false,
    build: "CI Execution")]
[AndroidCrossBrowserTesting("crossBrowser-storage:ApiDemos.apk",
    "7.1",
    "Android GoogleAPI Emulator",
    Constants.AndroidNativeAppAppExamplePackage,
    ".view.ControlsMaterialDark",
    AppBehavior.RestartEveryTime,
    recordVideo: true,
    recordNetwork: true,
    build: "CI Execution")]
```

These integrations can help you to perform pixel perfect layout testing on various devices.

-   [SauceLabs](https://docs.bellatrix.solutions/android-automation/execute-tests-saucelabs/)
-   [BrowserStack](https://docs.bellatrix.solutions/android-automation/execute-tests-browserstack/)
-   [CrossBrowserTesting](https://docs.bellatrix.solutions/android-automation/execute-tests-crossbrowsertesting/)

[Learn more about Cloud Integration](https://docs.bellatrix.solutions/android-automation/layout-testing/)

---

# Boost Test Reliability (Android)

URL: https://bellatrix.solutions/features/android/boost-test-reliability/
Updated: 2021-11-29

## Handle All Synchronization Issues

## Handle All Synchronization Issues

#### BELLATRIX performs elements actions seamlessly, handling timeouts automatically.

One of the biggest problems in test automation is handling timeouts and performing actions on elements which may not be on the screen right now.In the WebDriver world, you have to constantly worry about how to solve these problems with an implicit wait, explicit wait, or WebDriverWait class.

BELLATRIX hides the whole complexity of searching and waiting for elements. When you perform an action or assertion against an element we guarantee that once returned is there.

## Lazy Loading of Elements

## Lazy Loading of Elements

#### Lazy loading means that BELLATRIX finds elements once you requested specific actions to be performed on the element.

In the time gap between selecting an element and finding it, the element’s state may change. That’s why we have an internal logic that locates elements upon request instead of when they are selected. This way, we prevent failing tests because the element state is different.

### WebDriver

```
 var agreeCheckBox = driver.FindElementById("agreeChB"));
var confirmButton = driver.FindElementById("confirm"));
agreeCheckBox.Click();
confirmButton.Click();
```

The problem with vanilla WebDriver/Appium is that it finds the elements immediately. If you use the element later and its state was changed, an error occurs.  
In the above example, the first agree checkbox is found, and then the confirm button. You uncheck the checkbox and the state of the button is changed. Once you perform the button click, an error occurs.

### BELLATRIX Example

```
var agreeCheckBox = App.ElementCreateService.CreateById<CheckBox>("agreeChB");
var confirmButton = App.ElementCreateService.CreateById<Button>("confirm");
agreeCheckBox.Uncheck();
confirmButton.Click();
```

With BELLATRIX’s lazy loading, the checkbox is found during just before the unchecking. When you call the button click, then BELLATRIX searches for the button and it is returned with its updated state.

[Learn more about Lazy Loading of Elements](https://docs.bellatrix.solutions/android-automation/wait-for-elements/)

## Smart Wait Assertions

## Smart Wait Assertions

#### Additional methods which internally handle the whole complexity of waiting for some conditions to happen.

A major part of your tests are the assertions- actually checking whether some conditions are met. This might be checking whether some text is shown or whether some button has been disabled. However, this often doesn’t happen immediately. In the era where most things happen asynchronously. In most cases, if you just call the following code snippet, your test will fail because the content box with a correct message might be displayed asynchronously.

```
Assert.AreEqual("Order Completed", successBox.Text);
```

To handle such scenarios, we created elements Validate methods. They internally handle the whole complexity of waiting for some condition to happen.  
Waits for the message alert to disappear.

```
messageAlert.ValidateIsNotVisible();
```

Wait for message alert to be disabled

```
updateCart.ValidateIsDisabled();
```

You can even fine-tune the timeouts.

```
totalContentBox.ValidateInnerTextIs("120.00€", timeout: 30, sleepInterval: 2);
```

For each specific element- button, content box, anchor, image, etc. only the relevant Validate methods are displayed.

![relevant validate methods](https://bellatrix.solutions/images/uploads/relevant_ensure_methods.png)

Moreover, we hide the whole complexity of how the specific property is gotten, saving you tons of code and duplication.

[Learn more about Smart Wait Assertions](https://docs.bellatrix.solutions/android-automation/wait-for-elements/)

---

# Human Readable Tests (Android)

URL: https://bellatrix.solutions/features/android/human-readable-tests/
Updated: 2021-11-29

## 18 UI Elements Ready to Use

## 18 UI Elements Ready to Use

#### Over 18 well-known Android controls with actions and properties that most relevant to them.

Since WebDriver is not a test framework, it is written in most generic manner. All Android elements share a common AndroidElement base class- containing the same methods and properties.

For example- you use SendKeys method to type text in the text field, to click a button using Enter key or upload a file. Or why do you need Click method for content box or text field?

### WebDriver Example

```
AppiumWebElement agreeCheckBox = driver.FindElementById("agreeChB"));
agreeCheckBox.Click();
AppiumWebElement firstNameTextField = driver.FindElementById("firstName"));
firstNameTextField.SendKeys("John");
AppiumWebElement saveBtn = driver.FindElementById("saveBtn"));
agreeCheckBox.SendKeys(Keys.Enter);
```

One more thing, if you don’t use suffixes in the names of your variables or properties, you won’t know what type of elements they are. In the case that you want to perform specific verifications, this might be important.

BELLATRIX offers 18 strongly-typed Android controls such as: combobox, button, text field, checkbox, etc. Each specific control contains well-named actions and properties that are most relevant to it.

### BELLATRIX Example

```
var checkBox = App.ElementCreateService.CreateByName<CheckBox>("checkBox");
checkBox.Check();
var comboBox = App.ElementCreateService.CreateByAutomationId<ComboBox>("select");
comboBox.SelectByText("Jupiter");
var button = App.ElementCreateService.CreateByName<Button>("button");
button.Click();
var textField = App.ElementCreateService.CreateByAutomationId<TextField>("textBox");
textField.SetText("Meissa Is Beautiful!");
```

While reading the code, you can quickly find out the type of the elements since it is the first thing you see. Moreover, the specific action methods and properties make the code more self-explanatory.

## Hide Low-level Details with Page Objects

## Hide Low-level Details with Page Objects

#### Page objects are classes that group elements, actions, and assertions that are related to a specific screen.

### Page objects benefits:

-   Reuse elements locators
-   Fix elements locators in a single place
-   Combine elements in use case methods
-   Hide low-level API details- such as waiting for elements
-   Reuse assertion exception messages

BELLATRIX comes with enhanced built-in page objects. Each page object can be spread among three files. Each file holds a specific group of methods and properties. We can have one for actions, one for declaring elements, and one more for assertions.

This speeds up test development and maintenance, since you can find different parts of the page object more quickly. For example, if you need to fix the element locator, you open the Page.Elements file.

Page objects significantly improve the test’s readability. This is because their actions and assertion methods can have names which are more relatable to your business domain.

**BELLATRIX Example**

```
var homePage = App.GoTo<HomePage>();
homePage.FilterProducts(ProductFilter.Popularity);
homePage.AddProductById(28);
homePage.ViewCartButton.Click();
var cartPage = App.Create<CartPage>();
cartPage.ApplyCoupon("happybirthday");
cartPage.UpdateProductQuantity(1, 2);
cartPage.AssertTotalPrice("95.00");
cartPage.ProceedToCheckout.Click();
```

[Learn more about Hide Low-level Details with Page Objects](https://docs.bellatrix.solutions/android-automation/page-objects/)

---

# Easy Knowledge Transfer (Android)

URL: https://bellatrix.solutions/features/android/easy-knowledge-transfer/
Updated: 2021-11-29

## Starter Kits

## Starter Kits

#### The starter kit provides you with everything that your new members need to onboard themselves by themselves.

![Starter Kits](https://bellatrix.solutions/images/uploads/Starter_kits-3.png)

A frequent problem teams face is helping/teaching new members how to write “proper” tests using the team’s framework. Usually, one of most senior people spends countless hours on this process. Starter kits are an automated way allowing new people to learn by themselves. These are projects that have examples with explanations on how to write tests and why we use a particular method or not.

For each test technology, we created a similar starter kit for BELLATRIX. Each of them explains the features of the framework with detailed real-world examples. Moreover, they also contain detailed comments for each part. After each chapter, they offer exercises that people can do, and this makes it ideal for self-learning. Different features are grouped in separate folders, and at the end of each chapter, there is a TODO file containing the exercises.

[Learn more about Starter Kits](https://docs.bellatrix.solutions/general-information/how-to-use-starter-kits/)

## Rich Documentation

## Rich Documentation

#### Find out how every feature works.

Each BELLATRIX feature is explained with lots of examples and explanations in our documentation. You can find the various use cases of each API, as well as find out how to customize it through configurations or extend it. Even the most complicated parts of the framework are fully documented- how to write new plugins or controls, for instance.

[Learn more about Rich Documentation](https://docs.bellatrix.solutions/android-automation/)

---

# Unified Team Conventions (Android)

URL: https://bellatrix.solutions/features/android/unified-team-conventions/
Updated: 2021-11-29

## Enforce Coding Standards and Naming Conventions

## Enforce Coding Standards and Naming Conventions

#### BELLATRIX comes with two static analysis modules for applying coding standards.

Coding standards define a programming style. A coding standard does not usually concern itself with wrong or right in a more abstract sense. It is merely a set of rules and guidelines for the formatting of source code.

### Benefits:

-   **Seamless code integration**
-   **Team member integration**
-   **Easy to debug and maintain**
-   **Readability**
-   **Minimizes communication**
-   **Minimizes performance pitfalls**
-   **Saves money due to fewer man hours**

BELLATRIX comes with two modules for helping you apply coding standards in your tests- .editorconfig and StyleCop. The EditorConfig project consists of a file format for defining coding styles and a collection of text editor plugins that enable editors to read the file format and adhere to defined styles.

StyleCop is an open source static code analysis tool from Microsoft which checks C# code for conformance to StyleCop’s recommended coding styles, a subset of Microsoft’s .NET Framework Design Guidelines.

Static analysis integrates with all versions of Visual Studio. It contains a set of style and consistency rules. The code is checked on a build. If some of the rules are violated, warning messages are displayed. This way, you can quickly locate the problems and fix them.

![StyleCope](https://bellatrix.solutions/images/uploads/StyleCope.png)

All BELLATRIX projects come with predefined StyleCop and .editorconfig rules.

In the files, you can enable and disable particular rules and configure the severity of violations reported by individual rules.

![StyleCope](https://bellatrix.solutions/images/uploads/StyleCope_2.png)

[Learn more about Enforce Coding Standards and Naming Conventions](https://docs.bellatrix.solutions/android-automation/static-analysis/)

## Structured Code Using Page Object Templates

## Structured Code Using Page Object Templates

#### 3 item templates for generating standardized page objects.

Page objects as any design pattern can be created in various ways and can easily pollute your code if you don’t have a way to enforce all engineers to write them in a unified way. This is done in case each page object is created in a different way – such as one in a single file and another with partial classes or navigation properties – as this can make your code harder to navigate, read, and maintain. To solve this problem, BELLATRIX comes with standardized page object item templates.

![Project templates](https://bellatrix.solutions/images/uploads/Templates.png)

### Choose one of the 4 Android page objects templates:

-   **Bellatrix-AssertedAndroidPage** – contains 3 files- one for actions, one for element declarations and one for assertions (all of them make one-page object).
-   **Bellatrix-AndroidPage**– one for actions and one for elements (all of them make a one-page object), don’t have methods for navigation.
-   **Bellatrix-AndroidAssertedNavigatablePage**– one for actions and one for elements (all of them make a one-page object), one for assertions and contains methods for navigating to specific activity.
-   **Bellatrix-AndroidNavigatablePage**– one for actions and one for elements (all of them make a one-page object) and contains methods for navigating to specific activity.

![install templates](https://bellatrix.solutions/images/uploads/template_2.png)

The files are generated automatically. This way, all page objects have the same structure, parent classes, properties, usages, etc.

[Learn more about Structured Code Using Page Object Templates](https://docs.bellatrix.solutions/android-automation/page-objects/)

---

# iOS Test Automation Features

URL: https://bellatrix.solutions/features/ios/
Updated: 2020-08-04

BELLATRIX iOS test automation features: AI integration, faster test creation and execution, responsive layout checks, reliable waits and failure diagnostics.

- [AI Integration](https://bellatrix.solutions/features/ios/ai-integration/): AI for iOS test automation in BELLATRIX: find elements by prompt, assert UI state in plain language, self-heal broken locators and get root cause analysis.
- [Accelerate Test Creation](https://bellatrix.solutions/features/ios/accelerate-test-creation/): Create iOS tests faster with BELLATRIX: element snippets, handy locators and 150+ element actions for testing on real iOS devices or simulators.
- [Accelerate Test Execution](https://bellatrix.solutions/features/ios/accelerate-test-execution/): open-source test framework that can speed up your iOS tests execution by retrying failed requestsby our enhanced finding and waiting of elements.
- [Extend The Framework to Fit Your Needs](https://bellatrix.solutions/features/ios/extend-the-framework-to-fit-your-needs/): BELLATRIX open-source test framework for testing iOS devices will provide you with a broader test execution life cycle with the ability to plug-in.
- [Troubleshooting Easiness](https://bellatrix.solutions/features/ios/troubleshooting-easiness/): BELLATRIX open-source test framework for testing iOS devices has screenshots and video recording with log reports and rich test running information.
- [Test Responsive Layouts](https://bellatrix.solutions/features/ios/test-responsive-layouts/): BELLATRIX open-source test framework for testing iOS devices has responsive layouts testing based on the location of objects relative to each other.
- [Boost Test Reliability](https://bellatrix.solutions/features/ios/boost-test-reliability/): BELLATRIX open-source test framework for testing iOS devices handles timeouts and guarantees that your elements are found once you requested an action.
- [Human Readable Tests](https://bellatrix.solutions/features/ios/human-readable-tests/): Write human-readable iOS tests with BELLATRIX: built-in page objects and 18+ iOS controls with ready-to-use actions, properties and assertions.
- [Easy Knowledge Transfer](https://bellatrix.solutions/features/ios/easy-knowledge-transfer/): Onboard your team to iOS testing with BELLATRIX: starter kits and rich documentation cover everything from installation to the most advanced features.
- [Unified Team Conventions](https://bellatrix.solutions/features/ios/unified-team-conventions/): BELLATRIX open-source test framework for testing iOS devices comes with two static analysis modules and item templates for applying coding standards.

---

# AI Integration (iOS)

URL: https://bellatrix.solutions/features/ios/ai-integration/
Updated: 2025-08-07

## Overview

## Overview 

BELLATRIX Mobile iOS brings advanced AI-driven automation to native and hybrid iOS apps:

-   **Element Finding by Prompt:** Find elements with human-readable instructions, using semantic NSPredicate locators.
-   **AssertByPrompt / ValidateByPrompt:** Validate UI state by describing what you expect.
-   **Native Self-Healing via LLM:** Instantly repair failing locators after UI changes.
-   **Smart AI Analysis:** Automated failure root cause analysis and actionable recommendations.

[Learn more about Overview](https://docs.bellatrix.solutions/ios-automation/ai-features/)

---

# Accelerate Test Creation (iOS)

URL: https://bellatrix.solutions/features/ios/accelerate-test-creation/
Updated: 2021-11-29

## Speed Test Writing with Element Snippets

## Speed Test Writing with Element Snippets

#### By giving you a corresponding snippet for more than 15+ iOS elements out of the box, BELLATRIX will dramatically speed up your test writing.

Code snippets are small blocks of reusable code that can be inserted in a code file using a context menu command or a combination of hotkeys. In Visual Studio there are expansion snippets, which are added at a specified insertion point and may replace a snippet shortcut.  
For example, to generate a TextField property, you need to type somewhere in you class itextfield and press Tab.

```
public TextField FirstNumber => Element.CreateById<TextField>("IntegerA");
```

On the first press of tab, the above code is generated. The first placeholder that is selected is the name of the property. Once you change it, you can press Tab. Then, the second placeholder is chosen- the By locator’s type, by default, it is set to Id, press Tab again and change the actual locator.

## API Usability- Locate Elements

## API Usability- Locate Elements

#### Additional methods and ability to add a custom locator.

For example, in WebDriver to find an element, we use the FindElement method while specifying the locator through By class.

### WebDriver Example

```
IWebElement agreeCheckBox = driver.FindElement(By.Id("agreeChB"));
agreeCheckBox.Click();
```

However, this syntax requires additional effort. It is not fluent since you had to begin a new “chain” using the By static class. Also, it is not extendable if you want to add custom locators.

### BELLATRIX Example

```
public TextField NumberOne => Element.CreateById<TextField>("IntegerA");
```

BELLATRIX provides you with a CreateBy method for each locator. Everything follows the natural writing flow, leveraging to the maximal degree on IntelliSense. If you add your custom locator, your method will appear as well.  
One of the coolest things that the BELLATRIX element includes, is the By property (knowing how it was located).

[Learn more about API Usability- Locate Elements](https://docs.bellatrix.solutions/ios-automation/locate-elements/)

## API Usability- Wait for Elements

## API Usability- Wait for Elements

#### Smart wait for elements that will solve 80% of all use cases.

All elements are internally waited to exist before usage. This solves 80% of all use cases. After that as part of the CreateBy API, we added additional ToBe methods which you can chain. Which means you can specify an unlimited number of conditions for each element that needs to be fulfilled before the element is returned.

```
var button = App.ElementCreateService.CreateByName<Button>("button").ToBeClickable().ToBeVisible();
button.Click();
```

BELLATRIX comes with 7 default ToBe methods.

-   ToExists
-   ToNotExists
-   ToBeVisible
-   ToNotBeVisible
-   ToBeClickable
-   ToHasContent
-   ToBeDisabled

Moreover, it is relatively easy to add your custom ToBe methods if needed.

[Learn more about API Usability- Wait for Elements](https://docs.bellatrix.solutions/ios-automation/wait-for-elements/)

## 150+ Additional Elements Actions

## 150+ Additional Elements Actions

#### BELLATRIX saves you a lot of effort and code with extended elements and services APIs.

BELLATRIX exposes 15+ iOS controls. Each of them includes only the actions that you should be able to do with the specific control and nothing more.

```
var button = App.ElementCreateService.CreateByName<Button>("button");
button.Click();
var seekBar = App.ElementCreateService.CreateByName<SeekBar>("seekBar);
Assert.AreEqual(false, seekBar.IsDisabled);
var checkBox = App.ElementCreateService.CreateByName<CheckBox>("checkBox");
checkBox.Check();
Assert.IsTrue(checkBox.IsChecked);
var password = App.ElementCreateService.CreateById<Password>("passwordBox");
password.SetPassword("topsecret");
```

Or we bring new useful methods to default controls such as ScrollToVisible.

```
var textField = App.ElementCreateService.CreateById<TextField>("IntegerA");
textField .ScrollToVisible(ScrollDirection.Down);
```

The most important attributes of each iOS control are included, as well as their assertion alternatives.

```
var label = App.ElementCreateService.CreateByName<Label>("AnswerLabel");
Assert.IsTrue(label.IsPresent);
Assert.AreEqual("Meissa Is Beautiful!", textField.GetText());
```

[Learn more about 150+ Additional Elements Actions](https://docs.bellatrix.solutions/ios-automation/common-components/)

---

# Accelerate Test Execution (iOS)

URL: https://bellatrix.solutions/features/ios/accelerate-test-execution/
Updated: 2021-11-29

## Optimized Element Finding and Waiting

## Optimized Element Finding and Waiting

#### Better finding and waiting of elements out of the box and flexible setup.

One of the most significant problems in test automation is handling timeouts and performing actions on elements which may not be on the screen right now. If you use global timeouts such as WebDriver implicit wait.

```
IOSDriver<IOSElement> driver = new IOSDriver<IOSElement>(new Uri("http://127.0.0.1:4723/wd/hub", desiredCaps));
driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(30);
```

In some cases, you may need a larger wait interval. What do you do if this happens? One option is to increase the global timeout, but this will affect all existing tests, slowing down the whole test run significantly.  
Another option is to use the global timeout and occasionally add hard-coded pauses in your tests where needed.

```
Thread.Sleep(2000);
```

However, this is the worst thing you can do. One time you may need to wait 1 second, and another time 5 seconds. If you always use the biggest possible pause, your tests will get slower and slower.

BELLATRIX hides the whole complexity of searching and waiting for elements. All elements are returned immediately when they are present on the page in the right state.

## Optimized App Life Cycle Control

## Optimized App Life Cycle Control

#### Better finding and waiting of elements out of the box and flexible setup.

Two of the operations that take the most time in iOS tests are related to starting and closing the application under test. Each of these operations can take from a fraction of a second to several seconds. If you open and close the app for each test and you have thousands of tests, this can make your test runs more than twice as long!

To battle this problem, BELLATRIX offers an automatic way of handling the app life cycle across multiple tests. You need to set this behavior in the IOS attribute applied to each test class.

```
[IOS(Constants.IOSNativeAppPath,
    Constants.IOSDefaultVersion,
    Constants.IOSDefaultDeviceName,
    AppBehavior.ReuseIfStarted)]
public class BellatrixAppBehaviourTests : IOSTest
```

#### The app lifecycle is configured through the AppBehavior property. Available options:

-   ### RestartEveryTime
    
    For each test a separate Appium instance is created and the previous app is closed.
    
-   ### RestartOnFail
    
    The app is only restarted if the previous test failed.
    
-   ### ReuseIfStarted
    
    The app is only restarted if the previous test’s app was different. In all other cases, the app is reused if possible.
    

If you use one of the “restart on fail” or “reuse if started” options, it can significantly decrease the test execution time, eliminating the additional time for app initialization and disposal.  
[Learn more about Optimized App Life Cycle Control](https://docs.bellatrix.solutions/ios-automation/control-app/)

---

# Extend The Framework to Fit Your Needs (iOS)

URL: https://bellatrix.solutions/features/ios/extend-the-framework-to-fit-your-needs/
Updated: 2021-11-29

## Extended Test Execution Life cycle and Plugins

## Extended Test Execution Life cycle and Plugins

#### Have a full control over your test execution.

All test frameworks give you the possibility to execute logic at certain points before or after tests. Typically tests are placed inside test classes. The standard test workflow for MSTest and NUnit is:

1\. **Execute Assembly Initialize** – once for the whole project  
2\. **Execute Class Initialize** – once for the test class  
3\. **Execute Test Initialize** – executed before each test  
4\. **Execute Test**  
5\. **Execute Test Cleanup** – executed after each test  
6\. **Execute Class Cleanup** – once for the test class  
7\. **Execute Assembly Cleanup** – once for the whole project

### Why do you need to extend the standard workflow?

Usually, you want to use these primary methods to execute business test-related logic. Sample Use Cases:

-   Take screenshots of test failure
-   Take videos on test failure
-   Fail tests if not executed under a certain time
-   Log test results in a 3rd party system
-   Control the app life cycle

In order to meet these requirements and allow you to write custom plugins, BELLATRIX comes with an extended test execution life cycle. When you write a plugin, you can execute logic in various phases of the new life cycle- before TestInitialize, after TestInitialize, before TestCleanup, after TestCleanup and more. For each test, all registered plugins logic is executed. This is how some of the BELLATRIX features work such as video and screenshot on test failure, app life cycle, and more.

You can easily write your custom plugins. See how it is done. In BELLATRIX, we have a feature called “execution time under”. Here you specify for the test class the maximal allowed test execution time if some of the tests take longer to run- it fails automatically. This is done through a test workflow plugin.

This is how we specify the maximal allowed time.

```
 [ExecutionTimeUnder(2)]
 public class MeasuredResponseTimesTests : IOSTest
```

This is part of the plugin.

```
public class ExecutionTimeUnderTestWorkflowPlugin : TestWorkflowPlugin
{
    protected override void PostTestInit(object sender, TestWorkflowPluginEventArgs e)
    {
        // get the start time
    }
    protected override void PostTestCleanup(object sender, TestWorkflowPluginEventArgs e)
    {
        // total time = start time - current time
        // IF total time > specified time ===> FAIL TEST
    }
}
```

In PostTestInit we start a stopwatch. We get the number placed inside the attribute in the PostTestCleanup method. Then stop the stopwatch and compare the actual and specified times. In case first took longer we fail the test.

[Learn more about Extended Test Execution Life cycle and Plugins](https://docs.bellatrix.solutions/ios-automation/extensibility-test-workflow-hooks/)

## Element Action Hooks

## Element Action Hooks

#### Another way to extend BELLATRIX is to use the controls hooks.

This is how the BDD logging is implemented. For each control’s method, there are two hooks- one that is called “before the action” and one “after”.  
For example, the available hooks for the button are:

-   **Clicking** – an event executed before button click
-   **Clicked** – an event executed after the button is clicked
-   **Hovering** – an event executed before button hover
-   **Hovered** – an event executed after the button is hovered

You need to implement the event handlers for these events and subscribe to them.

```
public void ClickingEventHandler(object sender, ElementActionEventArgs<IOSElement> arg)
{
    Logger.LogInformation($"Click {arg.Element.ElementName}");
}
public void HoveringEventHandler(object sender, ElementActionEventArgs<IOSElement> arg)
{
    Logger.LogInformation($"Hover {arg.Element.ElementName}");
}
```

These are two sample event handlers for the BELLATRIX button where we log messages before clicking and hovering a button.

[Learn more about Element Action Hooks](https://docs.bellatrix.solutions/ios-automation/extensibility-element-action-hooks/)

## Common Services Action Hooks

## Common Services Action Hooks

#### Another way to extend BELLATRIX is to use hooks for its common services.

The base class for all web elements- Element provides a few special events as well:

-   **ScrollingToVisible** – called before scrolling
-   **ScrolledToVisible** – called after scrolling
-   **CreatingElement** – called before creating the element
-   **CreatedElement** – called after the creation of the element
-   **CreatingElements** – called before the creation of nested element
-   **CreatedElements** – called after the creation of nested element
-   **ReturningWrappedElement** – called before searching for a native WebDriver element

[Learn more about Common Services Action Hooks](https://docs.bellatrix.solutions/ios-automation/extensibility-common-services-action-hooks/)

## Extend Existing UI Elements

## Extend Existing UI Elements

#### You have the ability to add new methods to existing BELLATRIX UI elements. You can add new methods in two ways.

### Extension Methods

One way to extend an existing element is to create an extension method for the additional action.

```
public static class ButtonExtensions
{
   public static void SubmitButtonWithScroll(this Button button)
   {
      button.ToExists().ToBeClickable().WaitToBe();
      button.ScrollToVisible(ScrollDirection.Down);
      button.Click();
   }
}
```

To use the new method, add a using statement to the extension methods’ namespace.

```
button.SubmitButtonWithScroll();
```

Click the button with first scrolling to it.

[Learn more about Extend Existing UI Elements](https://docs.bellatrix.solutions/ios-automation/extensibility-extend-existing-elements-extension-methods/)

### Child Elements

The second way of extending an existing element is to create a child element. Inherit the UI control you want to extend.

```
public class ExtendedButton : Button
{
    public void SubmitButtonWithScroll()
    {
         this.ToExists().ToBeClickable().WaitToBe();
         ScrollToVisible(ScrollDirection.Down);
         Click();
    }
}
```

Next in your tests, use the ExtendedButton instead of the regular Button to have access to these methods.

```
ExtendedButton button = App.ElementCreateService.CreateByIdContaining<ExtendedButton>("button");
```

[Learn more about Extend Existing UI Elements](https://docs.bellatrix.solutions/ios-automation/extensibility-extend-existing-elements-child-elements/)

## Extend Common Services

## Extend Common Services

#### Ability to add a new method to BELLATRIX common services.

For example, a new way of login into your application. To extend the BELLATRIX common services you can create an extension method for the additional action.

```
public static class AppServiceExtensions
{
    public static void LoginToApp(this IOSAppService appService, string userName, string password)
    {
        var elementCreateService = new ElementCreateService();
        var userNameField = elementCreateService.CreateById<TextField>("IntegerA");
        var passwordField = elementCreateService.CreateById<Password>("IntegerB");
        var loginButton = elementCreateService.CreateById<Button>("ComputeSumButton");
        userNameField.SetText(userName);
        passwordField.SetPassword(password);
        loginButton.Click();
    }
}
```

To use the new method, add a using statement to the extension methods’ namespace.

```
App.AppService.LoginToApp("bellatrix", "topSecret");
```

[Learn more about Extend Common Services](https://docs.bellatrix.solutions/ios-automation/extensibility-common-services-action-hooks/)

## Add New Find Locators

## Add New Find Locators

#### The ability to avoid code duplication and complex locate expressions by adding a custom find locators.

Here is a sample implementation of the locator for finding all elements starting with name. First, we need to create the By locator.

```
public class ByNameStartingWith : By<IOSDriver<IOSElement>, IOSElement>
{
    private readonly string _locatorValue;
    public ByNameStartingWith(string name)
        : base(name) => _locatorValue = $"//*[starts-with(@name, '{Value}')]";
    public override IOSElement FindElement(IOSDriver<IOSElement> searchContext) => searchContext.FindElementByXPath(_locatorValue);
    public override IEnumerable<IOSElement> FindAllElements(IOSDriver<IOSElement> searchContext) => searchContext.FindElementsByXPath(_locatorValue);
    public override AppiumWebElement FindElement(IOSElement element) => element.FindElementByXPath(_locatorValue);
    public override IEnumerable<AppiumWebElement> FindAllElements(IOSElement element) => element.FindElementsByXPath(_locatorValue);
    public override string ToString() => $"Name starting with = {Value}";
}
```

We override all available methods and use UIAutomator regular expression for finding an element with ID starting with. To ease the usage of the locator, we need to create an extension method of ElementCreateService.

```
public static TElement CreateByNameStartingWith<TElement>(this ElementCreateService repo, string id)
    where TElement : Element<IOSDriver<IOSElement>, IOSElement>
{
    return repo.Create<TElement, ByNameStartingWith, IOSDriver<IOSElement>, IOSElement>(new ByNameStartingWith(id));
}
```

This is everything after that you can use your new locator as it was originally part of BELLATRIX.

[Learn more about Add New Find Locators](https://docs.bellatrix.solutions/ios-automation/extensibility-add-new-find-locators/)

## Add New Element Wait Methods

## Add New Element Wait Methods

#### Ability to add your custom element wait logic.

Imagine that you want to wait for an element to have a specific content. First, create a new class and inherit the BaseUntil class.

```
public class UntilHaveSpecificContent<TDriver, TDriverElement> : BaseUntil<TDriver, TDriverElement>
    where TDriver : IOSDriver<TDriverElement>
    where TDriverElement : AppiumWebElement
{
    private readonly string _elementContent;
    public UntilHaveSpecificContent(string elementContent, int? timeoutInterval = null, int? sleepInterval = null)
        : base(timeoutInterval, sleepInterval)
    {
        _elementContent = elementContent;
        TimeoutInterval = timeoutInterval ?? ConfigurationService.Instance.GetMobileSettings().ElementToHaveContentTimeout;
    }
    public override void WaitUntil<TBy>(TBy by) 
        => WaitUntil(ElementHasSpecificContent(WrappedWebDriver, by), TimeoutInterval, SleepInterval);
    private Func<TDriver, bool> ElementHasSpecificContent<TBy>(TDriver searchContext, TBy by)
        where TBy : By<TDriver, TDriverElement>
    {
        return driver =>
        {
            try
            {
                var element = by.FindElement(searchContext);
                return element.Text == _elementContent;
            }
            catch (NoSuchElementException)
            {
                return false;
            }
            catch (InvalidOperationException)
            {
                return false;
            }
        };
    }
}
Expand
```

The important part is located in the ElementHasSpecificContent function. There we find the element and check the current value in the Text attribute. The internal WaitUntil will wait until the value changes in the specified time. The next and final step is to create an extension method for all UI elements.

```
public static TElementType ToHaveSpecificContent<TElementType>(
	this TElementType element, 
	string content, 
	int? timeoutInterval = null, 
	int? sleepInterval = null)
where TElementType : Element
{
    var until = new UntilHaveSpecificContent<IOSDriver<IOSElement>, IOSElement>(content, timeoutInterval, sleepInterval);
    element.EnsureState(until);
    return element;
}
```

After UntilHaveSpecificContent is created, it is important to be passed on to the element’s EnsureState method. From now on, the method is available as it was originally part of the framework.

[Learn more about Add New Element Wait Methods](https://docs.bellatrix.solutions/ios-automation/extensibility-add-new-element-wait-methods/)

---

# Troubleshooting Easiness (iOS)

URL: https://bellatrix.solutions/features/ios/troubleshooting-easiness/
Updated: 2021-11-29

## Screenshot on Test Failure

## Screenshot on Test Failure

#### BELLATRIX automatically creates a screenshot if the test fails.

One of the best ways to detect what was the cause of the test failure is to see a screenshot of the app at that moment.

```
[TestClass]
[IOS(Constants.IOSNativeAppPath,
    Constants.IOSDefaultVersion,
    Constants.IOSDefaultDeviceName,
    Lifecycle.RestartEveryTime)]
public class ScreenshotsOnFailTests : IOSTest
{
    [TestMethod]
    public void ButtonClicked_When_CallClickMethod()
    {
        var button = App.ElementCreateService.CreateByName<Button>("ComputeSumButton");
        button.Click();
    }
}
```

If the test fails, a screenshot is saved in the location you specified in the configuration file.

[Learn more about Screenshot on Test Failure](https://docs.bellatrix.solutions/ios-automation/troubleshooting-screenshots-on-fail/)

## Video on Test Failure

## Video on Test Failure

#### BELLATRIX automatically saves a video recording if the test fails.

Another great way to see what was the cause of test failure is to watch a video of the whole test execution.

```
[TestClass]
[IOS(Constants.IOSNativeAppPath,
    Constants.IOSDefaultVersion,
    Constants.IOSDefaultDeviceName,
    Lifecycle.RestartEveryTime)]
public class VideoRecordingTests : IOSTest
{
    [TestMethod]
    public void ButtonClicked_When_CallClickMethod()
    {
        var button = App.ElementCreateService.CreateByName<Button>("ComputeSumButton");
        button.Click();
    }
}
```

[Learn more about Video on Test Failure](https://docs.bellatrix.solutions/ios-automation/troubleshooting-video-recording/)

## Measure Test Execution Times

## Measure Test Execution Times

Sometimes it is useful to use your functional tests to measure performance or just to make sure that your app is not slow. To do this, Bellatrix libraries offer the ExecutionTimeUnder attribute whereby you specify a timeout. If the test is executed over it, the test fails.

```
[TestClass]
[ExecutionTimeUnder(5000, TimeUnit.Milliseconds)]
[IOS(Constants.IOSNativeAppPath,
    Constants.IOSDefaultVersion,
    Constants.IOSDefaultDeviceName,
    AppBehavior.RestartEveryTime)]
public class MeasureTestExecutionTimesTests : IOSTest
```

[Learn more about Measure Test Execution Times](https://docs.bellatrix.solutions/ios-automation/measure-test-execution-times/)

---

# Test Responsive Layouts (iOS)

URL: https://bellatrix.solutions/features/ios/test-responsive-layouts/
Updated: 2021-11-29

## 200+ Assertions Based on Coordinates

## 200+ Assertions Based on Coordinates

#### Layout testing always seemed like a complex task. BELLATRIX offers a simple solution- test the location of objects relative to each other.

BELLATRIX finds the elements and makes various calculations and assertions based on their coordinates and whether an element is above, below, left, right, etc. in relation to another one. BELLATRIX comes with 200+ layout assertion methods.

```
[TestMethod]
public void TestPageLayout()
{
    var button = App.ElementCreateService.CreateByIdContaining<Button>("button");
    var secondButton = App.ElementCreateService.CreateByIdContaining<Button>("button_disabled");
    var checkBox = App.ElementCreateService.CreateByIdContaining<CheckBox>("checkBox");
    var secondCheckBox = App.ElementCreateService.CreateByIdContaining<CheckBox>("secondsCheckBox");
    var mainElement = App.ElementCreateService.CreateById<Element>("mainView");
    button.AssertAboveOf(checkBox);
    checkBox.AssertNearBottomRightOf(button);
    button.AssertNearTopLeftOf(checkBox);
    LayoutAssert.AssertAlignedHorizontallyAll(button, secondButton);
    LayoutAssert.AssertAlignedVerticallyAll(secondCheckBox, checkBox);
    button.AssertInsideOf(mainElement);
    button.AssertHeightLessThan(100);
    button.AssertWidthBetween(50, 80);
}
```

Depending on what you want to check, BELLATRIX gives lots of options. You can test px perfect or just that some element is below another. Check that the purchase button is above the checkbox.

```
button.AssertAboveOf(checkBox);
```

Assert with the exact distance between them.

```
button.AssertAboveOf(checkBox, 105);
```

For each available method, you have variations of it such as, >, >=, <, <=, between and approximate to some expected value by specified %.

```
button.AssertAboveOfGreaterThan(checkBox, 100);
button.AssertAboveOfGreaterThanOrEqual(checkBox, 105);
button.AssertAboveOfLessThan(checkBox, 110);
button.AssertAboveOfLessThanOrEqual(checkBox, 105);
```

The expected distance is ~104px with 10% tolerance.

```
button.AssertAboveOfApproximate(checkBox, 104, percent: 10);
```

You can assert the position of elements again each other in all directions- above, below, right, left, top right, top left, below left, below right. Assert that the checkbox is positioned near the top right of the button.

```
checkBox.AssertNearBottomRightOf(button);
button.AssertNearTopLeftOf(checkBox);
```

You can test whether different elements are aligned correctly.

```
LayoutAssert.AssertAlignedHorizontallyAll(button, secondButton);
LayoutAssert.AssertAlignedHorizontallyTop(button, secondButton);
LayoutAssert.AssertAlignedHorizontallyCentered(button, secondButton, secondButton);
LayoutAssert.AssertAlignedHorizontallyBottom(button, secondButton, secondButton);
LayoutAssert.AssertAlignedVerticallyAll(secondCheckBox, checkBox);
```

Verify the height and width of elements.

```
button.AssertHeightLessThan(100);
button.AssertWidthBetween(50, 80);
```

Assert that the elements are aligned vertically only from the left side.

```
button.AssertInsideOf(mainElement);
```

[Learn more about 200+ Assertions Based on Coordinates](https://docs.bellatrix.solutions/ios-automation/layout-testing/)

## Cloud Integration

## Cloud Integration

#### Easily integrate tests with all major cloud providers.

![Cloud Integration](https://bellatrix.solutions/images/uploads/logos_Cloud_Integration-2.png)

Some companies have their own farms of devices and computers with various browser configurations. However, nowadays the cloud providers such as SauceLabs, BrowserStack or CrossBrowserTesting are a reasonable solution to the problem.

In BELLATRIX, we make that possible through the usage of a single attribute which is applied to the test class.

```
[IOSSauceLabs("sauce-storage:TestApp.app.zip",
    Constants.IOSDefaultVersion,
    Constants.IOSDefaultDeviceName,
    AppBehavior.RestartEveryTime)]
[IOSBrowserStack("pngG38y26LZ5muB1p46P",
    "11.3",
    "iPhone 6",
    AppBehavior.RestartEveryTime,
    captureVideo: true,
    captureNetworkLogs: true,
    consoleLogType: BrowserStackConsoleLogType.Disable,
    debug: false,
    build: "CI Execution")]
[IOSCrossBrowserTesting("crossBrowser-storage:TestApp.app.zip",
    "11.3",
    "iPhone 6",
    AppBehavior.RestartEveryTime,
    recordVideo: true,
    recordNetwork: true,
    build: "CI Execution")]
```

These integrations can help you to perform pixel perfect layout testing on various devices.

-   [SauceLabs](https://docs.bellatrix.solutions/ios-automation/execute-tests-saucelabs/)
-   [BrowserStack](https://docs.bellatrix.solutions/ios-automation/execute-tests-browserstack/)
-   [CrossBrowserTesting](https://docs.bellatrix.solutions/ios-automation/execute-tests-crossbrowsertesting/)

[Learn more about Cloud Integration](https://docs.bellatrix.solutions/ios-automation/layout-testing/)

---

# Boost Test Reliability (iOS)

URL: https://bellatrix.solutions/features/ios/boost-test-reliability/
Updated: 2021-11-29

## Handle All Synchronization Issues

## Handle All Synchronization Issues

#### BELLATRIX performs elements actions seamlessly, handling timeouts automatically.

One of the biggest problems in test automation is handling timeouts and performing actions on elements which may not be on the screen right now. In the WebDriver world, you have to constantly worry about how to solve these problems with an implicit wait, explicit wait, or WebDriverWait class. BELLATRIX hides the whole complexity of searching and waiting for elements. When you perform an action or assertion against an element we guarantee that once returned is there.

## Lazy Loading of Elements

## Lazy Loading of Elements

#### Lazy loading means that BELLATRIX finds elements once you requested specific actions to be performed on the element.

In the time gap between selecting an element and finding it, the element’s state may change. That’s why we have an internal logic that locates elements upon request instead of when they are selected. This way, we prevent failing tests because the element state is different.

### WebDriver Example

```
var agreeCheckBox = driver.FindElementById("agreeChB"));
var confirmButton = driver.FindElementById("confirm"));
agreeCheckBox.Click();
confirmButton.Click();
```

The problem with vanilla WebDriver/Appium is that it finds the elements immediately. If you use the element later and its state was changed, an error occurs. In the above example, the first agree checkbox is found, and then the confirm button. You uncheck the checkbox and the state of the button is changed. Once you perform the button click, an error occurs.

### BELLATRIX Example

```
var agreeCheckBox = App.ElementCreateService.CreateById<CheckBox>("agreeChB");
var confirmButton = App.ElementCreateService.CreateById<Button>("confirm");
agreeCheckBox.Uncheck();
confirmButton.Click();
```

With BELLATRIX’s lazy loading, the checkbox is found during just before the unchecking. When you call the button click, then BELLATRIX searches for the button and it is returned with its updated state.

[Learn more about Lazy Loading of Elements](https://docs.bellatrix.solutions/ios-automation/wait-for-elements/)

## Smart Wait Assertions

## Smart Wait Assertions

#### Additional methods which internally handle the whole complexity of waiting for some conditions to happen.

A major part of your tests are the assertions- actually checking whether some conditions are met. This might be checking whether some text is shown or whether some button has been disabled. However, this often doesn’t happen immediately. In the era where most things happen asynchronously. In most cases, if you just call the following code snippet, your test will fail because the content box with a correct message might be displayed asynchronously.

```
Assert.AreEqual("Order Completed", successBox.Text);
```

To handle such scenarios, we created elements Ensure methods. They internally handle the whole complexity of waiting for some condition to happen.  
Waits for the message alert to disappear.

```
messageAlert.EnsureIsNotVisible();
```

Wait for message alert to be disabled

```
updateCart.EnsureIsDisabled();
```

You can even fine-tune the timeouts.

```
totalContentBox.EnsureInnerTextIs("120.00€", timeout: 30, sleepInterval: 2);
```

For each specific element- button, content box, anchor, image, etc. only the relevant Ensure methods are displayed.

![relevant ensure methods](https://bellatrix.solutions/images/uploads/relevant_ensure_methods.png)

Moreover, we hide the whole complexity of how the specific property is gotten, saving you tons of code and duplication.

[Learn more about Smart Wait Assertions](https://docs.bellatrix.solutions/ios-automation/wait-for-elements/)

---

# Human Readable Tests (iOS)

URL: https://bellatrix.solutions/features/ios/human-readable-tests/
Updated: 2021-11-29

## 18 UI Elements Ready to Use

## 18 UI Elements Ready to Use

#### Over 18 well-known iOS controls with actions and properties that most relevant to them.

Since WebDriver is not a test framework, it is written in most generic manner. All iOS elements share a common IOSElement base class- containing the same methods and properties. For example- you use SendKeys method to type text in the text field, to click a button using Enter key or upload a file. Or why do you need Click method for content box or text field?

### WebDriver Example

```
AppiumWebElement agreeCheckBox = driver.FindElementById("agreeChB"));
agreeCheckBox.Click();
AppiumWebElement firstNameTextField = driver.FindElementById("firstName"));
firstNameTextField.SendKeys("John");
AppiumWebElement saveBtn = driver.FindElementById("saveBtn"));
agreeCheckBox.SendKeys(Keys.Enter);
```

One more thing, if you don’t use suffixes in the names of your variables or properties, you won’t know what type of elements they are. In the case that you want to perform specific verifications, this might be important.

BELLATRIX offers 18 strongly-typed iOS controls such as: combobox, button, text field, checkbox, etc. Each specific control contains well-named actions and properties that most relevant to it.

```
var checkBox = App.ElementCreateService.CreateByName<CheckBox>("checkBox");
checkBox.Check();
var comboBox = App.ElementCreateService.CreateByName<ComboBox>("select");
comboBox.SelectByText("Jupiter");
var button = App.ElementCreateService.CreateById<Button>("button");
button.Click();
var textField = App.ElementCreateService.CreateByAutomationId<TextField>("textBox");
textField.SetText("Meissa Is Beautiful!");
```

While reading the code, you can quickly find out the type of the elements since it is the first thing you see. Moreover, the specific action methods and properties make the code more self-explanatory.

[Learn more about 18 UI Elements Ready to Use](https://docs.bellatrix.solutions/ios-automation/common-components/)

## Hide Low-level Details with Page Objects

## Hide Low-level Details with Page Objects

#### Page objects are classes that group elements, actions, and assertions that are related to a specific screen.

### Page objects benefits:

-   Reuse elements locators
-   Fix elements locators in a single place
-   Combine elements in use case methods
-   Hide low-level API details- such as waiting for elements
-   Reuse assertion exception messages

BELLATRIX comes with enhanced built-in page objects. Each page object can be spread among three files. Each file holds a specific group of methods and properties. We can have one for actions, one for declaring elements, and one more for assertions. This speeds up test development and maintenance, since you can find different parts of the page object more quickly. For example, if you need to fix the element locator, you open the Page.Elements file. Page objects significantly improve the tests’ readability. This is because their actions and assertion methods can have names which are more relatable to your business domain.

### BELLATRIX Example

```
var homePage = App.Get<HomePage>();
homePage.FilterProducts(ProductFilter.Popularity);
homePage.AddProductById(28);
homePage.ViewCartButton.Click();
var cartPage = App.Create<CartPage>();
cartPage.ApplyCoupon("happybirthday");
cartPage.UpdateProductQuantity(1, 2);
cartPage.AssertTotalPrice("95.00");
cartPage.ProceedToCheckout.Click();
```

[Learn more about Hide Low-level Details with Page Objects](https://docs.bellatrix.solutions/ios-automation/page-objects/)

## BDD Logging

## BDD Logging

#### There are cases when you need to show your colleagues or managers what tests you have. Sometimes you may have manual test cases, but their maintenance and up-to-date state are questionable.

BELLATRIX generates automatically these test cases for you. This is a sample test case log generated after test execution.

```
Start Test
Class = BDDLoggingTests Name = PurchaseRocketWithLogs
Select 'Sort by price: low to high' on CartPage 
Click ApplyCupon on CartPage 
Ensure SuccessDiv on CartPage inner text is 'Coupon code applied successfully.'
Set '0' into QuantityNumber on CartPage 
Click UpdateCartButton on CartPage 
Ensure OrderTotalSpan on CartPage inner text is '95.00€'
```

[Learn more about BDD Logging](https://docs.bellatrix.solutions/ios-automation/bdd-logging/)

---

# Easy Knowledge Transfer (iOS)

URL: https://bellatrix.solutions/features/ios/easy-knowledge-transfer/
Updated: 2021-11-29

## Starter Kits

## Starter Kits

#### The starter kit provides you with everything that your new members need to onboard themselves by themselves.

![Starter Kits](https://bellatrix.solutions/images/uploads/Starter_kits-4.png)

A frequent problem teams face is helping/teaching new members how to write “proper” tests using the team’s framework. Usually, one of most senior people spends countless hours on this process. Starter kits are an automated way allowing new people to learn by themselves. These are projects that have examples with explanations on how to write tests and why we use a particular method or not.  
For each test technology, we created a similar starter kit for BELLATRIX. Each of them explains the features of the framework with detailed real-world examples. Moreover, they also contain detailed comments for each part. After each chapter, they offer exercises that people can do, and this makes it ideal for self-learning. Different features are grouped in separate folders, and at the end of each chapter, there is a TODO file containing the exercises.

[Learn more about Starter Kits](https://docs.bellatrix.solutions/general-information/how-to-use-starter-kits/)

## Rich Documentation

## Rich Documentation

#### Find out how every feature works.

Each BELLATRIX feature is explained with lots of examples and explanations in our documentation. You can find the various use cases of each API, as well as find out how to customize it through configurations or extend it. Even the most complicated parts of the framework are fully documented- how to write new plugins or controls, for instance.

[Learn more about Rich Documentation](https://docs.bellatrix.solutions/ios-automation/)

---

# Unified Team Conventions (iOS)

URL: https://bellatrix.solutions/features/ios/unified-team-conventions/
Updated: 2021-11-29

## Enforce Coding Standards and Naming Conventions

## Enforce Coding Standards and Naming Conventions

#### BELLATRIX comes with two static analysis modules for applying coding standards.

Coding standards define a programming style. A coding standard does not usually concern itself with wrong or right in a more abstract sense. It is merely a set of rules and guidelines for the formatting of source code.

### Benefits:

-   **Seamless code integration**
-   **Team member integration**
-   **Easy to debug and maintain**
-   **Readability**
-   **Minimizes communication**
-   **Minimizes performance pitfalls**
-   **Saves money due to fewer man hours**

BELLATRIX comes with two modules for helping you apply coding standards in your tests- .editorconfig and StyleCop.

The EditorConfig project consists of a file format for defining coding styles and a collection of text editor plugins that enable editors to read the file format and adhere to defined styles. StyleCop is an open source static code analysis tool from Microsoft which checks C# code for conformance to StyleCop’s recommended coding styles, a subset of Microsoft’s .NET Framework Design Guidelines.

Static analysis integrates with all versions of Visual Studio. It contains a set of style and consistency rules. The code is checked on a build. If some of the rules are violated, warning messages are displayed. This way, you can quickly locate the problems and fix them.

![StyleCope](https://bellatrix.solutions/images/uploads/StyleCope.png)

All BELLATRIX projects come with predefined StyleCop and .editorconfig rules: StyleCopeRules.ruleset and .editorconfig. In the files, you can enable and disable particular rules and configure the severity of violations reported by individual rules.

![StyleCope](https://bellatrix.solutions/images/uploads/StyleCope_2.png)  
[Learn more about Enforce Coding Standards and Naming Conventions](https://docs.bellatrix.solutions/ios-automation/static-analysis/)

## Structured Code Using Page Object Templates

## Structured Code Using Page Object Templates

#### Item templates for generating standardized page objects.

Page objects as any design pattern can be created in various ways and can easily pollute your code if you don’t have a way to enforce all engineers to write them in a unified way. This is done in case each page object is created in a different way – such as one in a single file and another with partial classes or navigation properties – as this can make your code harder to navigate, read, and maintain. To solve this problem, BELLATRIX comes with standardized page object item templates.

![Project templates](https://bellatrix.solutions/images/uploads/Templates.png)

### Choose one of the 2 iOS page objects templates

-   **Bellatrix-AssertedIOSPage** – contains 3 files- one for actions, one for element declarations and one for assertions (all of them make one-page object).
-   **Bellatrix-IOSPage** – one for actions and one for elements (all of them make a one-page object), don’t have methods for navigation.

![install templates](https://bellatrix.solutions/images/uploads/template_2.png)

The files are generated automatically. This way, all page objects have the same structure, parent classes, properties, usages, etc.

[Learn more about Structured Code Using Page Object Templates](https://docs.bellatrix.solutions/ios-automation/page-objects/)

---

# Desktop Test Automation Features

URL: https://bellatrix.solutions/features/desktop/
Updated: 2020-08-03

BELLATRIX open-source test framework comes with screenshot and video recording on test failure, and extensibility to fit your desktop app testing needs.

- [AI Integration](https://bellatrix.solutions/features/desktop/ai-integration/): AI for desktop test automation in BELLATRIX: find elements by prompt, validate UI state in plain language, self-heal broken locators and analyse failures.
- [Image Recognition](https://bellatrix.solutions/features/desktop/image-recognition/): BELLATRIX open-source test framework image recognition library can be used to verify hard-to-assert functionalities such as PDFs, charts, and similar.
- [Accelerate Test Creation](https://bellatrix.solutions/features/desktop/accelerate-test-creation/): BELLATRIX open-source test framework comes with element snippets, templates, elements locators, 150 elements actions for improving your desktop app testing.
- [Accelerate Test Execution](https://bellatrix.solutions/features/desktop/accelerate-test-execution/): open-source test framework that can speed up your desktop tests execution by finding and waiting of elements, and providing an wider app life cycle control.
- [Extend The Framework to Fit Your Needs](https://bellatrix.solutions/features/desktop/extend-the-framework-to-fit-your-needs/): Extend BELLATRIX for desktop testing: plug into every step of the test execution life cycle with plugins, extensibility points and custom locators.
- [Troubleshooting Easiness](https://bellatrix.solutions/features/desktop/troubleshooting-easiness/): Troubleshoot desktop tests faster with BELLATRIX: screenshots and video recording on failure, better error locating and detailed logs for every run.
- [Test Responsive Layouts](https://bellatrix.solutions/features/desktop/test-responsive-layouts/): BELLATRIX open-source test framework includes responsive layouts based on the test location of objects and 15+ resolutions for testing your desktop app.
- [Boost Test Reliability](https://bellatrix.solutions/features/desktop/boost-test-reliability/): BELLATRIX open-source test framework handles timeouts and guarantees that your elements are found once you requested action on your desktop application.
- [Human Readable Tests](https://bellatrix.solutions/features/desktop/human-readable-tests/): Write human-readable desktop tests with BELLATRIX: built-in page objects and 18+ desktop controls with ready-to-use actions, properties and assertions.
- [Easy Knowledge Transfer](https://bellatrix.solutions/features/desktop/easy-knowledge-transfer/): Everything that your team needs to know for BELLATRIX open-source test framework, from installation to the most complex features. For Desktop test automation.
- [Unified Team Conventions](https://bellatrix.solutions/features/desktop/unified-team-conventions/): Unify desktop test code with BELLATRIX: two static analysis modules enforce coding standards and naming, plus item templates for consistent page objects.

---

# AI Integration (Desktop)

URL: https://bellatrix.solutions/features/desktop/ai-integration/
Updated: 2025-08-07

## Overview

## Overview 

BELLATRIX Desktop introduces four advanced AI-powered features for desktop automation using LLMs:

-   **Element Finding by Prompt:** Locate UI elements using natural language instructions—works for WPF, WinForms, and all supported desktop controls.
-   **AssertByPrompt / ValidateByPrompt:** Validate or assert UI states with human-readable descriptions.
-   **Native Self-Healing via LLM:** Automatic self-healing when locators break due to UI changes.
-   **Smart AI Analysis:** Deep root cause analysis and BDD-style logging for failed tests.

These features drastically reduce test maintenance, increase reliability, and enable prompt-driven automation for any desktop application.

[Learn more about Overview](https://docs.bellatrix.solutions/desktop-automation/ai-features/)

---

# Image Recognition (Desktop)

URL: https://bellatrix.solutions/features/desktop/image-recognition/
Updated: 2021-11-29

## Overview

## Overview 

BELLATRIX Image Recognition library can be used to verify hard-to-assert functionalities such as PDFs, charts, and similar. But our computer vision library is much more than that. You can even interact with everything on your screen. Perform clicks, set text, drag and drop, double click, and more. Our library uses a machine learning engine for comparing images of your screen. Basically, you add screenshots to your project and embed them to it. Afterward, you need to mention the name of the picture.

[Learn more about Overview](https://docs.bellatrix.solutions/desktop-automation/image-recognition/)

---

# Accelerate Test Creation (Desktop)

URL: https://bellatrix.solutions/features/desktop/accelerate-test-creation/
Updated: 2021-11-29

## Speed Test Writing with Element Snippets

## Speed Test Writing with Element Snippets

#### By giving you a corresponding snippet for more than 18 desktop elements out of the box, BELLATRIX will dramatically speed up your test writing.

Code snippets are small blocks of reusable code that can be inserted in a code file using a context menu command or a combination of hotkeys. In Visual Studio there are expansion snippets, which are added at a specified insertion point and may replace a snippet shortcut.

For example, to generate a CheckBox property, you need to type somewhere in you class dcheckbox and press Tab.

```
public CheckBox PermanentTransfer => Element.CreateByName<CheckBox>("BellaCheckBox");
```

On the first press of tab, the above code is generated. The first placeholder that is selected is the name of the property. Once you change it, you can press Tab. Then, the second placeholder is chosen- the By locator’s type, by default, it is set to Id, press Tab again and change the actual locator.

## API Usability- Locate Elements

## API Usability- Locate Elements

#### Additional methods and ability to add custom locators.

For example, in WebDriver to find an element, we use the FindElement method while specifying the locator through By class.

### WebDriver Example

```
IWebElement agreeCheckBox = driver.FindElement(By.Id("agreeChB"));
agreeCheckBox.Click();
```

However, this syntax requires additional effort. It is not fluent since you had to begin a new “chain” using the By static class. Also, it is not extendable if you want to add custom locators.

### BELLATRIX Example

```
CheckBox agreeCheckBox =
App.ElementCreateService.CreateById<CheckBox>("agreeChB");
agreeCheckBox.Check();
```

BELLATRIX provides you with a CreateBy method for each locator. Everything follows the natural writing flow, leveraging to the maximal degree on IntelliSense. If you add your custom locator, your method will appear as well. One of the coolest things that the BELLATRIX element includes, is the By property (knowing how it was located).

[Learn more about API Usability- Locate Elements](https://docs.bellatrix.solutions/desktop-automation/locate-elements/)

## API Usability- Wait for Elements

## API Usability- Wait for Elements

#### Smart wait for elements that will solve 80% of all use cases.

All elements are internally waited to exist before usage. This solves 80% of all use cases. After that as part of the CreateBy API, we added additional ToBe methods which you can chain. Which means you can specify an unlimited number of conditions for each element that needs to be fulfilled before the element is returned.

### Example

```
var purchaseButton = App.ElementCreateService.CreateByName<Button>("Purchase").ToBeVisible().ToBeClickable().ToExists();
purchaseButton.Click();
```

### BELLATRIX comes with 7 default ToBe methods.

-   **ToExists**
-   **ToNotExists**
-   **ToBeVisible**
-   **ToNotBeVisible**
-   **ToBeClickable**
-   **ToHasContent**
-   **ToBeDisabled**

Moreover, it is relatively easy to add your custom ToBe methods if needed.  
[Learn more about API Usability- Wait for Elements](https://docs.bellatrix.solutions/desktop-automation/locate-and-wait-elements/)

## 150+ Additional Elements Actions

## 150+ Additional Elements Actions

#### BELLATRIX saves you a lot of effort and code with extended elements and services APIs.

BELLATRIX exposes 18+ desktop controls. Each of them includes only the actions that you should be able to do with the specific control and nothing more.

```
var purchaseButton = App.ElementCreateService.CreateByName<Button>("Purchase");
purchaseButton.Click();
var calendar = App.ElementCreateService.CreateByAutomationId<Calendar>("calendar");
Assert.AreEqual(false, calendar.IsDisabled);
var checkBox = App.ElementCreateService.CreateByName<CheckBox>("BellaCheckBox");
checkBox.Check();
Assert.IsTrue(checkBox.IsChecked);
var password = App.ElementCreateService.CreateByAutomationId<Password>("passwordBox");
password.SetPassword("topsecret");
```

Or we bring new useful methods to default controls such as Focus and Hover.

```
var datePicker = App.ElementCreateService.CreateByAutomationId<Date>("DatePicker");
datePicker.Hover();
datePicker.Focus();
```

The most important attributes of each desktop control are included, as well as their assertion alternatives.

```
var label = App.ElementCreateService.CreateByName<Label>("Result Label");
Assert.IsTrue(label.IsPresent);
Assert.AreEqual("Rocket", comboBox.InnerText);
```

[Learn more about 150+ Additional Elements Actions](https://docs.bellatrix.solutions/desktop-automation/common-components/)

---

# Accelerate Test Execution (Desktop)

URL: https://bellatrix.solutions/features/desktop/accelerate-test-execution/
Updated: 2021-11-29

## Optimized Element Finding and Waiting

## Optimized Element Finding and Waiting

#### Better finding and waiting of elements out of the box and flexible setup.

One of the most significant problems in test automation is handling timeouts and performing actions on elements which may not be on the screen right now.

If you use global timeouts such as WebDriver implicit wait.

```
IWebDriver driver = new WindowsDriver<WindowsElement>(new Uri("http://127.0.0.1:4723"));
driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(30);
```

In some cases, you may need a larger wait interval. What do you do if this happens? One option is to increase the global timeout, but this will affect all existing tests, slowing down the whole test run significantly.

Another option is to use the global timeout and occasionally add hard-coded pauses in your tests where needed.

```
Thread.Sleep(2000);
```

However, this is the worst thing you can do. One time you may need to wait 1 second, and another time 5 seconds. If you always use the biggest possible pause, your tests will get slower and slower. BELLATRIX hides the whole complexity of searching and waiting for elements. All elements are returned immediately when they are present on the page in the right state.

[Learn more about Optimized Element Finding and Waiting](https://docs.bellatrix.solutions/desktop-automation/wait-for-elements/)

## Optimized App Life Cycle Control

## Optimized App Life Cycle Control

#### Reuse the application and configure it when to restart.

Two of the operations that take the most time in desktop tests are related to starting and closing the application under test. Each of these operations can take from a fraction of a second to several seconds. If you open and close the app for each test and you have thousands of tests, this can make your test runs more than twice as long!

To battle this problem, BELLATRIX offers an automatic way of handling the app life cycle across multiple tests. You need to set this behavior in the App attribute applied to each test class.

```
[App(Constants.WpfAppPath, AppBehavior.RestartEveryTime)]
public class ControlAppTests : DesktopTest
```

#### The app lifecycle is configured through the AppBehavior property. Available options:

-   ### RestartEveryTime
    
    For each test a separate WinAppDriver instance is created and the previous application is closed.
    
-   ### RestartOnFail
    
    The application is only restarted if the previous test failed.
    
-   ### ReuseIfStarted
    
    The application is only restarted if the previous test’s application was different. In all other cases, the application is reused if possible.
    

If you use one of the “restart on fail” or “reuse if started” options, it can significantly decrease the test execution time, eliminating the additional time for application initialization and disposal.  
[Learn more about Optimized App Life Cycle Control](https://docs.bellatrix.solutions/desktop-automation/control-app/)

---

# Extend The Framework to Fit Your Needs (Desktop)

URL: https://bellatrix.solutions/features/desktop/extend-the-framework-to-fit-your-needs/
Updated: 2021-11-29

## Extended Test Execution Life Cycle and Plugins

## Extended Test Execution Life Cycle and Plugins

#### Have a full control over your test execution.

All test frameworks give you the possibility to execute logic at certain points before or after tests. Typically tests are placed inside test classes. The standard test workflow for MSTest and NUnit is:

1\. **Execute Assembly Initialize** – Once for the whole project  
2\. **Execute Class Initialize** – Once for the test class  
3\. **Execute Test Initialize** – Executed before each test  
4\. **Execute Test**  
5\. **Execute Test Cleanup** – Executed after each test  
6\. **Execute Class Cleanup** – Once for the test class  
7\. **Execute Assembly Cleanup** – Once for the whole project

### Why do you need to extend the standard workflow?

Usually, you want to use these primary methods to execute business test-related logic. Sample use cases:

-   **Take screenshots of test failure**
-   **Take videos on test failure**
-   **Fail tests if not executed under a certain time**
-   **Log test results in a 3rd party system**
-   **Control the app life cycle**

In order to meet these requirements and allow you to write custom plugins, BELLATRIX comes with an extended test execution life cycle. When you write a plugin, you can execute logic in various phases of the new life cycle- before TestInitialize, after TestInitialize, before TestCleanup, after TestCleanup and more. For each test, all registered plugins logic is executed. This is how some of the BELLATRIX features work such as video and screenshot on test failure, browser life cycle, and more.

You can easily write your custom plugins. See how it is done. In BELLATRIX, we have a feature called “execution time under”. Here you specify for the test class the maximal allowed test execution time if some of the tests take longer to run- it fails automatically. This is done through a test workflow plugin.

This is how we specify the maximal allowed time.

```
 [ExecutionTimeUnder(2)]
 public class MeasuredResponseTimesTests : DesktopTest
```

This is part of the plugin.

```
public class ExecutionTimeUnderTestWorkflowPlugin : TestWorkflowPlugin
{
    protected override void PostTestInit(object sender, TestWorkflowPluginEventArgs e)
    {
        // get the start time
    }
    protected override void PostTestCleanup(object sender, TestWorkflowPluginEventArgs e)
    {
        // total time = start time - current time
        // IF total time > specified time ===> FAIL TEST
    }
}
```

In PostTestInit we start a stopwatch. We get the number placed inside the attribute in the PostTestCleanup method. Then stop the stopwatch and compare the actual and specified times. In case first took longer we fail the test.

[Learn more about Extended Test Execution Life Cycle and Plugins](https://docs.bellatrix.solutions/desktop-automation/extensibility-test-workflow-hooks/)

## Element Action Hooks

## Element Action Hooks

#### Another way to extend BELLATRIX is to use the controls hooks.

This is how the BDD logging is implemented. For each control’s method, there are two hooks- one that is called “before the action” and one “after”. For example, the available hooks for the button are:

-   **Clicking** – an event executed before button click
-   **Clicked** – an event executed after the button is clicked
-   **Hovering** – an event executed before button hover
-   **Hovered** – an event executed after the button is hovered

You need to implement the event handlers for these events and subscribe to them.

```
public void ClickingEventHandler(object sender, ElementActionEventArgs arg)
{
    Logger.LogInformation($"Click {arg.Element.ElementName}");
}
public void HoveringEventHandler(object sender, ElementActionEventArgs arg)
{
    Logger.LogInformation($"Hover {arg.Element.ElementName}");
}
```

These are two sample event handlers for the BELLATRIX button where we log messages before clicking and hovering a button.

[Learn more about Element Action Hooks](https://docs.bellatrix.solutions/desktop-automation/extensibility-element-action-hooks/)

## Common Services Action Hooks

## Common Services Action Hooks

#### Another way to extend BELLATRIX is to use hooks for its common services.

The base class for all web elements- Element provides a few special events as well:

-   **ScrollingToVisible** – called before scrolling
-   **ScrolledToVisible** – called after scrolling
-   **CreatingElement** – called before creating the element
-   **CreatedElement** – called after the creation of the element
-   **CreatingElements** – called before the creation of nested element
-   **CreatedElements** – called after the creation of nested element
-   **ReturningWrappedElement** – called before searching for a native WebDriver element

[Learn more about Common Services Action Hooks](https://docs.bellatrix.solutions/desktop-automation/extensibility-common-services-action-hooks/)

## Extend Existing UI Elements

## Extend Existing UI Elements

#### You have the ability to add new methods to existing BELLATRIX UI elements. You can add new methods in two ways.

### Extension Methods

One way to extend an existing element is to create an extension method for the additional action.

```
public static class ButtonExtensions
{
    public static void SubmitButtonWithEnter(this Button button)
    {
        var action = new Actions(button.WrappedDriver);
        action.MoveToElement(button.WrappedElement).SendKeys(Keys.Enter).Perform();
    }
}
```

To use the new method, add a using statement to the extension methods’ namespace.

```
proceedToCheckout.SubmitButtonWithEnter();
```

Click the “proceed to checkout” button via the Enter key instead of clicking on it.  
[Learn more about Extend Existing UI Elements](https://docs.bellatrix.solutions/desktop-automation/extensibility-extend-existing-elements-extension-methods/)

### Child Elements

The second way of extending an existing element is to create a child element. Inherit the UI control you want to extend.

```
public class ExtendedButton : Button
{
    public void SubmitButtonWithEnter()
    {
        var action = new Actions(WrappedDriver);
        action.MoveToElement(WrappedElement).SendKeys(Keys.Enter).Perform();
    }
}
```

Next in your tests, use the ExtendedButton instead of the regular Button to have access to these methods.

```
ExtendedButton proceedToCheckout = 
 App.ElementCreateService.CreateByName<ExtendedButton>("checkout-button");
```

[Learn more about Extend Existing UI Elements](https://docs.bellatrix.solutions/desktop-automation/extensibility-extend-existing-elements-child-elements/)

## Extend Common Services

## Extend Common Services

#### Ability to add a new method to BELLATRIX common services.

For example, a new way of login into your application. To extend the BELLATRIX common services you can create an extension method for the additional action.

```
public static class NavigationServiceExtensions
{
    public static void LoginToApp(this AppService appService, string userName, string password)
    {
        var elementCreateService = new ElementCreateService();
        var userNameField = elementCreateService.CreateByAutomationId<TextField>("textBox");
        var passwordField = elementCreateService.CreateByAutomationId<Password>("passwordBox");
        var loginButton = elementCreateService.CreateByName<Button>("loginButton");
        userNameField.SetText(userName);
        passwordField.SetPassword(password);
        loginButton.Click();
    }
}
```

To use the new method, add a using statement to the extension methods’ namespace.

```
App.AppService.LoginToApp("bellatrix", "topSecret");
```

[Learn more about Extend Common Services](https://docs.bellatrix.solutions/desktop-automation/extensibility-common-services-action-hooks/)

## Add New Find Locators

## Add New Find Locators

#### The ability to avoid code duplication and complex locate expressions by adding a custom find locators.

Here is a sample implementation of the locator for finding all elements ending with ID. First, we need to create the By locator.

```
public class ByIdEndingWith : By
{
    private const string XpathEndingWithExpression = "//*[ends-with(@id, '{0}')]";
    public ByIdEndingWith(string value)
        : base(value)
    {
    }
    public override WindowsElement FindElement(WindowsDriver<WindowsElement> searchContext)
        => searchContext.FindElementByXPath(string.Format(XpathEndingWithExpression, Value));
    public override IEnumerable<WindowsElement> FindAllElements(WindowsDriver<WindowsElement> searchContext)
        => searchContext.FindElementsByXPath(string.Format(XpathEndingWithExpression, Value));
    public override AppiumWebElement FindElement(WindowsElement element)
        => element.FindElementByXPath(string.Format(XpathEndingWithExpression, Value));
    public override IEnumerable<AppiumWebElement> FindAllElements(WindowsElement element)
        => element.FindElementsByXPath(string.Format(XpathEndingWithExpression, Value));
    public override string ToString() => $"By ID ending with = {Value}";
}
```

We override all available methods and use XPath expression for finding an element with ID ending with. To ease the usage of the locator, we need to create an extension method of ElementCreateService.

```
public static TElement CreateByIdEndingWith<TElement>(this Element element, string idPart)
    where TElement : Element
{
    element.Create<TElement, ByIdEndingWith>(new ByIdEndingWith(idPart));
}
```

This is everything after that you can use your new locator as it was originally part of BELLATRIX.  
[Learn more about Add New Find Locators](https://docs.bellatrix.solutions/desktop-automation/extensibility-add-new-find-locators/)

## Add New Element Wait Methods

## Add New Element Wait Methods

#### Ability to add your custom element wait logic.

Imagine that you want to wait for an element to have a specific content. First, create a new class and inherit the BaseUntil class.

```
public class UntilHasContent : BaseUntil
{
    private readonly string _elementStyle;
    public UntilHasContent(string elementStyle, int? timeoutInterval = null, int? sleepInterval = null)
        : base(timeoutInterval, sleepInterval)
    {
        _elementStyle = elementStyle;
    }
   public override void WaitUntil<TBy>(TBy by) => WaitUntil(ElementHasContent(WrappedWebDriver, by), TimeoutInterval, SleepInterval);
    private Func<IWebDriver, bool> ElementHasContent<TBy>(WindowsDriver<WindowsElement> searchContext, TBy by)
        where TBy : Locators.By => driver =>
    {
        try
        {
            var element = by.FindElement(searchContext);
            return !string.IsNullOrEmpty(element.Text);
        }
        catch (NoSuchElementException)
        {
            return false;
        }
        catch (InvalidOperationException)
        {
            return false;
        }
    };
}
```

The important part is located in the ElementHasContent function. There we find the element and check the current value in the Text attribute. The internal WaitUntil will wait until the value changes in the specified time. The next and final step is to create an extension method for all UI elements.

```
public static TElementType ToHasContent<TElementType>(this TElementType element, 
int? timeoutInterval = null, int? sleepInterval = null)
 where TElementType : Element
{
    var until = new UntilHaveContent(timeoutInterval, sleepInterval);
    element.EnsureState(until);
    return element;
}
```

After UntilHasContent is created, it is important to be passed on to the element’s EnsureState method. From now on, the method is available as it was originally part of the framework.

[Learn more about Add New Element Wait Methods](https://docs.bellatrix.solutions/desktop-automation/extensibility-add-new-element-wait-methods/)

---

# Troubleshooting Easiness (Desktop)

URL: https://bellatrix.solutions/features/desktop/troubleshooting-easiness/
Updated: 2021-11-29

## Screenshot on Test Failure

## Screenshot on Test Failure

#### BELLATRIX automatically creates a screenshot if the test fails.

One of the best ways to detect what was the cause of the test failure is to see a screenshot of the app at that moment.

```

[TestClass]
[App(Constants.WpfAppPath, Lifecycle.RestartEveryTime)]
public class AppScreenshotsOnFailTests : DesktopTest
{
    [TestMethod]
    public void MessageChanged_When_ButtonHovered_Wpf()
    {
        var button = App.ElementCreateService.CreateByName<Button>("button");
        button.Hover();
    }
}
```

If the test fails, a screenshot is saved in the location you specified in the configuration file.

[Learn more about Screenshot on Test Failure](https://docs.bellatrix.solutions/desktop-automation/troubleshooting-screenshots-on-fail/)

## Video on Test Failure

## Video on Test Failure

#### BELLATRIX automatically saves a video recording if the test fails.

Another great way to see what was the cause of test failure is to watch a video of the whole test execution.

```
[TestClass]
[App(Constants.WpfAppPath, Lifecycle.RestartEveryTime)]
public class VideoRecordingTests : DesktopTest
{
    [TestMethod]
    public void MessageChanged_When_ButtonHovered_Wpf()
    {
        var button = App.ElementCreateService.CreateByName<Button>("button");
        button.Hover();
    }
}
```

[Learn more about Video on Test Failure](https://docs.bellatrix.solutions/desktop-automation/troubleshooting-video-recording/)

## Measure Test Execution Times

## Measure Test Execution Times

Sometimes it is useful to use your functional tests to measure performance or just to make sure that your app is not slow. To do this, BELLATRIX libraries offer the ExecutionTimeUnder attribute whereby you specify a timeout. If the test is executed over it, the test fails.

```

[ExecutionTimeUnder(2)]
public class MeasuredResponseTimesTests : DesktopTest
```

[Learn more about Measure Test Execution Times](https://docs.bellatrix.solutions/desktop-automation/measure-test-execution-times/)

---

# Test Responsive Layouts (Desktop)

URL: https://bellatrix.solutions/features/desktop/test-responsive-layouts/
Updated: 2021-11-29

## 200+ Assertions Based on Coordinates

## 200+ Assertions Based on Coordinates

#### Layout testing always seemed like a complex task. BELLATRIX offers a simple solution- test the location of objects relative to each other.

BELLATRIX resizes your app. It then finds the elements and makes various calculations and assertions based on their coordinates and whether an element is above, below, left, right, etc. in relation to another one. BELLATRIX comes with 200+ layout assertion methods.

```
[App(Constants.WpfAppPath, AppBehavior.RestartEveryTime)]
public class LayoutTestingTests : DesktopTest
{
    [TestMethod]
    public void CommonActionsWithDesktopControls_Wpf()
    {
        var button = App.ElementCreateService.CreateByName<Button>("purchaseButton");
        var calendar = App.ElementCreateService.CreateByAutomationId<Calendar>("calendar");
        var selectedRadioButton = App.ElementCreateService.CreateByName<RadioButton>("selectedRadioButton");
        button.AssertAboveOf(calendar);
        saturnVAnchor.AssertNearBottomRightOf(sortDropDown);
        sortDropDown.AssertNearTopLeftOf(saturnVAnchor);
        LayoutAssert.AssertAlignedHorizontallyAll(button, bcalendar);
        
        LayoutAssert.AssertAlignedVerticallyLeft(radioButton, selectedRadioButton);
        button.AssertHeightLessThan(100);
        button.AssertWidthBetween(70, 80);
    }
}
```

Depending on what you want to check, BELLATRIX gives lots of options. You can test px perfect or just that some element is below another. Check that the purchase button is above the calendar.

```
button.AssertAboveOf(calendar);
```

Assert with the exact distance between them.

```
button.AssertAboveOf(calendar, 106);
```

For each available method, you have variations of it such as, >, >=, <, <=, between and approximate to some expected value by specified %.

```
button.AssertAboveOfGreaterThan(calendar, 100);
button.AssertAboveOfGreaterThanOrEqual(calendar, 106);
button.AssertAboveOfLessThan(calendar, 110);
button.AssertAboveOfLessThanOrEqual(calendar, 106);
```

The expected distance is ~105px with 10% tolerance.

```
button.AssertAboveOfApproximate(calendar, 105, percent: 10);
```

You can test whether different desktop elements are aligned correctly.

```
LayoutAssert.AssertAlignedHorizontallyAll(button, button1);
LayoutAssert.AssertAlignedHorizontallyCentered(protonRocketAnchor, protonMAnchor, saturnVAnchor);
LayoutAssert.AssertAlignedHorizontallyBottom(protonRocketAnchor, protonMAnchor, saturnVAnchor);
LayoutAssert.AssertAlignedVerticallyAll(falcon9Anchor, falconHeavyAnchor);
```

Verify the height and width of elements.

```
saturnVRating.AssertHeightLessThan(100);
saturnVRating.AssertWidthBetween(50, 70);
```

[Learn more about 200+ Assertions Based on Coordinates](https://docs.bellatrix.solutions/desktop-automation/layout-testing/)

## 15+ Predefined Resolutions

## 15+ Predefined Resolutions

#### BELLATRIX comes with 15+ of most often used resolution for desktop, mobile and tablet.

You can access them through DesktopWindowSize, MobileWindowSize and TabletWindowSize enumerations. Browser attribute gives you the option to resize your browser window so that you can test the rearrangement of the desktop elements on your screens.

### Desktop Testing

![desktop testing responsive](https://bellatrix.solutions/images/uploads/desktop.png)

```
[App(Constants.WpfAppPath, DesktopWindowSize._1280_1024,  AppBehavior.RestartEveryTime)]
```

### Mobile Testing

![mobile testing responsive](https://bellatrix.solutions/images/uploads/mobile.png)

```
[App(Constants.WpfAppPath, MobileWindowSize._360_640, AppBehavior.RestartEveryTime)]
```

### Tablet Testing

![tablet testing responsive](https://bellatrix.solutions/images/uploads/tablet.png)

```
[App(Constants.WpfAppPath, TabletWindowSize._600_1024,  AppBehavior.RestartEveryTime)]
```

[Learn more about 15+ Predefined Resolutions](https://docs.bellatrix.solutions/desktop-automation/layout-testing/)

## Custom Resolutions

## Custom Resolutions

#### If you cannot find the resolution you would like to test on, you can specify your own.

```
[App(Constants.WpfAppPath, width: 600, height: 900, behavior: AppBehavior.RestartEveryTime)]
```

[Learn more about Custom Resolutions](https://docs.bellatrix.solutions/desktop-automation/layout-testing/)

---

# Boost Test Reliability (Desktop)

URL: https://bellatrix.solutions/features/desktop/boost-test-reliability/
Updated: 2021-11-29

## Handle All Synchronization Issues

## Handle All Synchronization Issues

#### BELLATRIX performs elements actions seamlessly, handling timeouts automatically.

One of the biggest problems in test automation is handling timeouts and performing actions on elements which may not be on the screen right now. In the WebDriver world, you have to constantly worry about how to solve these problems with an implicit wait, explicit wait, or WebDriverWait class. BELLATRIX hides the whole complexity of searching and waiting for elements. When you perform an action or assertion against an element we guarantee that once returned is there.

## Lazy Loading of Elements

## Lazy Loading of Elements

#### Lazy loading means that BELLATRIX finds elements once you requested specific actions to be performed on the element.

In the time gap between selecting an element and finding it, the element’s state may change. That’s why we have an internal logic that locates elements upon request instead of when they are selected. This way, we prevent failing tests because the element state is different.

### WebDriver Example

```
var agreeCheckBox = driver.FindElementById("agreeChB"));
var confirmButton = driver.FindElementById("confirm"));
agreeCheckBox.Click();
confirmButton.Click();
```

The problem with vanilla WebDriver is that it finds the elements immediately. If you use the element later and its state was changed, an error occurs.  
In the above example, the first agree checkbox is found, and then the confirm button. You uncheck the checkbox and the state of the button is changed. Once you perform the button click, an error occurs.

### BELLATRIX Example

```
var agreeCheckBox = App.ElementCreateService.CreateById<CheckBox>("agreeChB");
var confirmButton = App.ElementCreateService.CreateById<Button>("confirm");
agreeCheckBox.Uncheck();
confirmButton.Click();
```

With BELLATRIX’s lazy loading, the checkbox is found during just before the unchecking. When you call the button click, then BELLATRIX searches for the button and it is returned with its updated state.

[Learn more about Lazy Loading of Elements](https://docs.bellatrix.solutions/desktop-automation/wait-for-elements/)

## Smart Wait Assertions

## Smart Wait Assertions

#### Additional methods which internally handle the whole complexity of waiting for some conditions to happen.

A major part of your tests are the assertions- actually checking whether some conditions are met. This might be checking whether some text is shown or whether some button has been disabled.  
However, this often doesn’t happen immediately. In the era where most things happen asynchronously.

In most cases, if you just call the following code snippet, your test will fail because the content box with the correct message might be displayed asynchronously.

```
Assert.AreEqual("Order Completed", successBox.Text);
```

To handle such scenarios, we created elements Validate methods. They internally handle the whole complexity of waiting for some condition to happen.

Waits for the message alert to get disabled.

```
updateCart.ValidateIsDisabled();
```

Wait for message alert to disappear.

```
messageAlert.ValidateIsNotVisible();
```

You can even fine-tune the timeouts.

```
totalContentBox.ValidateInnerTextIs("120.00€", timeout: 30, sleepInterval: 2);
```

For each specific element- button, content box, anchor, image, etc. only the relevant Validate methods are displayed.

![validate methods](https://bellatrix.solutions/images/uploads/ensure_methods.png)

Moreover, we hide the whole complexity of how the specific property is gotten, saving you tons of code and duplication.

[Learn more about Smart Wait Assertions](https://docs.bellatrix.solutions/desktop-automation/normal-assertions/)

---

# Human Readable Tests (Desktop)

URL: https://bellatrix.solutions/features/desktop/human-readable-tests/
Updated: 2021-11-29

## 18 UI Elements Ready to Use

## 18 UI Elements Ready to Use

#### Over 18 well-known desktop controls with actions and properties that are related to them.

Since WebDriver is not a test framework, it is written in most generic manner. All desktop elements share a common WindowsElement base class- containing the same methods and properties. For example- you use SendKeys method to type text in the text field, to click a button using Enter key or upload a file. Or why do you need Click method for content box or text field?

### WebDriver Example

```
WindowsElement agreeCheckBox = driver.FindElementById("agreeChB"));
agreeCheckBox.Click();
WindowsElement firstNameTextField = driver.FindElementById("firstName"));
firstNameTextField.SendKeys("John");
WindowsElement avatarUpload = driver.FindElementById("uploadAvatar"));
avatarUpload.SendKeys("pathTo\myAvatar.jpg");
WindowsElement saveBtn = driver.FindElementById("saveBtn"));
agreeCheckBox.SendKeys(Keys.Enter);
```

One more thing, if you don’t use suffixes in the names of your variables or properties, you won’t know what type of elements they are. In the case that you want to perform specific verifications, this might be important. BELLATRIX offers 18 strongly-typed desktop controls such as: combobox, button, text field, checkbox, etc. Each specific control contains well-named actions and properties that are related to it.

### BELLATRIX Example

```
CheckBox agreeCheckBox = App.ElementCreateService.CreateById<CheckBox>("agreeChB");
agreeCheckBox.Check();
TextField firstNameTextField = App.ElementCreateService.CreateById<TextField>("firstName");
firstNameTextField.SetText("John");
var comboBox = App.ElementCreateService.CreateByAutomationId<ComboBox>("select");
comboBox.SelectByText("Item2");
Button saveBtn = App.ElementCreateService.CreateById<Button>("saveBtn");
saveBtn.ClickByEnter();
```

While reading the code, you can quickly find out the type of the elements since it is the first thing you see. Moreover, the specific action methods and properties make the code more self-explanatory.

[Learn more about 18 UI Elements Ready to Use](https://docs.bellatrix.solutions/desktop-automation/common-components/)

## Hide Low-level Details with Page Objects

## Hide Low-level Details with Page Objects

#### Page objects are classes that group elements, actions, and assertions that are related to a specific screen.

### Page objects benefits:

-   Reuse elements locators
-   Fix elements locators in a single place
-   Combine elements in use case methods
-   Hide low-level API details- such as waiting for elements
-   Reuse assertion exception messages

BELLATRIX comes with enhanced built-in page objects. Each page object can be spread among three files. Each file holds a specific group of methods and properties. We can have one for actions, one for declaring elements, and one more for assertions. This speeds up test development and maintenance, since you can find different parts of the page object more quickly. For example, if you need to fix the element locator, you open the Page.Elements file.

Page objects significantly improve the test’s readability. This is because their actions and assertion methods can have names which are more relatable to your business domain.

### BELLATRIX Example

```
var homePage = App.GoTo<HomePage>();
homePage.FilterProducts(ProductFilter.Popularity);
homePage.AddProductById(28);
homePage.ViewCartButton.Click();
var cartPage = App.Create<CartPage>();
cartPage.ApplyCoupon("happybirthday");
cartPage.UpdateProductQuantity(1, 2);
cartPage.AssertTotalPrice("95.00");
cartPage.ProceedToCheckout.Click();
```

[Learn more about Hide Low-level Details with Page Objects](https://docs.bellatrix.solutions/desktop-automation/page-objects/)

---

# Easy Knowledge Transfer (Desktop)

URL: https://bellatrix.solutions/features/desktop/easy-knowledge-transfer/
Updated: 2021-11-29

## Starter Kits

## Starter Kits

#### The starter kit provides you with everything that your new members need to onboard themselves by themselves.

![Starter Kits](https://bellatrix.solutions/images/uploads/Starter_kits-1.png)

A frequent problem teams face is helping/teaching new members how to write “proper” tests using the team’s framework. Usually, one of most senior people spends countless hours on this process. Starter kits are an automated way allowing new people to learn by themselves. These are projects that have examples with explanations on how to write tests and why we use a particular method or not.

For each test technology, we created a similar starter kit for BELLATRIX. Each of them explains the features of the framework with detailed real-world examples. Moreover, they also contain detailed comments for each part. After each chapter, they offer exercises that people can do, and this makes it ideal for self-learning. Different features are grouped in separate folders, and at the end of each chapter, there is a TODO file containing the exercises.

[Learn more about Starter Kits](https://docs.bellatrix.solutions/general-information/how-to-use-starter-kits/)

## Rich Documentation

## Rich Documentation

#### Find out how every feature works.

Each BELLATRIX feature is explained with lots of examples and explanations in our documentation. You can find the various use cases of each API, as well as find out how to customize it through configurations or extend it. Even the most complicated parts of the framework are fully documented- how to write new plugins or controls, for instance.

[Learn more about Rich Documentation](https://docs.bellatrix.solutions/overview/)

---

# Unified Team Conventions (Desktop)

URL: https://bellatrix.solutions/features/desktop/unified-team-conventions/
Updated: 2021-11-29

## Enforce Coding Standards and Naming Conventions

## Enforce Coding Standards and Naming Conventions

#### BELLATRIX comes with two static analysis modules for applying coding standards.

Coding standards define a programming style. A coding standard does not usually concern itself with wrong or right in a more abstract sense. It is merely a set of rules and guidelines for the formatting of source code.

### Benefits:

-   **Seamless code integration**
-   **Team member integration**
-   **Easy to debug and maintain**
-   **Readability**
-   **Minimizes communication**
-   **Minimizes performance pitfalls**
-   **Saves money due to fewer man hours**

BELLATRIX comes with two modules for helping you apply coding standards in your tests- .editorconfig and StyleCop. The EditorConfig project consists of a file format for defining coding styles and a collection of text editor plugins that enable editors to read the file format and adhere to defined styles. StyleCop is an open source static code analysis tool from Microsoft which checks C# code for conformance to StyleCop’s recommended coding styles, a subset of Microsoft’s .NET Framework Design Guidelines.

Static analysis integrates with all versions of Visual Studio. It contains a set of style and consistency rules. The code is checked on a build. If some of the rules are violated, warning messages are displayed. This way, you can quickly locate the problems and fix them.

![StyleCope](https://bellatrix.solutions/images/uploads/StyleCope.png)

All BELLATRIX projects come with predefined StyleCop and .editorconfig rules. In the files, you can enable and disable particular rules and configure the severity of violations reported by individual rules.

![StyleCope](https://bellatrix.solutions/images/uploads/StyleCope_2.png)  
[Learn more about Enforce Coding Standards and Naming Conventions](https://docs.bellatrix.solutions/desktop-automation/static-analysis/)

## Structured Code Using Page Object Templates

## Structured Code Using Page Object Templates

#### Item templates for generating standardized page objects.

Page objects as any design pattern can be created in various ways and can easily pollute your code if you don’t have a way to enforce all engineers to write them in a unified way. This is done in case each page object is created in a different way – such as one in a single file and another with partial classes or navigation properties – as this can make your code harder to navigate, read, and maintain.

To solve this problem, BELLATRIX comes with standardized Page Object Item Templates.

![Project templates](https://bellatrix.solutions/images/uploads/Templates.png)

### Choose one of the 2 desktop page object templates

-   **Bellatrix-AssertedDesktopPage** – contains 3 files- one for actions, one for element declarations and one for assertions (all of them make single page object)
-   **Bellatrix-DesktopPage** – one for actions and one for elements (all of them make single page object), they don’t have methods for navigation

![install templates](https://bellatrix.solutions/images/uploads/template_2.png)

The files are generated automatically. This way, all page objects have the same structure, parent classes, properties, usages, etc.  
[Learn more about Structured Code Using Page Object Templates](https://docs.bellatrix.solutions/desktop-automation/page-objects/)

---

# API Test Automation Features

URL: https://bellatrix.solutions/features/api/
Updated: 2020-08-03

Better API discoverability and ready-to-go solution. BELLATIRX open-source test framework support authentication strategies and retry failed requests.

- [Accelerate Test Creation](https://bellatrix.solutions/features/api/accelerate-test-creation/): Speed up your API test creation by providing predefined response assertions, default authentication modules, JSON, and XML schema validations and templates.
- [Accelerate Test Execution](https://bellatrix.solutions/features/api/accelerate-test-execution-api/): Speed up API test execution with BELLATRIX: retry failed requests automatically and run tests in parallel, so flaky endpoints stop slowing down your CI.
- [Extend The Framework to Fit Your Needs](https://bellatrix.solutions/features/api/extend-the-framework-to-fit-your-needs/): BELLATRIX open-source test framework has provided you with a wider test execution life cycle with the ability to plug-in everywhere. For API test automation.
- [Easy Knowledge Transfer](https://bellatrix.solutions/features/api/easy-knowledge-transfer/): Everything that your team needs to know about BELLATRIX open-source test framework, from installation to the most complex features. For API test automation.
- [Test API Performance](https://bellatrix.solutions/features/api/test-api-performance/): BELLATRIX open-source test framework ability to set a timeout for test execution and a module for load testing help you to measure your API performance.
- [Human Readable Tests](https://bellatrix.solutions/features/api/human-readable-tests/): BELLATRIX open-source test framework can generate test cases that are understandable for non-technical people and Improve your test’s readability.
- [Unified Team Conventions](https://bellatrix.solutions/features/api/unified-team-conventions/): BELLATRIX open-source test framework comes with two static analysis modules to apply coding standards and item templates for generating page objects.

---

# Accelerate Test Creation (API)

URL: https://bellatrix.solutions/features/api/accelerate-test-creation/
Updated: 2021-11-29

## Predefined Response Assertions

## Predefined Response Assertions

#### The BELLATRIX API library brings many convenient assertion methods on top of RestSharp.

Of course, you can write similar methods yourself using MSTest or NUnit. All BELLATRIX assertions come with full BDD logging and extensibility hooks. We save you lots of time on writing all of these methods yourself.  
Assert that the status code is successful.

```
response.AssertSuccessStatusCode();
```

Assert that the header named ‘server’ has the value ‘Kestrel’.

```
response.AssertResponseHeader("server", "Kestrel");
```

Assert that the native text content (JSON or XML) contains the specified value.

```
response.AssertContentContains("Metallica");
```

Assert the response content encoding.

```
response.AssertContentEncoding("gzip");
```

Assert C# collections directly.

```
response.AssertResultEquals(expectedAlbums);
```

Assert that a specific cookie exists.

```
response.AssertCookieExists("whoIs");
```

[Learn more about Predefined Response Assertions](https://docs.bellatrix.solutions/api-automation/assertions/)

## 6+ Authentication Strategies

## 6+ Authentication Strategies

#### To save you even more time, BELLATRIX comes with 6 default authentication modules.

You need to place the authentications strategy attribute over the test class and configure it. We use JwtToken authentication. The attribute accepts your text token.

```
[TestClass]
[JwtAuthenticationStrategy(GlobalConstants.JwtToken)]
public class AuthenticationTests : APITest
{
    [TestMethod]
    public void GetAlbumById()
    {
        var request = new RestRequest("api/Albums/10");
        var client = App.GetApiClientService();
        var response = client.Get<Albums>(request);
        Assert.AreEqual(10, response.Data.AlbumId);
    }
}
```

### Other authentication strategy attributes:

-   **HttpBasicAuthenticationStrategy** – user and password.
-   **NtlmAuthenticationStrategy** – authenticate with the credentials of the currently logged in user, or impersonate a user.
-   **OAuth2AuthorizationRequestHeaderAuthenticationStrategy** – OAuth 2 authenticator using the authorization request header field.
-   **OAuth2UriQueryParameterAuthenticationStrategy** – OAuth 2 authenticator using URI query parameter.
-   **SimpleAuthenticationStrategy** – userKey, user, passwordKey, password.

[Learn more about 6+ Authentication Strategies](https://docs.bellatrix.solutions/api-automation/authentication/)

## Validate JSON and XML Schemas

## Validate JSON and XML Schemas

#### You can easily validate whether or not your API’s schema stays valid over time with BELLATRIX.

We support XML and JSON schema validation.

```

var expectedSchema = @"{
    ""definitions"": {},
    ""$schema"": ""http://json-schema.org/draft-07/schema#"",
    ""$id"": ""http://example.com/root.json"",
    ""type"": ""object"",
    ""title"": ""The Root Schema"",
    ""required"": [
    ""albumId"",
    ""title"",
    ""artistId"",
    ""artist"",
    ""tracks""
    ]
}";
            
response.AssertSchema(expectedSchema);
```

[Learn more about Validate JSON and XML Schemas](https://docs.bellatrix.solutions/api-automation/validate-json-and-xml-schema/)

---

# Accelerate Test Execution (API)

URL: https://bellatrix.solutions/features/api/accelerate-test-execution-api/
Updated: 2021-11-29

## Retry Failed Requests

## Retry Failed Requests

#### Retry the failed requests a few times to make sure that there is a real problem.

There are cases where your API is deployed or unavailable for some reason. This can lead to failing some of the currently-executing tests. Instead of waiting just to see that there is a minor problem with your test environment and retrying the whole test run again, BELLATRIX can retry the failed requests a few times.

```
[RetryFailedRequests(3, 200, TimeUnit.Milliseconds)]
public class RetryFailedRequestsTests : APITest
{
    [TestMethod]
    public void GetAlbumById()
    {
        var request = new RestRequest("api/Albums/10");
        var client = App.GetApiClientService();
        var response = client.Get<Albums>(request);
        Assert.AreEqual(10, response.Data.AlbumId);
    }
}
```

Apply RetryFailedRequests attribute to your test class and configure it. The rules apply to all tests in the class.  
[Learn more about Retry Failed Requests](https://docs.bellatrix.solutions/api-automation/retry-failed-requests/)

---

# Extend The Framework to Fit Your Needs (API)

URL: https://bellatrix.solutions/features/api/extend-the-framework-to-fit-your-needs/
Updated: 2021-11-29

## Extended Test Execution Life Cycle and Plugins

## Extended Test Execution Life Cycle and Plugins

#### Have a full control over your test execution

All test frameworks give you the possibility to execute logic at certain points before or after tests. Typically tests are placed inside test classes. The standard test workflow for MSTest and NUnit is:

1\. **Execute Assembly Initialize** – once for the whole project  
2\. **Execute Class Initialize** – once for the test class  
3\. **Execute Test Initialize** – executed before each test  
4\. **Execute Test**  
5\. **Execute Test Cleanup** – executed after each test  
6\. **Execute Class Cleanup** – once for the test class  
7\. **Execute Assembly Cleanup** – once for the whole project

### Why do you need to extend the standard workflow?

Usually, you want to use these primary methods to execute business test-related logic. Sample use cases:

-   Fail tests if not executed under certain time
-   Log test results in a 3rd party system
-   Control requests life cycle

To meet these requirements and allow you to write custom plugins, BELLATRIX comes with extended test execution life cycle. When you write a plugin, you can execute logic in various phases of the new life cycle- before TestInitialize, after TestInitialize, before TestCleanup, after TestCleanup and more.  
For each test all registered plugins logic is executed. You can easily write your custom plugins. See how it is done. In BELLATRIX we have a feature called “execution time under”. You specify for the test class what is the maximal allowed test execution time if some of the tests takes longer to run- it fails automatically. This is done through test workflow plugin.

This is how we specify the maximal allowed time.

```
 [ExecutionTimeUnder(2)]
 public class MeasuredResponseTimesTests : APITest
```

This is part of the plugin.

```
public class ExecutionTimeUnderTestWorkflowPlugin : TestWorkflowPlugin
{
    protected override void PostTestInit(object sender, TestWorkflowPluginEventArgs e)
    {
        // get the start time
    }
    protected override void PostTestCleanup(object sender, TestWorkflowPluginEventArgs e)
    {
        // total time = start time - current time
        // IF total time > specified time ===> FAIL TEST
    }
}
```

In PostTestInit we start a stopwatch. We get the number placed inside the attribute in the PostTestCleanup method. Then stop the stopwatch and compare the actual and specified times. In case first took longer we fail the test.

## API Client Hooks

## API Client Hooks

#### Ability to execute logic between requests by creating an API client plugin.

You can execute your logic in various points, such as:

-   **OnClientInitialized** – executed after the API client is initialized. Here you can fine-tune the client.
-   **OnRequestTimeout** – executed if some of the requests time out.
-   **OnMakingRequest** – executed before making a request.
-   **OnRequestMade** – executed after the request is made.
-   **OnRequestFailed** – executed in case of request failure.

To create a custom plugin, you need to derive the class- ApiClientExecutionPlugin. Then you can override some of its protected methods. You can create plugins for logging the request failures or modifying the requests. The possibilities are limitless.

Here is an example of a plugin that measures the request’s execution time.

```
public class LogRequestTimeApiClientExecutionPlugin : ApiClientExecutionPlugin
{
    private Stopwatch _requestStopwatch = Stopwatch.StartNew();
    protected override void OnMakingRequest(object sender, RequestEventArgs client)
    {
	_requestStopwatch = Stopwatch.StartNew();
    }
    protected override void OnRequestMade(object sender, ResponseEventArgs client)
    {
        _requestStopwatch.Stop();
        Console.WriteLine($"Request made for {_requestStopwatch.ElapsedMilliseconds}");
    }
}
```

The OnMakingRequest method is called before executing the request. There we start the stopwatch. After the request is completed, we stop the stopwatch and print the time taken.

[Learn more about API Client Hooks](https://docs.bellatrix.solutions/api-automation/extensibility-api-client-hooks/)

## Assertion Hooks

## Assertion Hooks

#### Another way to extend BELLATRIX is to use assertions hooks.

Some of the available hooks are:

-   **AssertExecutionTimeUnderEvent** – an event executed before AssertExecutionTimeUnder method
-   **AssertContentContainsEvent** – an event executed before AssertContentContains method
-   **AssertContentTypeEvent** – an event executed before AssertContentType method

You need to implement the event handlers for these events and subscribe to them. You can call external logging provider, modify the response, etc.

```
public override void AssertContentContainsEventHandler(object sender, ApiAssertEventArgs arg)
{
    Debug.WriteLine($"Assert response content contains {arg.ActionValue}.");
}
public override void AssertContentEncodingEventHandler(object sender, ApiAssertEventArgs arg)
{
    Debug.WriteLine($"Assert response content encoding is equal to {arg.ActionValue}.");
}
```

In the example, Debug.WriteLine is called for each assertion event handler, printing to debug window what the method is verifying.

[Learn more about Assertion Hooks](https://docs.bellatrix.solutions/api-automation/extensibility-assertion-hooks/)

---

# Easy Knowledge Transfer (API)

URL: https://bellatrix.solutions/features/api/easy-knowledge-transfer/
Updated: 2021-11-29

## Starter Kits

## Starter Kits

#### The starter kit provides you with everything that your new members need to onboard themselves by themselves.

![Starter Kits](https://bellatrix.solutions/images/uploads/Starter_kits-2.png)

A frequent problem teams face is helping/teaching new members how to write “proper” tests using the team’s framework. Usually, one of most senior people spends countless hours on this process. Starter kits are an automated way allowing new people to learn by themselves. These are projects that have examples with explanations on how to write tests and why we use a particular method or not.

For each test technology, we created a similar starter kit for BELLATRIX. Each of them explains the features of the framework with detailed real-world examples. Moreover, they also contain detailed comments for each part. After each chapter, they offer exercises that people can do, and this makes it ideal for self-learning. Different features are grouped in separate folders, and at the end of each chapter, there is a TODO file containing the exercises.

[Learn more about Starter Kits](https://docs.bellatrix.solutions/general-information/how-to-use-starter-kits/)

## Rich Documentation

## Rich Documentation

#### Find out how every feature works.

Each BELLATRIX feature is explained with lots of examples and explanations in our documentation. You can find the various use cases of each API, as well as find out how to customize it through configurations or extend it. Even the most complicated parts of the framework are fully documented- how to write new plugins or controls, for instance.

[Learn more about Rich Documentation](https://docs.bellatrix.solutions/overview/)

---

# Test API Performance (API)

URL: https://bellatrix.solutions/features/api/test-api-performance/
Updated: 2021-11-29

## Load Testing

## Load Testing

#### BELLATRIX has a module which enables two types of load testing.

Load testing is a kind of performance testing which determines a system’s performance under real-life load conditions. This testing helps to determine how the application behaves when multiple users access it simultaneously. This testing usually identifies the maximum operating capacity of an application. BELLATRIX offers a module for making load tests. The first type of load test is time-based. 10 parallel processes run for 30 seconds, and the engine makes a pause of 1 sec between requests. As an anonymous method or existing method, you can specify the code to be executed in each process.

### Time-Based Example

```
App.LoadTestService.ExecuteForTime(
    numberOfProcesses: 10,
    pauseBetweenStartSeconds: 1,
    secondsToBeExecuted: 30,
    testBody: () =>
{
    var response = _apiClientService.Get(request);
    response.AssertSuccessStatusCode();
    response.AssertExecutionTimeUnder(1);
});
```

### Number-of-Times-Based Example

The second type of load test is number-of-times-based. Your code executes the specified number of times between the specified number of processes.

```
App.LoadTestService.ExecuteNumberOfTimes(5, 1, 5, () =>
{
    var response = _apiClientService.Get(request);
    response.AssertSuccessStatusCode();
    response.AssertExecutionTimeUnder(1);
});
```

[Learn more about Load Testing](https://docs.bellatrix.solutions/api-automation/load-testing/)

## Measure Test Execution Times

## Measure Test Execution Times

#### Fail test if it exceeds a specified timeout

Sometimes it is useful to use your functional tests in order to measure performance or perhaps to just make sure that your app is not slow. To do that, Bellatrix libraries offer the ExecutionTimeUnder attribute whereby you specify a timeout. If the test is executed over it, the test fails.

```
[ExecutionTimeUnder(2)]
public class MeasuredResponseTimesTests : APITest
```

Another way to measure performance is to use the AssertExecutionTimeUnder method. If the request takes longer to execute, the test fails again.

```
response.AssertExecutionTimeUnder(2);
```

[Learn more about Measure Test Execution Times](https://docs.bellatrix.solutions/api-automation/measure-response-times/)

---

# Human Readable Tests (API)

URL: https://bellatrix.solutions/features/api/human-readable-tests/
Updated: 2021-11-29

## 10+ Supported Request Types

## 10+ Supported Request Types

#### Request types which you can use directly with C# instead of working with JSON and XML.

Testing APIs can get quite complicated and unreadable if we keep lots of JSON and XML in our tests. BELLATRIX comes with 10 default request types which you can use directly with C# objects instead of JSON or XML. Moreover, the BELLATRIX API testing syntax makes reading and understanding the tests easier.  
Making GET request and return a C# response object.

```
var request = new RestRequest("api/Albums/10");
var response = _apiClientService.Get<Albums>(request);
```

Change the title and create a PUT request.

```
var putRequest = new RestRequest("api/Albums/11");
getResponse.Data.Title = Guid.NewGuid().ToString();
putRequest.AddJsonBody(getResponse.Data);
_apiClientService.Put<Albums>(putRequest);
```

Create a new album. Create a POST request and add the new object as a JSON body.

```
var newAlbum = CreateUniqueGeneres();
var request = new RestRequest("api/Genres");
request.AddJsonBody(newAlbum);
var response = _apiClientService.Post(request);
```

Delete an existing artist.

```
var deleteRequest = new RestRequest($"api/Artists/{newArtist.ArtistId}");
var response = _apiClientService.Delete(deleteRequest);
```

All BELLATRIX client API methods have an async version. Your test should be marked as async and you should use the await operator.

```
var deleteRequest = new RestRequest($"api/Artists/{newArtist.ArtistId}");
var response = await _apiClientService.DeleteAsync<Artists>(deleteRequest);
```

[Learn more about 10+ Supported Request Types](https://docs.bellatrix.solutions/api-automation/all-request-types/)

## Responses as C# Objects

## Responses as C# Objects

#### Automatically convert any XML or JSON response to a predefined C# object.

Making requests is not enough to test APIs. You also need to make validations of the responses. They are returned natively as JSON or XML. Some test frameworks are hard to use or read because they tend to use JSON and XML directly. The tests are polluted with low-level logic for converting text to language types such as boolean or numbers.

**RestAssured Example Java**

```
given().when().get("/garage").then()
       .body("name",equalTo("Acme garage"))
       .body("info.slots",equalTo(150))
       .body("info.status",equalTo("open"))
       .statusCode(200);
```

The problem is that if the fields like “name”, “info.slots” or “info.status” change, your tests will start to fail. Moreover, you have to hard-code these values in each test and know them beforehand.

To solve these problems, BELLATRIX automatically converts any XML or JSON response to a predefined C# object. If there is a change in the response schema, you will see a meaningful error explanation and need to fix everything in one place.

**BELLATRIX Example**

```
var getUpdatedResponse = _apiClientService.Get<Albums>(request);
Assert.AreEqual(updatedTitle, getUpdatedResponse.Data.Title);
```

After the GET request, you can directly work with the Albums object. Of course, you can still access the original XML or JSON response body. The tests readability is further improved when you need to create or update objects. Instead of building yourself the JSON or all of the fields, you can do it directly by initializing the C# object.

**RestAssured Example Java**

```
JSONObject requestParams = new JSONObject();
requestParams.put("AlbumId", 23);
requestParams.put("Title", "Open Your Eyes");
requestParams.put("ArtistId", 26);
requestParams.put("ArtistName", "Guano Apes");
requestParams.put("AlbumName",  "Proud Like a God");
request.body(requestParams.toJSONString());
Response response = request.post("api/Albums");
```

**BELLATRIX Example**

```
var newAlbum = new Albums
{ 
    Artist = guanoApesArtist,
    Title = "Open Your Eyes",
    Tracks = new List<Tracks>() { openYourEyesTrack },
};
var postRequest = new RestRequest("api/Albums");
postRequest.AddBody(newAlbum);
var response = _apiClientService.Get<Albums>(request);
```

We work with C# objects and there are no hard-coded, copy-pasted strings.  
[Learn more about Responses as C# Objects](https://docs.bellatrix.solutions/api-automation/all-request-types/)

---

# Unified Team Conventions (API)

URL: https://bellatrix.solutions/features/api/unified-team-conventions/
Updated: 2021-11-29

## Enforce Coding Standards and Naming Conventions

## Enforce Coding Standards and Naming Conventions

#### BELLATRIX comes with two static analysis modules for applying coding standards.

Coding standards define a programming style. A coding standard does not usually concern itself with wrong or right in a more abstract sense. It is merely a set of rules and guidelines for the formatting of source code.

### Benefits:

-   **Seamless code integration**
-   **Team member integration**
-   **Easy to debug and maintain**
-   **Readability**
-   **Minimizes communication**
-   **Minimizes performance pitfalls**
-   **Saves money due to fewer man hours**

BELLATRIX comes with two modules for helping you apply coding standards in your tests- .editorconfig and StyleCop.

The EditorConfig project consists of a file format for defining coding styles and a collection of text editor plugins that enable editors to read the file format and adhere to defined styles. StyleCop is an open source static code analysis tool from Microsoft which checks C# code for conformance to StyleCop’s recommended coding styles, a subset of Microsoft’s .NET Framework Design Guidelines. Static analysis integrates with all versions of Visual Studio. It contains a set of style and consistency rules. The code is checked on a build. If some of the rules are violated, warning messages are displayed. This way, you can quickly locate the problems and fix them.

![StyleCope](https://bellatrix.solutions/images/uploads/StyleCope.png)

All BELLATRIX projects come with predefined StyleCop and .editorconfig rules. In the files, you can enable and disable particular rules and configure the severity of violations reported by individual rules.

![StyleCope](https://bellatrix.solutions/images/uploads/StyleCope_2.png)

[Learn more about Enforce Coding Standards and Naming Conventions](https://docs.bellatrix.solutions/api-automation/static-analysis/)

---

# Release 4.5.0.0 (Altairius)

URL: https://bellatrix.solutions/roadmap/release-4-5-0-0-altairius/
Updated: 2025-07-11

**The new release brings not only bug fixes but also significant enhancements,**

**most notably the new AI-powered test automation augmentation features.**

## What’s New?

-   Add new logic for web, desktop, Android, iOS, Playwright to find elements by prompt
-   Add new logic for AssertByPrompt and ValidateByPrompt
-   Add new logic for native self-healing via LLM for all technologies
-   Add new smart AI analysis via LLM
-   Upgrade all NuGet packages
-   Update license headers
-   Implement new full page screenshots in Selenium Web
-   Refactor obsolete methods after upgrade of 3rd party nugets

---

# Release 4.0.0.0 (Pleione)

URL: https://bellatrix.solutions/roadmap/release-4-0-0-0-pleione/
Updated: 2024-07-16

**The new release brings not only bug fixes but even more enhancements.  
The most prominent is email services integration.**

## What’s New?

-   New web automation module – **Playwright**!
-   Upgrade All NuGet Packages

---

# Release 3.9.0.0 (Lyra)

URL: https://bellatrix.solutions/roadmap/release-3-9-0-0-lyra/
Updated: 2024-02-29

**The new release brings not only bug fixes but even more enhancements.  
The most prominent is email services integration.**

## What’s New?

-   Added Advanced CkEditor component
-   Added DevExtreme Components v.1.0
-   .NET 8 Support
-   Selenium Manager Support
-   Upgrade All NuGet Packages
-   Chrome Headless uses the new headless mode now
-   Fixed grid execution driver additional options to Selenium 4
-   Added SetModelColumns method to grid extensions

---

# Release 3.8.0.0 (Vela)

URL: https://bellatrix.solutions/roadmap/release-3-8-0-0-vela/
Updated: 2024-02-29

**The new release brings not only bug fixes but even more enhancements.  
The most prominent is email services integration.**

## What’s New?

-   .NET 7 Support
-   Added DevExtreme Components v1.2.0
-   Fixed parallel execution
-   Added Excel Service
-   Fixed formatting
-   Added qTestId plugin
-   Upgraded Azure KeyVault Identity
-   Upgraded WebDriver Manager Version

---

# Release 3.6.0.0 (Chamaeleon)

URL: https://bellatrix.solutions/roadmap/release-3-6-0-0-chamaeleon/
Updated: 2022-08-12

**The new release brings not only bug fixes but even more enhancements.  
The most prominent is email services integration.**

## What’s New?

-   new email testing 3rd-party services integrations
-   new AWS integration – S3
-   new AWS integration – Computer Vision OCR images and PDFs
-   new AWS integration – Secrets Manager
-   convert to file-scoped namespaces
-   update demo apps
-   add new CSV service for working with CSV files
-   deprecate touch web services
-   update API libraries
-   upgrade all 3rd-party NuGet packages
-   fix all known bugs

---

# Release 3.5.0.0 (Dorado)

URL: https://bellatrix.solutions/roadmap/release-3-5-0-0-dorado/
Updated: 2022-08-12

**The new release brings not only bug fixes but even more enhancements.  
The most prominent is upgrade to .NET 6 and C# 10.0 + Selenium 4.0**

## What’s New

-   add support to Selenium 4
-   upgrade to .NET 6
-   enhanced support for C# 10.0
-   add new high-quality analyzers from .NET 6
-   deprecate StyleCop analyzers
-   remove deprecated App properties
-   delete obsolete web tests
-   fix Edge initialization with Selenium 4
-   fix Firefox initialization with Selenium 4
-   new advanced SauceLabs integration
-   new email testing feature
-   enhancements of web Table and Grid controls
-   new file utilities and assertions
-   upgrade all 3rd-party NuGet packages
-   fix all known bugs

---

# Release 3.3.0.0 (Aries)

URL: https://bellatrix.solutions/roadmap/release-3-3-0-0-aries/
Updated: 2022-08-12

**The new release brings not only bug fixes but even more enhancements.**

**The most prominent is a new email verification service.**

## What’s New

-   add Lambda Test cloud integration
-   add new JavaScript errors verification plugin
-   add new Azure blob storage integration
-   add email verification service
-   upgrade WebDriver to new 4 version RC1
-   upgrade all 3rd-party NuGet packages

---

# Release 3.1.0.0 (Gemini)

URL: https://bellatrix.solutions/roadmap/release-3-1-0-0-gemini/
Updated: 2021-10-04

#### The new release brings not only bug fixes but even more enhancements.  
The most prominent is one of the most advanced testing integrations with Google Lighthouse.

## What’s New

-   Add new Lighthouse validation library
-   Add new ApiClient support to BELLATRIX.Web
-   Add new Process utilities
-   Update all 3rd-party NuGets

---

# Release 3.0.0.0 (Perseus)

URL: https://bellatrix.solutions/roadmap/release-3-0-0-0-perseus/
Updated: 2021-10-04

#### The new release brings not only bug fixes but even more enhancements.  
The most prominent ones are- Azure KeyVault integration and new cognitive service support for validation text in PDFs and images. Simplification of settings and controlling apps and browsers. Simplified usage of page objects. Run the same test in multiple browsers using the NUnit TestCase attribute. + Many more!

## What’s New

-   Add default grid and browser settings without attribute for web
-   Add additional web timeout settings
-   Add additional desktop timeout settings
-   Add additional Android timeout settings
-   Add additional iOS timeout settings
-   Add new Azure KeyVault integration of storing secrets
-   Add support for the usage of TestCase attribute for running the same test under multiple browsers NUnit
-   Add by default Azure, QTest dynamic test cases plugins
-   Add by default Azure, Jira bug plugins
-   Add by default Allure and Report Portal plugins
-   Add new TakeScreenshot method to all components
-   Add a new method for AI analysis of component
-   Add global troubleshooting settings, and e.PrintStackTrace() method
-   Add a new utility class for downloading files
-   Add a new web utility class for resolving URLs based on the environment UrlDeterminer
-   Deprecate video recorder NuGet package, download it on demand
-   Add new cognitive service support for validation text in PDFs and Images
-   Add new WebPage page objects base class, mark the old 4 base classes as Obsolete
-   Simplify web settings
-   Simplify desktop settings
-   Simplify Android settings
-   Simplify iOS settings
-   Refactor Page Objects to have unified access to App instead of using services directly
-   Refactor App services’ properties to have shorter names
-   Refactor Page Objects naming convention
-   Fix known bugs in video recording and screenshots on failure
-   Fix restart problem in mobile and desktop execution plugins
-   Fix known bugs in dynamic test cases for Azure
-   Fix proper initializations of plugins when running tests in parallel
-   Fix logging of messages when running tests in parallel
-   Fix WebDriverManager initialization of browsers
-   Update WinAppDriver to latest stable 1.0.1
-   Update Appium to latest stable 4.3.1
-   Update all 3rd-party NuGets

---

# Release 2.3.0.0 (Centauri)

URL: https://bellatrix.solutions/roadmap/release-2-3-0-0-centauri/
Updated: 2021-05-27

#### The new release brings not only bug fixes but even more enhancements.  
The most prominent ones are automatic updating of all browser drivers, simplified solution/project structure, and combining of MSTest and NUnit pre-configured projects

## What’s New

-   Deprecate SpecFlow projects
-   Deprecate load testing projects
-   Deprecate machine automation projects
-   Deprecate BELLATRIX browser driver packages, use WebDriverManager.NET instead
-   Create a simplified project structure
-   Simplify project templates
-   Refactor BELLATRIX plugins- easier usage
-   Simplify usage of screenshots and videos on failure
-   Merge NUnit and MSTest project templates for easier usage
-   Merge Android and IOS project templates for easier usage

---

# Release 2.2.0.0 (Canopus)

URL: https://bellatrix.solutions/roadmap/release-2-2-0-0-canopus/
Updated: 2021-10-04

## What’s New

-   Enable parallel execution from VS and all CLI runners
-   Update all projects to .NET Framework 5.0
-   Upgrade Desktop modules to support the latest stable version of WinAppDriver
-   Simplify usage of configuration settings
-   Simplify the use of Logger class
-   Simplify all technology components and deprecate local and global override of actions
-   Rename all Until classes to WaitStrategy
-   Rename all ByLocator classes to FindStrategy
-   Simplify all wait strategies
-   Simplify usage of ServiceCollection
-   Open-source all framework test projects
-   Delete obsolete framework tests
-   Simplify project MSBuild files
-   Deprecate exception analysis feature
-   Remove shared test context logic from all projects
-   Fix a bug in the video recorder in parallel mode
-   Improving the speed of creation of services and components
-   Fix a bug in wait for not exist methods

**All projects and tests are now available in the PUBLIC GitHub repository. You can submit bugs or suggestions through the GitHub issues project page.**

---

# Release 2.1.0.0 (Scorpius)

URL: https://bellatrix.solutions/roadmap/release-2-1-0-0/
Updated: 2021-10-04

## What’s New

-   Simplify all modules control extensibility event handler classes
-   Add support for Data-Driven tests
-   Add class cleanup to the tests execution engine
-   Add new functionalities to Browser Service
-   Improve messages for the “Ensure” methods
-   Various small bug fixes

---

# Release 1.9.7.0 (Arcturus)

URL: https://bellatrix.solutions/roadmap/new-release-1-9-7-0-arcturus/
Updated: 2021-10-04

#### The most prominent of them are our integrations with Azure DevOps, qTest, and Jira, as well as our Free Unlimited CI test execution.

## What’s New

-   Faster Table and Grid support
-   New Edge Chromium Support
-   Using Multiple Assertions
-   CLI BELLATRIX Tests Execution
-   qTest Automatic Dynamic Cases Generation
-   Azure DevOps Dynamic Cases Generation
-   Azure DevOps Automatic Bug Logging
-   Jira Automatic Bug Logging
-   BELLATRIX Chatbot announcement

---

# Release 1.8.1.0 (Deneb)

URL: https://bellatrix.solutions/roadmap/release-1-8-1-0-deneb/
Updated: 2021-10-04

#### The most prominent of them are automation of complex web grids/tables, verification of hard-to-test functionalities such as PDFs/charts through our computer vision engine powered by machine learning, software management automation library, allowing you to install/upgrade desired software such as browsers, extensions through code.

## What’s New

-   improvements in assertion libraries
-   web Table and Grid controls
-   improvements in web element ElementList collection
-   web element collection control caching
-   add new ensure web methods
-   add support for latest browsers
-   add new BELLATRIX utility methods
-   optimize of web element control- add ability to cache
-   tests execution in Docker containers- Selenoid plug-in
-   Image Recognitioning library
-   web style assetion library
-   software management automation library
-   configuration through environment variables
-   upgrade all libraries to .NET Core 3.1
-   fix all known bugs

---

# Release 1.4.0.0 (Rigel)

URL: https://bellatrix.solutions/roadmap/release-1-4-0-0-rigel/
Updated: 2021-10-04

#### The new release brings not only bug fixes but even more enhancements.  
The most prominent ones are- new Web Load Testing Module where you can reuse your existing BELLATRIX web tests in the load tests. The next big thing is that BELLATRIX now seamlessly integrates with all major Test Results Reporting Portals and Tools such as Allure, Zafira, ReportPortal and Azure DevOps CI.

## What’s New

-   new web load testing module
-   new plugin for recording existing web tests for load tests
-   new test results portal/tools integrations
-   add web load testing templates
-   add new extensibility points- Pre/PostAssemblyInitialize, Pre/PostAssemblyCleanup
-   add new extensibility point for subscribing in case of exceptions in TestInit
-   add new extensibility points for video and screenshot generation
-   fix all known bugs in API, desktop, web, Android, iOS getting started
-   fix all known bugs in API, desktop, web, Android, iOS libraries
-   add support for latest versions of Opera driver
-   add support for latest versions of Chrome driver
-   add support for latest versions of Firefox driver
-   update video recording to the latest stable release of ffmpeg
-   update web full-page screenshots engine to latest stable release HTML2Canvas
-   update static analysis to the latest stable version of StyleCop
-   update all 3rd-party NuGet packages to latest stable versions

---

# Release 1.3.0.0 (Betelgeuse)

URL: https://bellatrix.solutions/roadmap/release-1-3-0-0-betelgeuse/
Updated: 2021-10-04

#### The new release brings not only bug fixes but even more enhancements.  
The most prominent ones are- support for Safari browser on MacOS, new BELLATRIX tooling for testing iOS and Android applications for both Windows and MacOS.

## What’s New

-   new Android automation tools and libraries
-   new iOS automation tools and libraries
-   add support for Safari browser on MacOS
-   add Android and iOS getting started guides and templates
-   fix all known bugs in API, desktop, web getting started
-   fix all known bugs in API, desktop, web libraries
-   add new examples in API, desktop, web getting started
-   add support for latest versions of Opera driver
-   add support for latest versions of Chrome driver
-   add support for latest versions of Firefox driver
-   add support for latest versions of Internet Explorer driver

---

# Release 1.2.8.0 (Leo)

URL: https://bellatrix.solutions/roadmap/release-1-2-8-0/
Updated: 2021-10-04

#### The new release brings not only bug fixes but even more enhancements.  
The most prominent ones are new UI installer for Windows, simplified native installation for Linux and MacOS. Bellatrix web and API tooling now are fully working on MacOS. Find below the list of all new things.

## What’s New

-   new UI installer for Windows
-   new .NET Core project templates for Windows, MacOS, Linux
-   fix bug video recording MacOS
-   start automatically WinAppDriver for Desktop projects
-   start automatically API demos for API getting started
-   decrease templates size
-   distribute drivers as single package per browser depending on OS
-   distribute video recorder as single package depending on OS
-   fix bug Opera window not closing
-   fix bug typing text in Internet Explorer not working correctly
-   fix bug Number web control
-   update settings files screenshots and videos locations to support MacOS
-   fix multiple bugs in API, Desktop, Web Getting Started
-   add support for latest versions of Opera driver
-   add support for latest versions of Chrome driver
-   add support for latest versions of Firefox driver
-   add support for latest versions of Internet Explorer driver
-   update WebDriver to 3.14.0
-   upgrade all templates to .NET Core 2.1

---

# How to Create a Library for Auto-generating Test Cases from Automated Tests Execution?

URL: https://bellatrix.solutions/how-to-create-a-library-for-auto-generating-test-cases-from-automated-tests-execution/
Updated: 2021-10-04

## Overview:

#### It is a nightmare to maintain duplicated tests or not to know what your automated tests are covering. One way to solve this problem is to relate detailed manual test cases to the automated tests and base the automated test entirely to the manual one. However, this is not efficient in most cases since certain aspects of the automated tests are different from the manual case. Also, many companies don’t have detailed, up-to-date manual test cases. Even if you have everything in place, it is hard to maintain the manual test cases’ relevance with time. This is why we will create a coded solution integrated into your automated tests to create automatically detailed manual test cases based on your passed automated tests and keeping them up-to-date. The solution will integrate with all major TCM systems.

## What Will Present:

<ul class="is-style-checklist"><li><h4>Overview of the ways to document what your automated tests are doing</h4></li><li><h4>List of problems with the maintenance of the test descriptions</h4></li><li><h4>List of potential benefits of implementing dynamic test cases</h4></li><li><h4>Demos – importing auto-generated test cases to major TCM</h4></li></ul>

## Speakers

#### Join this session to see the most advanced test automation features!

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

<div class="is-layout-flex wp-block-columns has-2-columns"><div class="wp-block-column"><figure class="wp-block-image"><img src="/blog-images/aangelov-.png" alt="Anton Angelov" width="185" height="183" loading="lazy" decoding="async"></figure><h4>Anton Angelov</h4><p>CTO Automate the Planet</p></div><div class="wp-block-column"></div></div>

---

# How to Create a Chat Bot Side-kick for Test Automation?

URL: https://bellatrix.solutions/how-to-create-a-chat-bot-side-kick-for-test-automation/
Updated: 2021-10-04

## Overview

#### We will look into how to create such a chatbot that can help you with specific test automation tasks- searching docs/automation blogs returning the most relevant results, asking it about element locators, giving notification about completed test runs, or even analyzing failed testing results through ML algorithms. We review all of the steps required to create such a bot, deploying it to the cloud and using it in many platforms such as FB messenger, Skype, Slack, Teams, Cortana, and many more.

## What Will Present:

<ul class="is-style-checklist"><li><h4>What are the chatbots?</h4></li><li><h4>How chatbots can be used in test automation?</h4></li><li><h4>Demos – creating a chatbot from scratch</h4></li><li><h4>Demos – deploying the chatbot the Azure</h4></li><li><h4>Demos – registering the chatbot in all major chat platforms</h4></li></ul>

## Speakers

#### Join this session to see the most advanced test automation features!

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

<div class="is-layout-flex wp-block-columns has-2-columns"><div class="wp-block-column"><figure class="wp-block-image"><img src="/blog-images/aangelov-.png" alt="Anton Angelov" width="185" height="183" loading="lazy" decoding="async"></figure><h4>Anton Angelov</h4><p>CTO Automate the Planet</p></div><div class="wp-block-column"></div></div>

---

# BELLATRIX R1 2020 Release Webinar

URL: https://bellatrix.solutions/bellatrix-r1-2020-release-webinar/
Updated: 2021-10-04

## Overview

We will show the newest cool features such as much faster automation of complex web grids/tables, executing multiple assertions without failing the tests immediately with our brand new Assert.Multiple method. We will look at how you can run your BELLATRIX tests via the command line with our new dotnet test plugin. At the end of the webinar, there will be a demo to our brand new integration with test case management systems such as qTest. The new plugin will generate test cases automatically and keep them up to date based on the execution of your passed tests and their steps.

## We Will Present:

<ul class="is-style-checklist"><li><h4>Faster Table and Grid support</h4></li><li><h4>New Edge Chromium Support</h4></li><li><h4>qTest Automatic Test Cases Generation</h4></li><li><h4>Using Multiple Assertions</h4></li><li><h4>CLI BELLATRIX Tests Execution</h4></li></ul>

## Speakers

#### Join this session to see the most advanced test automation features!

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

<div class="is-layout-flex wp-block-columns has-2-columns"><div class="wp-block-column"><figure class="wp-block-image"><img src="/blog-images/aangelov-.png" alt="Anton Angelov" width="185" height="183" loading="lazy" decoding="async"></figure><h4>Anton Angelov</h4><p>CTO Automate the Planet</p></div><div class="wp-block-column"><figure class="wp-block-image"><img src="/blog-images/mkolev-1.png" alt="Martin Kolev" width="180" height="180" loading="lazy" decoding="async"></figure><h4>Martin Kolev</h4><p>Marketing Lead</p></div></div>

---

# Responsive Designs Automated Testing

URL: https://bellatrix.solutions/responsive-designs-automated-testing/
Updated: 2021-10-04

## Overview

#### We will discuss possible solutions using WebDriver, Appium, and WinAppDriver. We will talk about what are the automated style tests and how they can improve the overall user experience of your app. Additionally, we will present a layout automated testing library for handling all these cases.

## What Will Present:

<ul class="is-style-checklist"><li><h4>Why testing app responsiveness is important</h4></li><li><h4>What are the layout tests?</h4></li><li><h4>What are the style tests?</h4></li><li><h4>Layout and style tests in practice</h4></li></ul>

## Speakers

#### Join this session to see the most advanced test automation features!

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

<div class="is-layout-flex wp-block-columns has-2-columns"><div class="wp-block-column"><figure class="wp-block-image"><img src="/blog-images/aangelov-.png" alt="Anton Angelov" width="185" height="183" loading="lazy" decoding="async"></figure><h4>Anton Angelov</h4><p>CTO Automate the Planet</p></div><div class="wp-block-column"></div></div>

---

# Test Grid and Table Controls

URL: https://bellatrix.solutions/test-grid-and-table-controls/
Updated: 2021-10-04

## Overview

The difference between a table and a grid is that usually, the grids are more complex than a regular HTML table. In them, you can have dynamic data. Moreover, inside the column, you can have other HTML elements such as buttons, text fields, selects, other tables. Or you can filter, sort the columns, and have paging for the grid. Instead of getting specific cells or rows by custom locators, we have created the Table and Grid controls, which ease the selection of cells/rows and assertion of the data. Moreover, in many cases, there isn’t a unique item that you can use to select the row/cell.

<div class="wp-block-button"><a class="wp-block-button__link has-blue-color has-lightblue-background-color has-text-color has-background" href="https://docs.bellatrix.solutions/web-automation/complex-components/">Learn more<span class="sr-only"> about Test Grid and Table Controls</span></a></div>

---

# Getting Started with BELLATRIX in 15 Minutes

URL: https://bellatrix.solutions/getting-started-with-bellatrix-in-15-minutes/
Updated: 2021-10-04

## 1. Simple Install and Create First Project

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

1.1 Download the BELLATRIX solution as a zip file or directly clone the GitHub repository. Follow the links from the download email.

1.2 Unzip it.

1.3. Open the **BellatrixTestFramework.sln**

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

<figure class="wp-block-image aligncenter"><img src="/blog-images/open_the_sln.png" alt="1.3. Open the BellatrixTestFramework.sln" width="681" height="240" loading="lazy" decoding="async"></figure>

1.4. Under the **starthere** folder find the project your prefer: web, mobile, desktop, API

![1.4. Under the starthere folder find the project your prefer: web, mobile, desktop, API](https://bellatrix.solutions/blog-images/image.png)

1.5 Build the project

![1.5 Build the project](https://bellatrix.solutions/blog-images/build.png)

> **Note**
>
> You can also install BELLATRIX through the command line on [**Windows**](https://docs.bellatrix.solutions/general-information/system-requirements/), [**MacOS**](https://docs.bellatrix.solutions/general-information/system-requirements/) and [**Linux**](https://docs.bellatrix.solutions/general-information/system-requirements/).

> **Note**
>
> Since BELLATRIX is a set of C# libraries and tools (it isn’t a UI tool or IDE), you need programming knowledge on how to write C# code. To write tests, we use the standard .NET code editors- **[Visual Studio](https://visualstudio.microsoft.com/)** or [**Visual Studio Code**](https://code.visualstudio.com/). The suggested one for beginners is Visual Studio since it is more visual and easier to use. For this tutorial, I will use Visual Studio.

## 2. Steps to Create a New Test Class

2.1 Create a new file called **BellatrixLoginTest**.cs file.

2.2 Copy the following sample code:

```csharp
using NUnit.Framework;
namespace Bellatrix.Web.NUnit.Tests
{
    [TestFixture]
    [Browser(BrowserType.Chrome, Lifecycle.ReuseIfStarted)]
    public class LoginTests : WebTest
    {
        public override void TestInit() => App.NavigationService.Navigate("http://demos.bellatrix.solutions/my-account/");
        [Test]
        public void CorrectTextDisplayed_When_ClickDownloadButton()
        {
            var downloadButton = App.ElementCreateService.CreateByInnerTextContaining<Anchor>("Download");
            downloadButton.Click();
            var heading1 = App.ElementCreateService.CreateById<Heading>("feature-title");
            heading1.EnsureInnerTextIs("Download");
        }
    }
}
```

The **TestInit** method will be executed before each method marked with the **Test** attribute, which means that you don’t need to write a code for navigating to the page in each test.

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

## 3.Steps to Create the Login Test

Now you have a preconfigured BELLATRIX web test project. You can start writing web tests immediately. How about creating our web login automated test?

3.1 Rename **CorrectTextDisplayed\_When\_ClickDownloadButton** test method to **SuccessfullyLoggedIn\_When\_DefaultCredentialsUsed**. Delete the body of the method. Here we will place our login test logic.

3.2 To log in to the shop’s my account, we need to set the username and password fields. Then click the ‘Log in’ button and verify somehow that we are logged in. To fill the info in the fields, we need to use BELLATRIX to locate and ‘create’ them on the page. After a component (button, text field, select, etc.) is found, you can perform actions against it- set text, clicking, and so on. First, we need to find the most appropriate way to locate the elements to do so load the [**http://demos.bellatrix.solutions/my-account/**](http://demos.bellatrix.solutions/my-account/) page in a new Chrome browser tab. And Chrome Developers tools, which we will use to inspect the web page elements HTML and choose the best possible locator.

![3.2 To log in to the shop’s my account, we need to set the username and password fields. Then click the ‘Log…](https://bellatrix.solutions/blog-images/Picture111.png)

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

3.3 Now, why not find the locator for the username field? **Click** in the username field and **right-click**. From the menu, choose **Inspect**.

![3.3 Now, why not find the locator for the username field? Click in the username field and right-click. From…](https://bellatrix.solutions/blog-images/Picture12.png)

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

3.4 The inspected element will be highlighted in the Elements window.

![3.4 The inspected element will be highlighted in the Elements window](https://bellatrix.solutions/blog-images/Picture13.png)

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

> **Note**
>
> To be able to write any kind of automated web tests, you need to have basic HTML knowledge, and I won’t go in many details about the different types of locators here.

<div aria-hidden="true" class="wp-block-spacer spacer-40"></div>

3.5 Usually, the best possible way to find a web element is to use its ID if there is one. Luckily for us, the username text field has an ID. Find it in the Elements window and copy it.

![3.5 Usually, the best possible way to find a web element is to use its ID if there is one. Luckily for us, the…](https://bellatrix.solutions/blog-images/Picture15.png)

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

3.6 Next, we need to instruct BELLATRIX to create the username control using the copied ID. We will save the control in a variable which we use later to set the text into the control. To do so, use the following code:

```csharp
TextField userNameField = App.ElementCreateService.CreateById<TextField>("username");
```

We create the **userNameField** variable of type **TextField**. Then we create the element using BELLATRIX **ElementCreateService**. It gives us the method **CreateById**, and there are many other similar methods for using the different types of locators such as CSS, XPath, Class, and so on. In the <> brackets, we need to point the type of the component that we want to be created in our case- **TextField**. This is essential since each component provides unique to its methods and properties. For example, the Button component doesn’t have a method **SetText**, but the **TextField** does. Lastly, as a parameter to the **CreateById** method, set the copied ID- “username”.

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

3.7 We need to create the password and button components, too, following the same procedure. You will end up with the following code:

```csharp
[Test]
public void CorrectTextDisplayed_When_ClickDownloadButton()
{
    TextField userNameField = App.ElementCreateService.CreateById<TextField>("username");
    Password passwordField = App.ElementCreateService.CreateById<Password>("password");
}
```

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

3.8 The next step is to set our credentials to the username and password fields. If you use the new **userNameField** variable and type ‘.’ after it, Visual Studio will show you all of its available actions and properties that are at your disposal.

![3.8 The next step is to set our credentials to the username and password fields. If you use the new…](https://bellatrix.solutions/blog-images/Picture16.png)

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

For setting the username, we can use the **SetText** method.

```csharp
userNameField.SetText("info@berlinspaceflowers.com");
You have a similar method for the password field called SetPassword.
passwordField.SetPassword("@purISQzt%%DYBnLCIhaoG6$");
```

<div aria-hidden="true" class="wp-block-spacer spacer-50"></div>

3.9 Lastly, we need to locate the login button. Inspect the ‘Log in’ button.

![3.9 Lastly, we need to locate the login button. Inspect the ‘Log in’ button](https://bellatrix.solutions/blog-images/Picture17.png)

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

You will notice that the button doesn’t have an ID attribute. We can use the XPath selector to locate the element. An easy way to find element’s XPath is by right-clicking on the element’s HTML in the Developer Tools and clicking Copy XPath.

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

![You will notice that the button doesn’t have an ID attribute. We can use the XPath selector to locate the…](https://bellatrix.solutions/blog-images/Picture18.png)

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

However, in most cases, it is better to write the XPath yourself since the one generated is not the optimal one and can lead to failure of the tests over time. This is the XPath generated by Chrome- **//\*\[@id=”post-8″\]/div/div/form/p\[3\]/button.** I rewrote it to use the name attribute of the button- **//button\[@name=’login’\]**

```csharp
Button loginButton = App.ElementCreateService.CreateByXpath<Button>("//button[@name='login']");
```

<div aria-hidden="true" class="wp-block-spacer spacer-40"></div>

3.10 Write a code to click on the ‘Log in’ button. Just call the **Click** method of the **loginButton** variable.

```csharp
loginButton.Click();
```

<div aria-hidden="true" class="wp-block-spacer spacer-40"></div>

3.11 If the login process is successful, the following screen should be displayed.

![3.11 If the login process is successful, the following screen should be displayed](https://bellatrix.solutions/blog-images/Picture19.png)

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

We need to make sure that the right user succeeded in logging in. To do so, we need to add a verification step. The most appropriate info that we can check is whether the correct ‘Hello’ message is displayed. In our case- ‘Hello info1’. Our second assertion might be whether the log out button is visible.

3.12 Inspect the “Hello info1” label. You will notice that it is wrapped in an HTML div element that holds the whole information in this part of the screen. We can create such Div component with BELLATRIX and then assert that it contains the ‘Hello info1’ text. However, as you can see, we don’t have an ID for this element. However, we can find it using its class- woocommerce-MyAccount-content. You should be careful using classes since, in many cases, there is more than one element that can be returned for a class. You can check whether this is the case by pressing ctrl + F and pasting the class in the search field.

![3.12 Inspect the “Hello info1” label. You will notice that it is wrapped in an HTML div element that holds the…](https://bellatrix.solutions/blog-images/Picture22.png)

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

Only one result is returned, which means that this class is unique, and we can use it safely as a selector.

```csharp
Div myAccountContentDiv = App.ElementCreateService.CreateByClass<Div>("woocommerce-MyAccount-content");
```

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

3.13 Verify the ‘Hello’ message. Each BELLATRIX component exposes several relevant verification methods called- ‘Ensure’ methods. They are more than a normal assertion method since it will wait a bit for the condition to happen in case of asynchronous requests and additionally will display a beatified message in case of failure. In our case, you can call the **EnsureInnerTextContains** method of the **myAccountContentDiv** variable.

```csharp
myAccountContentDiv.EnsureInnerTextContains("Hello info1");
```

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

3.14 Finally, how about locating the logout link? Inspect the link.

![3.14 Finally, how about locating the logout link? Inspect the link](https://bellatrix.solutions/blog-images/Picture233.png)

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

The best option we have is to locate the anchor by its inner text ‘Log out’. To do so, we can use another BELLATRIX method called CreateByInnerTextContaining.

```csharp
Anchor logoutLink = App.ElementCreateService.CreateByInnerTextContaining<Anchor>("Log out");
```

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

3.15 Assert that the log out link is visible- call the **EnsureIsVisible** method of the **logoutLink** variable.

```csharp
logoutLink.EnsureIsVisible();
```

Here is how our code looks in the end:

```csharp
[TestFixture]
[Browser(BrowserType.Chrome, Lifecycle.ReuseIfStarted)]
public class BellatrixLoginTests : WebTest
{
    public override void TestInit() => App.NavigationService.Navigate("http://demos.bellatrix.solutions/my-account/");
    [Test]
    public void CorrectTextDisplayed_When_ClickDownloadButton()
    {
        TextField userNameField = App.ElementCreateService.CreateById<TextField>("username");
        Password passwordField = App.ElementCreateService.CreateById<Password>("password");
        Button loginButton = App.ElementCreateService.CreateByXpath<Button>("//button[@name='login']");
        userNameField.SetText("info@berlinspaceflowers.com");
        passwordField.SetPassword("@purISQzt%%DYBnLCIhaoG6$");
        loginButton.Click();
        Div myAccountContentDiv = App.ElementCreateService.CreateByClass<Div>("woocommerce-MyAccount-content");
        myAccountContentDiv.EnsureInnerTextContains("Hello info1");
        Anchor logoutLink = App.ElementCreateService.CreateByInnerTextContaining<Anchor>("Log out");
        logoutLink.EnsureIsVisible();
    }
}
```

## 4. Run The Automated Test

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

4.1 Build the BELLATRIX NUnit project

![4.1 Build the BELLATRIX NUnit project](https://bellatrix.solutions/blog-images/Picture24.png)

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

4.2 Open Text Explorer and select your test. Right-click and click Run.

![4.2 Open Text Explorer and select your test. Right-click and click Run](https://bellatrix.solutions/blog-images/Picture25.png)

![4.2 Open Text Explorer and select your test. Right-click and click Run](https://bellatrix.solutions/blog-images/Picture26.png)

![4.2 Open Text Explorer and select your test. Right-click and click Run](https://bellatrix.solutions/blog-images/Picture34.png)

<div aria-hidden="true" class="wp-block-spacer spacer-30"></div>

#### Congratulations! You have just written your first BELLATRIX web test in a couple of minutes!

---

# BELLATRIX R3 2019 Release Webinar

URL: https://bellatrix.solutions/bellatrix-r3-2019-release-webinar/
Updated: 2021-10-04

## We Will Present:

<div aria-hidden="true" class="wp-block-spacer spacer-20"></div>

<ul class="is-style-checklist"><li><h3>Table and Grid support</h3></li><li><h3>Visual assertions</h3></li><li><h3>Selenoid support</h3></li><li><h3>Load Testing</h3></li><li><h3>SpecFlow</h3></li><li><h3>Angular support</h3></li></ul>

---

# How to Test the Test Automation Framework Appium Conf 2019

URL: https://bellatrix.solutions/how-to-test-the-test-automation-framework-appium-conf-2019/
Updated: 2021-10-04

## Overview

Nowadays, more and more companies are building test automation frameworks based on WebDriver and Appium for testing their web and mobile projects. A big part of why there are so many flaky tests is that we don’t treat our tests as production code. Moreover, we don’t treat our framework as a product. In the talk, you will see examples of how you can automate the testing of your test automation framework and be sure that it is highly reliable. You can get lots of ideas for various types of tests such as learning tests verifying that 3rd party dependencies are not breaking the code, compatibility tests checking that the UI components are working for each mobile control on each OS, cross-platform verifications for testing whether everything is working on multiple OS. Sample test environments for storing different distributions of the framework packages will be presented.

---

# Accelerate Tests Creation

URL: https://bellatrix.solutions/accelerate-tests-creation/
Updated: 2021-10-04

## Overview

#### BELLATRIX speeds up your test creation by providing element snippets, handy elements locators, smart wait for the elements, more than 200 additional elements actions, ready-to-go templates, and much more.

-   [Speed Test Writing with Element Snippets](https://bellatrix.solutions/features/web/accelerate-test-creation/#subfeature_speed-test-writing-with-element-snippets)
-   [15+ Handy Elements Locator](https://bellatrix.solutions/features/web/accelerate-test-creation/#subfeature_15-handy-elements-locator)
-   [API Usability- Locate Elements](https://bellatrix.solutions/features/web/accelerate-test-creation/#subfeature_api-usability-locate-elements)
-   [API Usability- Wait for Elements](https://bellatrix.solutions/features/web/accelerate-test-creation/#subfeature_api-usability-wait-for-elements)
-   [200+ Additional Elements Actions](https://bellatrix.solutions/features/web/accelerate-test-creation/#subfeature_200-additional-elements-actions)
-   [HTTP Traffic Capturing and Validations](https://bellatrix.solutions/features/web/accelerate-test-creation/#subfeature_http-traffic-capturing-and-validations)
-   [Ready-To-Go Project Templates](https://bellatrix.solutions/features/web/accelerate-test-creation/)

---

# Test Responsive Layouts

URL: https://bellatrix.solutions/test-responsive-layouts/
Updated: 2021-10-04

## Overview

#### We have more than 15 predefined resolutions, featuring the ability to set up custom ones and easily integrate with all major cloud providers.

-   [200+ Assertions Based on Coordinates](https://bellatrix.solutions/features/web/test-responsive-layouts/#subfeature_200-assertions-based-on-coordinates)
-   [15+ Predefined Resolutions](https://bellatrix.solutions/features/web/test-responsive-layouts/#subfeature_15-predefined-resolutions)
-   [Custom Resolutions](https://bellatrix.solutions/features/web/test-responsive-layouts/#subfeature_custom-resolutions)
-   [Cloud Integration](https://bellatrix.solutions/features/web/test-responsive-layouts/#subfeature_cloud-integration)

---

# Learning Resources

URL: https://bellatrix.solutions/learning-resources/
Updated: 2021-10-04

- [How to Create a Library for Auto-generating Test Cases from Automated Tests Execution?](https://bellatrix.solutions/how-to-create-a-library-for-auto-generating-test-cases-from-automated-tests-execution/): Webinar: build a library that auto-generates detailed manual test cases from your passed automated tests and keeps them up to date in all major TCM systems.
- [How to Create a Chat Bot Side-kick for Test Automation?](https://bellatrix.solutions/how-to-create-a-chat-bot-side-kick-for-test-automation/): How to create such a chatbot that can help you with specific test automation tasks- searching docs/automation blogs returning the most relevant results
- [BELLATRIX R1 2020 Release Webinar](https://bellatrix.solutions/bellatrix-r1-2020-release-webinar/): Much faster automation of complex web grids/tables, executing multiple assertions without failing the tests immediately with our brand new method.
- [Responsive Designs Automated Testing](https://bellatrix.solutions/responsive-designs-automated-testing/): Webinar: why app responsiveness matters and how layout and style tests with WebDriver, Appium and WinAppDriver catch broken responsive designs early on.
- [Test Grid and Table Controls](https://bellatrix.solutions/test-grid-and-table-controls/): 15-minute video: how BELLATRIX Table and Grid controls select cells and rows and assert dynamic data in complex grids with buttons, inputs and nested tables.
- [Getting Started with BELLATRIX in 15 Minutes](https://bellatrix.solutions/getting-started-with-bellatrix-in-15-minutes/): Install BELLATRIX and create your first project and test. We will create an automated test to log in to a website and verify afterward whether we succeeded.
- [BELLATRIX R3 2019 Release Webinar](https://bellatrix.solutions/bellatrix-r3-2019-release-webinar/): BELLATRIX R3 2019 release webinar recording: table and grid support, visual assertions, Selenoid, load testing, SpecFlow and Angular support in practice.
- [How to Test the Test Automation Framework Appium Conf 2019](https://bellatrix.solutions/how-to-test-the-test-automation-framework-appium-conf-2019/): Appium Conf 2019 talk: treat your test automation framework as a product with learning, compatibility and cross-platform tests that keep it reliable.
- [Accelerate Tests Creation](https://bellatrix.solutions/accelerate-tests-creation/): Video: BELLATRIX speeds up test creation with element snippets, handy locators, smart waits, 200+ extra element actions and ready-to-go project templates.
- [Test Responsive Layouts](https://bellatrix.solutions/test-responsive-layouts/): Video: test responsive web layouts with BELLATRIX using 200+ coordinate-based assertions, 15+ predefined resolutions, custom sizes and cloud integration.