(Updated on: 21.11.2021)
It combines information from the best articles recently released (they are referenced at the bottom) and adds from my own experience.
Just a couple of years ago website testing had little documentation, was slow, hard to implement, not deterministic, and, generally, not pleasant to work on.
Nowadays, the website testing field has stabilized. Several testing tools receive very positive feedback from their users, well-known testing best practices has emerged, and testing became a more integral part of the job of web developers.
Today’s cutting edge website testing tools are fast, informative, and easy to work with. These tools would make your testing and developing experience much more enjoyable.
Looking forward, I forecast that AI would become more impactful in the field of automated tests. Some such tools already exist, and actively improving the workflow and experience of thousands of developers.
- If you see anything I missed, got wrong, or is outdated, leave a comment and I’ll address it right away.
- Notice the links at the bottom of the page. Reading them will allow you to deepen your knowledge in specific aspects of testing.
In general, the central test types for websites are:
- Unit Tests- Testing of individual units like functions or classes by supplying input and making sure the output is as expected:
- Integration Tests- Testing processes across several units to achieve their goals, including their side effects:
- End-to-end Tests (also known as “E2E Tests” or “Functional Tests”)- Testing user scenarios on the browser itself by controlling controlling the browser programmatically.
These tests usually ignore the internals of applications and look at them like on a black box.
If I write a test, where would it run?
- Tests can run in the browser by creating an HTML page with the test libraries and test files included as JS scripts.
- Tests can run in a headless browser which is a way to launch browsers in a special mode where they run without actually rendering the UI on the screen. This way you can run them much faster in terms of performance and even entirely from the command line.
- Tests can also be executed in Node.js by simply importing the test files that would import the files that are being test, that usually run on the browser.
To simulate a browser-like environment, “
window.location“ and such, jsdom is commonly used. Jsdom simulates whatever you get when you run your JS inside the browser like window, document, body, location, cookies, selectors but it doesn’t render anything.
Out of these three methods, I suggest using the third method (Node.js + jsdom) wherever possible. This method is much faster than the other two. However, the first and second methods may be more reliable because running bowser related code in the browser might be more reliable.
Test Tools Types
Test tools can be divided into the following functionalities. Some provide us with only one functionality, and some provide us with a combination.
It is very common to use a combination of several tools to cover all the needed test functionalities.
I will discuss each of them in-depth below, but first, let’s introduce them quickly.
- Test launchers are used to launch your tests in the browser or in Node.js with user config. (Karma, Jasmine, Jest, TestCafe, Cypress, webdriverio)
- Testing structure providers help you to arrange your tests in a readable and scalable way. (Mocha, Jasmine, Jest, Cucumber, TestCafe, Cypress)
- Assertion functions are used to check if a test returns what you expect it to return and otherwise, to throw a clear exception. (Chai, Jasmine, Jest, Unexpected, TestCafe, Cypress)
- Generate and display test progress and summary. (Mocha, Jasmine, Jest, Karma, TestCafe, Cypress)
- Mocks, spies, and stubs to simulate tests scenarios, isolate the tested part of the software from other parts, and attach to processes to test certain aspects of a scenario. (Sinon, Jasmine, enzyme, Jest, testdouble)
- Generate and compare snapshots to make sure changes to data structures from previous test runs are intended by the user’s code changes. (Jest, Ava)
- Generate code coverage reports of how much of your code is covered by tests. (Istanbul, Jest, Blanket)
- Browser Controllers simulate user actions for E2E Tests. (Nightwatch, Nightmare, Phantom, Puppeteer, TestCafe, Cypress)
- Visual Regression Tools are used to compare your site’s appearance to its previous versions visually by using image comparison techniques.
(Applitools, Percy, Wraith, WebdriverCSS)
Let’s explain some of the terms mentioned above:
Launch a list of tests based on a configuration you provide (what browsers to run in, what babel plugins to use, how to format the output, etc).
Refers to the organization of your tests. Nowadays, tests are usually organized in a BDD structure that supports behavior-driven development (BDD). It often looks like this:
Are used to make sure that tested variables contain the expected value. They usually look like one of these:
They are also really good in reporting issues when an unexpected value is returned. Instead of just failing, you get information about the structure of objects and exactly what is the difference between the expected object and the one the test actually outputs:
TIP: Here is a nice article about advanced Jasmine and Jest assertions.
Attached to functions to provide extra information about them. For example, how many times a function was called, in which cases, by whom, what arguments were passed to it in each call?
Spies are used in integration tests to make sure that the side effects of a process or flow are expected. For example, how many times was a calculation function like
execute called in the following case?
Replaces selected methods of existing modules with user-supplied functions in order to ensure expected behavior during the test.
In many libraries, for example in
jest, it can easily be done on functions you spy on.
For example here, we spy on
isValid during the test, and unsubscribe after each test to make sure we don’t pollute the
Used to fake certain modules or behaviors to test different parts of a processes.
Sinon can, for example, fake a server to ensure offline, fast and expected responses when testing a certain flow.
Allows you to compare a data structure to what it was in older releases.
The following example, from the official Jest documentation, shows a snapshot test of a certain
It doesn’t actually renders and takes a picture of the component, but it saves its internal data in a separate file like this:
When the test runs, and the new snapshot differs from the last one, the developer is prompted to confirm that the change is intended.
Notice: Snapshots in Jest usually compare component representation data but they can also compare other types of data, like redux store states or the inner structure of different units in the application.
There are several ways to control browsers to simulate user behavior, like clicking the mouse, drag and dropping, typing, and navigating.
- A relatively new way of controlling browsers quickly became popular in the latest years. Browser maintainers added features to browsers that made them controllable using native APIs. For example puppeteer.
Sometimes a framework might be used to expose the browser’s API in a different way.
Your code on Node.js <> (Maybe a framework) <> Browser's API
- An older way that was used for many years was to install drivers on browsers that control the browser using different methods. This is how selenium works:
Your code on Node.js <> WebDriver <> FF/Chrome/Safari Driver <> Browser
- Another way would be to inject scripts of a JS code that has access to the whole application environment: DOM, network, cookies etc… to raise events that simulate user behavior. Cypress.io uses this approach. For example, here is how you simulate a click:
Putting it All Together
To start testing, you need to choose a testing structure that suits you, choose the style of assertion functions you like, and decide how do you want to run the tests.
I will discuss the tools you can choose from later in the article.
Some frameworks like Jest, Jasmine, TestCafe, and Cypress provide all of these out of the box. Some of them provide only some of the functionality and a combination of libraries can be used. A famous combinations of tools would be: mocha + chai + sinon.
I also suggest creating two different processes. One for running unit and integration tests and another one for E2E Tests. This is because functional tests usually take much longer to run, especially when running the test suite on several different browsers.
Unit and integration tests can run on the fly, as you code, using “watch mode” because they finish running in seconds. On the other hand E2E tests are usually launched before merges and releases. In some companies it takes hours to finish running all the E2E tests.
Should cover all the small pure units of an application- utils, services and helpers. Provide all these units with simple and edge case inputs and make sure outputs are expected using assertion functions.
Also make sure to use a code coverage reporting tool to know which units are covered.
Healthy and proper unit tests are one of the reasons to use functional programming and pure functions as much as possible.
The purer your application is, the easier you can test it.
Old school tests were focused on unit testing and resulted in applications where many small parts were working but the processes as a whole kept on failing.
Integration tests, on the other hand, detect cases where a unit is refactored and passes its tests but a process that depends on it fails.
The best demonstration of why testing more than each part of a system separately is important can be seen in this great GIF.
It’s also important to remember that in the real world, for the reasons of imperfect design and the widespread use of black boxes, not all units are pure and not all units are testable- some units can be tested only as part of a bigger process.
Integration tests should cover important cross-module processes. Sometimes they extend to processes across several classes and sometimes to processes across different systems like Front-End-To-Back-End interactions.
Comparing to unit tests, you would probably benefit from using spies to ensure expected side effects instead of just asserting the output and stubs to mock and modify the parts of the process that are not in the specific test.
Component snapshot tests fall into this category as well. They provide us with a way to test how processes affect selected component structures and data structure without actually rendering them into a browser or a browser-like environment.
Sometimes the quick and effective unit and integration tests are not enough.
E2E Tests (Functional Tests) control browsers and simulate user behavior in the browser (clicking, typing, scrolling etc…) and make sure these scenarios actually work from the point of view of an end user.
Visual regression testing tools can also be set up to verify that the different screens of your applications are ok visually by a smart comparison of screenshots. These screenshots are usually taken as part of your Functional Tests or by executing a separate session of browser automation.
List of General Prominent Testing Tools
There are dozens of great tools out there. I couldn’t include all of them here but I tried to include the most important to know, best maintained , and the most adopted tools in the following list:
As mentioned before, in this simulated browser environment, tests would run really fast. The drawback of jsdom is that not everything can be simulated outside a real browser (you can’t take a screenshot for example) so using it will limit your test’s reach.
It’s worth mentioning that the JS community rapidly improves jsdom and the current version is very close to support whatever exists on a real browser.
Storybook: UI component explorer for frontend developers
"Storybook is a powerful frontend workshop environment tool that allows teams to design, build, and organize UI…
While not, strictly speaking, a testing tool, Storybook lets you write components in special “stories” which enable developing and interacting with components in isolation.
Testing Library · Simple and complete testing utilities that encourage good testing practices
The Testing Library family of libraries is a very light-weight solution for testing without all the implementation…
Simple and complete testing utilities that encourages good testing practices. It is developed by Kent C. Dodds who is a testing guru. I suggest having a look at his work to learn more about best practices in testing websites.
The library provides special tools for different frameworks like React, Preact, React Native, Marko, Angular, Vue, and Svelte. The most famous of them is React Testing Library which is very widely adopted.
It also helps with E2E testing tools like Cypress, Puppeteer, Testcafe, and Nightwatch that would all be discussed next.
It helps with convenient selectors, firing events, configuration, dealing with asynchronous code, and many more.
Testing tools like Cypress.io use Electron to launch tests with maximum control of the browser.
Istanbul will tell you how much of your code is covered with unit tests. It will report on statement, line, function and branch coverage in percentages so you will understand better what is left to cover.
The main goal for Karma is to bring a productive testing environment to developers. The environment being one where…
Karma hosts a test server with a special web page to run your tests in the page’s environment. This page can be run across many browsers and browser-like environments including jsdom.
chai — BDD / TDD assertion framework for node.js and the browser that can be paired with any testing framework.
Chai is the most popular assertion library. It has many plugins and extensions.
Unexpected is an assertion library with a slightly different syntax from Chai. It is also extensible so assertions can be more advanced with libraries that are based on it like unexpected-react that you can read about more in depth here.
testdouble is a less popular library that does what Sinon does, and claims to do it better. It has a few differences in design, philosophy, and features that could make it useful in some cases. I suggest learning it for the sake of understanding how these libraries work in principle.
Wallaby is another tool worth mentioning. It is not free, but many users recommend buying it. It runs on your IDE (it supports all major ones) and runs tests that are relevant to your code changes and indicates if anything fails in real time alongside your code.
Cucumber help with writing tests in BDD by dividing them between the acceptance criteria files using the Gherkin syntax and the tests that correspond to them.
Tests can be written in a variety of languages that are supported by the framework, including JS, which I focus on:
Many teams will find this syntax more convenient than TDD.
Choose Your Unit and Integration Tests Framework
The first choice you should probably make is which framework you want to use.
* you can’t go wrong with Jest. It has nice approval ratings, it’s very fast, clear and has many features in case you need to cover complex scenarios. If you want to “just get started”, go Jest.
* If you want a very flexible and extendable configuration, go with Mocha.
* If you are looking for simplicity go with Ava.
* If you want to be really low-level, go with tape.
Here is a list of the most prominent tools with some of their characteristics:
Jest is the testing framework created and maintained by Facebook. It spiked in popularity and became the most popular testing library in 2017 and stayed in the first place since then.
It was initially based on Jasmine which I will discuss later. Over time, Facebook replaced most of its functionality and added a lot of features on top of it.
- Performance- First of all Jest is considered to be faster for big projects with many test files by implementing a clever parallel testing mechanism.
- UI- Clear and convenient.
- Ready-To-Go- Comes with assertions, spies, and mocks that are equivalent to libraries that do the same like Sinon. Libraries still can easily be used in case you need some unique features.
- Globals- Like in Jasmine, it creates test globals by default so there is no need to require them. This can be considered bad since it makes your tests less flexible and less controllable, but in most cases it just makes your life easier:
- Snapshot testing- jest-snapshot is developed and maintained by Facebook, although it can be used in almost any other framework as part of the framework’s integration of the tool or by using the right plugins.
- Great modules mocking- Jest provides you with an easy way to mock heavy modules to improve testing speed. For example a service can be mocked to resolve a promise instead of making a network request.
- Code coverage- Includes a powerful and fast built-in code coverage tool that is based on Istanbul.
- Reliability- Since it has a huge community, and used in many very complex projects, is is considered very reliable.
- Support- It is currently supported by all the major IDEs and tools.
- Development- jest only updates the files updated, so tests are running very fast in watch mode.
Jasmine is the testing framework that Jest is based on. Why would you prefer Jasmine over Jest? It has been around for longer and it has a huge amount of articles, tools, and questions answered in various forums that were all created by the community over many years.
- Ready-To-Go- Comes with everything you need to start testing.
- Globals- Comes with all the important testing features in the global scope.
- Community- It has been on the market since 2009 and gathered a vast amount of articles, suggestions and tools that are based on it.
- Angular- Has widespread Angular support for all its versions and it is recommended in the official Angular documentation.
Mocha was the most used testing library until 2019 (moving to be at second place after Jest). Unlike Jasmine or Jest, it is only a test runner so it has to be used with third party assertions, mocking, and spying tools (usually Sinon and Chai).
This means Mocha is a little harder to set up and divided into more libraries but it is more flexible and open to extensions.
For example, if you want special assertion logic, you can fork Chai and replace only Chai with your own assertion library. This can also be done in Jasmine but in Mocha this change will be more clear, expected, and obvious.
- Community- Has many plugins and extension to test unique scenarios.
- Extensibility- Very extensible, to the point where plugins, extensions and libraries are designed only to run on top of it.
- Globals- Creates test structure globals by default, but obviously not assertions, spies and mocks like Jasmine. some people are surprised by this seemingly inconsistency of globals.
Ava is a minimalistic testing library that runs tests in parallel.
- Ready-To-Go- Comes with everything you need to start testing (besides spying and dubbing that you can easily add). Uses the following syntax for test structure and assertions, and runs in Node.js:
- Globals- As you can see above, it does not create any test globals, so you have more control over your tests.
- Simplicity- Simple structure and assertions without a complex API while supporting many advanced features.
- Development- Ava only updates the files updated so tests will run fast in watch mode.
- Speed- Runs tests in parallel as separate Node.js processes.
- Snapshot testing is supported as part of the framework.
Tape is more low-level than the other test runners we saw. It’s just a JS file you run using node with a very short and “to-the-point” API.
- Simplicity- Minimalistic structure and assertions without a complex API. Even more than Ava.
- Globals- Does not create any test globals so you have more control over your tests.
- No Shared State between tests- Tape discourages the use of functions like “beforeEach” to ensure test modularity and maximum user control over the testsing cycle.
- No CLI is needed- Tape will simply run anywhere JS can run.
E2E Testing Tools
The tools for the purpose of functional testing differ from each other in their implementation, philosophy, and API. Therefore it is strongly suggested to invest time in understanding the different solutions and testing them on your product.
* In short, if you want to “just get started” with a convenient UI, clear documentation, cool tools and overall fun all-in-one tool E2E Testing experience go with Cypress.io.
* If you prefer older and more time-proven tools, you can “just get started” with Nightwatch.js.
Selenium and Selenium based tools have dominated the market of E2E Tests for years. It is not written specifically for testing and can control a browser for many purposes by using a driver that controls browsers using add-ins and browser extensions.
Node.js <=> WebDriver <=> FF/Chrome/IE/Safari drivers <=> browser
Selenium WebDriver can be accessed in many different ways and using a variety of programming languages, and with some tools even without any real programming.
The WebDriver can be imported into your testing framework and tests can be written as part of it:
The WebDriver itself might be sufficient for you and indeed some people suggest using it as is, but various libraries were created to extend it either by forking and altering it or by wrapping it.
Wrapping the WebDriver might result in a more clear API but might also add redundant code and could make debugging harder, whereas forking it might diverge it from the very active ongoing development of the WebDriver.
Still, some people prefer to not use it directly. Let’s look at some of the libraries for selenium:
Headless Chrome is just a regular Chrome v59+ that is launched with the
Here it is worth mentioning that Firefox has also released their headless mode at the end of 2017.
Notice that different testing tools can also use Headless Chrome and Firefox. For example TestCafe, Karma, and Cypress.
- Puppeteer is maintained by Google and has a big community that uses and develops tools and wrappers around it.
- Since it is native and uses the latest Chrome engine, it is very fast.
- One major drawback of Headless Chrome (thus of Puppeteer as well) is that it doesn’t support extensions like Flash and probably won’t in the near future.
- Notice that this tool doesn’t come with a build-in testing system. Tools like mocha and chai can be used to create the necessary testing environment and structure around this library.
Playwright is a Node library to automate the Chromium, WebKit and Firefox browsers with a single API. It enables…
Playwright is like Puppeteer extended to more browsers. It is developed by Microsoft by the team that originally developed Puppeteer.
It’s worth mentioning that since the library is pretty fresh (It was released in January 2020), breaking changes may be made in the near future and some things might not work or be documented as expected at the moment.
- Cross Platform
- Supports multiple tabs
- Pretty new
Protractor is a library that wraps Selenium and provides us with improved syntax and special built-in hooks for Angular.
- Angular- Has special hooks, although it can successfully be used with other JS frameworks too. Angular official documentation suggests using this tool (UPDATE: No longer. see the message above).
WebdriverIO — Selenium 2.0 bindings for NodeJS
A nodejs bindings implementation for selenium 2.0/webdriver.
It is an open source JS project that is used in JS environments (while selenium can be used with many programming languages).
- Syntax- very easy and readable.
- Flexible- A very simple, flexible, and extensible library.
- Community- It has good support and enthusiastic developer community.
- Applitools support, which is a visual regression library we will discuss later.
Write efficient and straightforward end-to-end tests in Node.js which run against a Selenium/WebDriver server.
Nightwatch has its own implementation of the selenium WebDriver. And provides its own testing framework with a test server, assertions, and tools.
- Framework- Can be used with other frameworks too, but can be especially useful in case you want to run E2E tests, not as part of another framework.
- Syntax- looks the easiest and the most readable.
- Support- No typescript support and in general, this library seems to be slightly less supported than the others.
Apium provides an API similar to Selenium for testing websites on a mobile device using the following tools:
- iOS 9.3+: Apple’s XCUITest
- Before iOS 9.3: Apple’s UIAutomation
- Android 4.2+: Google’s UiAutomator/UiAutomator2
- Android 2.3+: Google’s Instrumentation. (Instrumentation support is provided by bundling a separate project, Selendroid)
- Windows Phone: Microsoft’s WinAppDriver
So if you use Selenium or Selenium-based tools, you can also use Apium to test on mobile devices.
Automated browser testing for the modern web development stack | TestCafe
TestCafe is a simple and powerful framework for testing websites and apps. It allows you to easily create, maintain and…
TestCafe is a great alternative to Selenium-Based tools. It was rewritten and open-sourced at the end of 2016.
- Fast to set up- Npm install and run your first test on any browser you want.
- Cross Browser and Devices- Supports many browsers and devices and can be used with SauceLabs or BrowserStack which provide devices and browsers for your tests. This includes running of tests in Headless Chrome and Headless Firefox which will be discussed later.
- Parallel Testing- TestCafe can run your tests on several browser instances at once. This practice can significantly decrease your testing time.
- Convenient Error Reporting
- Own Ecosystem- TestCafe uses its own test structure. It could be quite convenient, especially because UI tests usually run separately from other tests, but some people dislike it.
Fast, easy and reliable testing for anything that runs in a browser. Install Cypress in seconds and take the pain out…
Cypress is a direct competitor of TestCafe. They are doing relatively the same, which is injecting tests into a website, but they try to do it in a more modern, flexible and convenient way.
The difference between them is that Cypress.io runs itself in the browser and controls your tests from there where TestCafe runs in Node.js and controls the tests through a serialized communication with its injected script in the browser.
Parallel testing was introduced in version 3.10.
- Documentation- Solid and clear.
- Native access to all your application’s variables without serialization (TestCafe on the other hand turns objects to JSON, sends them to Node.js as text and then parses them back to objects).
- Very convenient running and debugging tools- Easy debugging and logging of the test process.
- Cross-browser Support- since version 4.0.
- Some use-cases are missing but in constant development such as lack of HTML5 drag-n-drop.
- Using Mocha as the test structure provider makes its use pretty standard and allow your E2E tests to be built in the same structure as the rest of your tests.
Like CucumberJS which was discussed above, Codecept provides another abstraction over different libraries’ API’s to make your interactions with tests use a slightly different philosophy that focuses on user behavior.
Here is how it looks:
And here is the list of libraries that can be executed using this code. All discussed above.
If you believe this syntax is better for your needs, give it a shot.
NOTICE: Its main maintainer, Vitaliy Slobodin, no longer works on it, and its development was suspended and its repository archived.
Nightmare is an E2E Testing library that uses Electron which uses Chromium to control the browser.
Doesn’t seem to be maintained. Probably because of the introduction of “Puppeteer” as well which provides you with the same features out of the box.
Visual Regression Testing
The visual regression testing tools are consists roughly of the following:
- Techniques and integrations to automate the browser or to run as part of E2E Testing tools discussed above, including in the CLI for CI.
- Take smart screenshots as images and as DOM snapshots.
- Images and DOM comparison techniques to spot differences sometimes even using advanced AI.
- UI for humans to approve, reject and improve the comparison mechanism to only show what’s relevant for the user.
There are a lot of tools of this type in the market, but it feels like this field still has a long way to do.
Also, I noticed that paid tools in the visual regression testing category are much better than the free ones.
Applitools is an application visual management and AI-powered visual UI testing and monitoring software. Use our visual…
- Easy to set up.
- Uses AI to make the comparison technique and human input regarding differences and negation of false positives very powerful.
- It can be integrated conveniently with many of the tools discussed above.
- Has a free and paid flexible plans, including special pricing for startup companies and non-profits.
- Easy to set up.
- Uses smart comparison techniques.
- Convenient human input regarding differences.
- It can be integrated conveniently with many of the tools discussed above.
- It has great integrations with great tools.
- Have free and paid flexible plans.
Happo.io — Cross-browser screenshot testing
Happo is a cross-browser screenshot testing service. Prevent visual regressions, visualize your UI changes, and keep a…
Happo is a paid visual regression testing tool. It hooks into the CI to compare the visual appearance of UI components before and after a change.
Screenshots can be taken in different browsers and across different screen sizes to ensure consistent cross-browser and responsive styling of your application.
Paid with a free plan for open source projects.
Node.js library for comparing images. Contribute to gemini-testing/looks-same development by creating an account on…
Yandex now migrated to hermione that runs tests using WebdriverIO and Mocha.js and uses LooksSame for visual regressions. It is more simple and limited than the paid tools mentioned above, but for simple websites, it can be enough.
LooksSame can also be used on it’s own as long as you generate screenshots in any way you like.
Catch CSS curve balls. Contribute to garris/BackstopJS development by creating an account on GitHub.
An open source visual regression utility that runs on Chrome Headless with Puppeteer and CI support.
Uses selenium docker to create visual regression tests on Chrome / Firefox.
recycle: Visual Regression Testing tool. Contribute to reg-viz/reg-suit development by creating an account on GitHub.
An open-source library that compares images, generates reports and saves them on the cloud. Very convenient if you want to add visual regression tests to an existing E2E Test. Simply add steps of taking screenshots to your existing test flow and use it to compare these screenshots.
Differencify is a library for visual regression testing — NimaSoroush/differencify
Another open-source Chrome Headless using Puppeteer testing tool with nice integrations with Jest snapshots. Can run in docker and generates convenient reports.
No Coding E2E Testing Tools
Testim.io | Agile, Self-Healing, Autonomous Testing Solution
Testim uses machine learning automation testing to improve the testing around your software by integrating with all…
Opens your application in a separate window and uses a browser extension to record your manual interactions with the application as test scenarios.
Uses machine learning to help you record and validate test scenarios. Cross Browser and has some nice integrations with many CI and Collaboration tools.
Have free and paid flexible plans.
Chromatic is a visual testing tool for Storybook made by Storybook maintainers.
Diff Detector renders the UI of each story and takes a visual snapshot. If anything changes, you are prompted to accept the visual changes locally and as part of the project’s pipelines.
Screener.io: Automated Visual Testing
Screener is a cloud-based automation platform for visual and functional UI testing. Test your web applications and UI…
Lets you record your tests using a chrome extension, has in-depth visual regression reporting. Has some nice integrations like with storybook different CI tools and BrowserStack and Sauce Labs.
Other tools of this type (you are free to suggest more in the comments):
We reviewed the most trending testing strategies and tools in the web development community and hopefully made it easier for you to test your sites.
In the end, the best decisions regarding application architecture today are made by understanding general patterns that are trending in the very active community of developers, and combining them with your own experience and the characteristics of your application.
Oh, and writing, and rewriting, and rewriting, and rewriting, and testing different solutions :)
Happy testings :)
- If you consider Puppeteer cool, then Playwright is awesomeness 😍 (January 2020)
- Playing with Playwright (February, 2020)
- E2E Tests: Integrating Microsoft Playwright with mocha and chai (January, 2020)
- Playwright Launch (January, 2020)
- Top UI Test Automation Best Practices You Should Follow (November 2017)
- Introduction to Headless Browser Testing (September 2017)
- How to set up E2E browser testing for your GitHub project (With TestCafe) (February 2017)
- Top 12 Browser Compatibility Testing Tools (June 2017)
- Top 10 Cross Browser Compatibility Testing Tools In 2019 (2019)
- Bye-Bye, Sinon — Hello, testdouble (March 2016)
- testdouble.js vs. sinon.js (March 2016)
- enzyme vs unexpected-react (April 2017)
- React Testing — Jest or Mocha? (May 2017)
- How to Snapshot Test Everything in Your Redux App With Jest
- The Hidden Power of Jest Matchers (January 2017)
- Testing React components with Jest and Enzyme (December 2016)
- Snapshot Testing React Components with Jest (January 2017)
- Testing an AngularJS app with Jest (October 2016)
- Effortless unit testing with AVA (April 2016)
- Why I use Tape Instead of Mocha & So Should You (July 2015)
- Learn Tape
- Hybrid Application Testing with Protractor and Appium (March 2017)
- Headless Chrome vs PhantomJS Benchmark (September 2017)
- Protractor vs WebdriverIO vs NightWatch (November 2016)
- End to End (e2e) Testing React Apps With Selenium WebDriver And Node.js is Easier Than You Think (April 2016)
- Node.js End-to-End Testing with Nightwatch.js (March 2017)
- Nightmare of End-to-End Testing (September 2016)
- Protractor vs WebdriverIO vs NightWatch (November 2016)
- Stack Overflow- What is the difference between nightwatch.js And webdriver.io? (March 2016)
- What is PhantomJS and How is it Used? (June 2016)
- Setting up End-to-End Testing in Angular Project with CodeceptJS (December 2017)
- Which automated testing tool to pick — Testcafe or Selenium WebDriver? (January 2016)
- Introducing TestCafe — Open Source Testing Framework (Octobeer 2016)
- Why not use Selenium? (October 2016)
- Functional Testing With TestCafe (March 2017)
- UI Test Automation Frameworks Showdown: TestCafé versus Nightwatch.js (February 2018)
- Cypress: The future of end-to-end testing for web applications (February 2018)
- Evaluating Cypress and TestCafe for end to end testing (March 2018)
- Robo-Testing your Website Without Writing Code (October 2016)
- Cypress vs WebdriverIO: Key Differences (August 2021)
- Migrating Nightwatch Tests to Cypress (January 2021)
Older versions of this article: