Logo

Write automated browser tests in plain English

Carbonate turns simple language driven instructions into end-to-end tests.

Try it for yourself by running a simulated test:
Simulated browser
*This is a smaller model for demonstration purposes, for the best results try the real thing.
Step 1

Write your tests in plain English, directly in your preferred testing tool.

Step 2

At first run, Carbonate will automatically convert your tests into fixed test scripts.

Step 3

When your HTML changes, Carbonate will generate a new test script.

No more brittle tests

Tweak your UI to your heart's content. As long as the behavior stays the same, Carbonate will figure out the changes just like a real user would.

Icon 01
Performance
Analysis is performed only once; any subsequent runs will use a locally cached version of the test script for optimal performance.
Icon 02
Flexibility
The test scripts provided by Carbonate can be run however you like, giving you the opportunity to run your own code in between.
Icon 03
Robustness
Carbonate intelligently analyzes your HTML to determine the difference between a change in UI and simple rendering differences.
Icon 04
Integrations
We provide SDKs for PHP, Node, and Python, so you can get up and running in minutes without any change to your tooling.

Run directly from your existing test suite

public function testSelectTwoFromTheDropdown()
{
    $this->carbonateSdk->load('https://carbonate.dev/demo-form.html');
        
    $this->carbonateSdk->action('select Two from the dropdown')
        
    $this->assertTrue(
        $this->carbonateSdk->assertion('the dropdown should be set to Two')  
    );
}

Learn more over at the docs.

Integrations ready to go

PHPUnit
Python unittest
Laravel Dusk (PHP)
Puppeteer (Node)
Symfony Panther (PHP)
Jest (Node)

FAQs

What is the difference between a cached run and an extraction?

An extraction is the initial analysis and generation of the test script, which is then cached after the first successful run. Provided that your HTML has some semantic meaning, extractions will only be necessary when you change your UI.

Won't this slow down our test suite?

Carbonate's SDK caches the generated test script directly into your test suite, meaning that on subsequent runs, it will run as fast as hand-written tests.

How can I ensure tests are reliable?

Test scripts can be committed to your repository alongside your code. If your HTML structure changes significantly, you can delete the test scripts, and Carbonate will automatically generate new ones.

What if my page is dynamically rendered?

During the initial extraction, the SDK uses a combination of DOM mutation observers and spying on your network requests to determine when a page has finished loading. On subsequent cached runs, the SDK only needs to wait until the appropriate elements are available.

What if I need to do something advanced?

In these cases, you can interface with the browser directly between steps. We've made sure to design our SDK to fit around your existing setup, so you retain as much control as necessary.

Do I need coding knowledge to use this product?

You'll need to know a bit to integrate our SDK into your test suite, but it doesn't take long to get up and running. We're working on a tool that will let you run these with no integration necessary.

Speed up development; increase stability

Move fast and don't break things

End-to-end tests provide valuable assurance that your changes don't break existing functionality.

Unfortunately, they are notoriously fragile and slow to write. By outsourcing the hard work to Carbonate, you can spend less time testing and more time doing the things you love.

Feature

Automate your testing today