Easiest, reliable and quickest test automation for teams that ship fast

Zylitics help teams to quickly implement automated tests for their web apps. With our all-inclusive platform, there is no upfront setup required. Our easy testing APIs let teams having less or no prior end to end testing experience quickly become a pro.

Teams that don't write tests may be shipping bugs & harming own business.

Manual end to end testing
Less confidence in deployments.
Increased pressure on developers/QA engineers.
Manual testers often save testing efforts during small refactoring that may lead to broken functionalities in any dependent modules.
Must remember entire application flow, functionalities, behavior and expectations to be able to test.
User experience depends on the ability of manual tester and the efforts put into testing.
Automated end to end testing
Strong confidence in deployments.
Happier and relieved developers/QA engineers.
Once setup, all dependent modules are automatically tested at a much faster rate.
Once tests are written, they also serve as documentation to the smallest supported features and functionalities. Every smallest detail is tested.
Tests fail if any part of an application doesn't behave as expected.

What are the challenges involved in automated testing?

Deciding where to begin

Write test or use no-code tool? Which framework? Test just locally or multiple OS & browsers? Which infrastructure provider to use? Where to manage and store test results?

Complex setup

Most testing frameworks require a specific environment setup before getting started. This includes downloading and installing libraries, setting up environment variables, configuring test runners and more depending on what framework you're using.

Understanding core concepts

Most testing frameworks requires you to understand their core concepts before you can get started. This involves understanding initializations, various interfaces, classes, constructors and appropriate methods. There could be separate set of constructs and techniques for performing different tasks.

Code complexity

You may find yourself writing > 10 lines of code for doing simple hover, click and type operations. Since automated tests try behaving the same way an end user would, there are several things need to be explicitly handled such as 'waiting for something to happen'. Handling similar cases increase the complexity and length of test.

Less programming ability

Not everyone who needs to write automated tests may be a good programmer. To be able to write tests for complex parts of a web app, one must have a solid grasp of the language being used to write tests. What if a QA engineer knows little java but needs to deal with lambdas and generics?

Unreliable tests

Even if you successfully begin writing tests, they may not run reliably, i.e they may pass or fail arbitrarily. There could be numerous reason behind this such as poor element selectors or improperly handled exceptions. This is also known as flakiness.

Poor understanding of framework internals

Selenium is the most widely used end to end testing framework that uses W3C webdriver standard to automate tests on browsers. If you don't know webdriver internals, you may end up using improper methods that can lead to fragile and unreliable tests. It's very important to have a solid understanding of the internals to be able to write solid tests.

Insufficient documentation and support

A detailed and complete documentation is vital to be able to succeed in writing automated tests. If you're a beginner you might require good support that may be hard to get from any open source framework.

Slow and opaque tests when run on remote machines

When a team need to test on various OS and browsers, they usually use a test infrastructure provider. In most cases you don't get to see what happened with the test until it is completed. They run slower because lot of network calls may be involved during test execution.

Agreed! Lots of challenges but how's Zylitics going to help?

Logging in to Zylitics begins your testing journey

There is nothing to decide. Zylitics is an all inclusive platform. You can just open browser, log in and begin writing and running tests. Various OS, browsers and testing tools will be available with no extra configuration.

No setup

You don't have to have anything installed on the machine except a browser where you'd open Zylitics. If you've used selenium, you might know there are a number of things to setup. These include browser drivers, system environments, libraries, grid etc. Zylitics frees you from all those management headaches.

No core concepts to understand

Just invoke built-in commands, named precisely that match the names of the actions you need to perform. There are no interfaces, classes or objects. For example, type will type into text field, click will click on element, scroll will scroll to element.

Easy coding even in complex tests

Zylitics tests looks like instruction sets. Tasks that typically take multiple lines of code are kept into built-in functions. This makes test clean, readable and easy to write. You will write less and do more with Zylitics. More on that in further sections.

Only basic programming ability is needed

With Zylitics, writing complex tests is easier than ever even for people with less programming experience. This was our #1 priority while building Zylitics. There are no complicated language constructs. We've created built-in functions for almost every use case so that you will never have to write or read complex and imperative test code. More on that in further sections.

Write reliable tests automatically

We're continually identifying common mistakes people make while writing tests and incorporating them into our test functions so that you will not have to handle them explicitly. We try to cover many possible edge cases to minimize flakiness. Our documentation guides you in writing resilient element selectors and provides best practices to increase test reliability.

We read framework internals in depth

Zylitics uses selenium and webdriver to automate tests. Every API is written after reading webdriver specs in depth. Webdriver allows to perform a particular task in a few different ways. Our APIs are precisely written and maps to appropriate webdriver task. For example type is given to enter text in text fields and sendKeysToPage is given to send text to non text field elements such as body. This makes sure test run smoothly in every circumstance.

We've excellent documentation and outstanding support

Even selenium's documentation is not that complete and elaborative. We've covered every test function, guides, concepts and much more. We guide you on building selectors, writing test cases, finding elements and everything else you'd expect from a good documentation. Our support comes directly from engineers who're building Zylitics. It's available whenever you're in need. Call, chat or community, we've plenty of support options.

Fast and transparent tests even on remote machines

All our tests run on remote VMs but still they are very fast and transparent. 95% of the times, a VM gets connected under 10 seconds. All tests relay live preview and real time output without directly connecting you to VM or using things like VNC. We put drivers, browsers, test runner and everything else in the VM so that it runs isolated without having to access external network. This allow tests to run much faster. There are no hubs or nodes.

I use Selenium today, can Zylitics make things easier?

Zylitics handles many things internally and lets you focus on writing effective tests rather than handling unexpected errors and bugs. Following are some of the things that make selenium developer's life easier:

Setting up things are not required. You won't be dealing with multi browser drivers, environments, selenium binaries, test runners or anything else.
You won't be worrying about grid, nodes, networking, ports etc. We've built-in infrastructure (multiple OS and browser versions).
Despite running tests in remote VMs, we don't use grid & node setup. Tests run in an isolated VM as if they're running locally. No grid to node network communication.

Zylitics tests can reduce your 100 lines of selenium test case to just 10. For instance, if you call type but element is behind a backdrop, command will wait until it can type into element. No more 6 lines of extra code when you use FluentWait or similar classes.

All commands automatically wait until the intended task is performed. For example typeActive will wait until there is a focused text type field is found. click waits until click is done. Assertions wait until conditions are fulfilled. No more confusing implicit and explicit waits.

Minimal flakiness. You will never get a StaleElementException, ElementClickInterceptedException or anything like that. We've created our APIs in a way that encourage the use of appropriate method for a particular task thus minimizing flakiness.

We've added some very useful selector methods like by.text, by.labelText, by.altText, by.title, by.placeholderText, by.testId, by.role etc. We stress on using resilient and reliable element selectors.

We've made it very easy to use functions like 'file upload' using setFiles. You'll appreciate the simplicity of our APIs. We've made selenium tests look and perform much better and easier.

Enough talk, can I see some code?

In this section we've demonstrated two beautifully working code samples that validates sign-in functionality of amazon.in. The image shows exact flow of sign-in. Once signed-in, test goes into customer service page and validates it has reached intended page.

One of the sample is written in Zylitics testing APIs and another is in Selenium using Java. Not only our testing APIs are easy to write, read and understand they also wait automatically. You will hardly find yourself using manual waits. Writing code in Selenium is not very tricky too but you've to be an expert to be able to use APIs in correct ways, whereas Zylitics APIs are extremely easy even for beginners.

Amz Sign in process

#==========Zylitics's ZWL==========
# move mouse over 'Hello..' to let Sign-in button appear
performAction(move(findElement('Hello, Sign in', by.text)))
click(findElement('Sign in', by.text))
# No need to find elements, typeActive will wait for a
# focused text field automatically
typeActive('praveen@example.com', keys.enter)
typeActive('xx', keys.enter)
click(findElement('Customer Service', by.text))
# assert that we're into customer service page by validating heading
assertTrue(exists(findElement('/^Hi, praveen. What can we help/', by.text)))

//==========Selenium Java==========
WebDriver driver = new ChromeDriver();
Actions actions = new Actions(driver);
    driver.findElement(By.partialLinkText("Hello, Sign in")));
driver.findElement(By.partialLinkText("Sign in")).click();
WebDriverWait wait =
   new WebDriverWait(driver, Duration.ofMillis(60));
// Have to wait for email and password fields to render because
// amazon makes api calls in between before rendering them.
WebElement email =
    wait.until(d -> d.findElement(By.name("email")));
email.sendKeys("praveen@example.com", Keys.ENTER);
WebElement password =
    wait.until(d -> d.findElement(By.name("password")));
password.sendKeys("xx", Keys.ENTER);
    By.partialLinkText("Customer Service")).click();
// selenium doesn't support selecting by text, therefore just wait and match page page title as
// there are no suitable and reliable css selector on this page
wait.until(d -> ExpectedConditions.titleContains("Help"));

Wait, I read Zylitics's ZWL. Is that some programming language?

Yes, Zylitics uses it's own DSL (Domain specific language) called ZWL for writing tests. It has minimal syntax and is similar to other languages you already know. Following are answers to some common questions:

What was the need of ZWL? Why not existing languages such as JS, Java, Python...?

We wanted to make testing in Zylitics dead easy for everyone regardless of programming ability. We didn't want to set just one language such as JS because there are thousands of dev/QA who write in Java/Python/C# etc. We could've added support for all popular languages but then it'd become a maintenance mess and most of our time would go just in supporting multiple languages.
To keep everyone on same page, we built a simple DSL that anyone can use without going through a learning curve. ZWL's language specs are just 10 minutes read. If you know basics of any language, you already know ZWL.

How will I write Java like lambdas and complex operations in ZWL?

You won't have to. ZWL has built-in functions for everything needed to successfully write end to end tests. If you look at the code sample comparison above, we did everything that was happening in java but didn't have to use any complex operation. Everything comes out of box with ZWL. Your tests look very clean and readable.

What about third party libraries I want to use to aid in testing?

We've just begun. ZWL will improve by time and will provide plugins for injecting third party functionalities. ZWL is interpreted into Java internally, that is why it'd be very easy to provide plugins for various third party tools.

Is there support in ZWL for String, List, Map..?

Yes ZWL supports all common data structures and operations. It has rich support for regex.

How much time I'll be spending in learning ZWL as a language?

Not more than 10 minutes. It is the testing APIs such as findElement, type, click that you need to look into.

Where will I'll be writing the code? Does Zylitics integrates to my IDE?

You'll use Zylitics IDE that is specifically built as a testing IDE. Following briefs why we built our own IDE and why Zylitics can't be integrated into your own.

All our tests run on remote VMs. Zylitics IDE allows to watch them live. It has integrated panels for live preview and real time output.
Our IDE immediately displays full detail of completed builds in a drawer like panel.
To configure OS/browser and other details of a run, our IDE provides various configuration screens.
It has file upload, global and build time variables and several other management screens that helps manage all test related tasks from a single place.
Our IDE is built in a way that you never have to leave it during test development.
For all the above reasons, we built our own IDE. Zylitics can't function with your own IDE for the same reasons.
IDE Intro

Our test infrastructure

Windows 10 and 8.1 are currently supported. Support for Mac is expected by Sep 2021.
Chrome, firefox and IE11 are currently supported. Support for Safari is expected by Sep 2021. More than 10 previous versions of chrome and firefox are supported.
Zylitics Infra

Can I see a quick demo to learn how it works?

Zylitics makes automated testing easier than ever.

© 2021 Zylitics. All Rights Reserved
Zylitics logo