Types of Testing

Acceptance testing

This type of testing is done to determine if a feature or system meets the customer expectations and requirements. This type of testing generally involves the customer’s cooperation or feedback, being a validation activity that answers the question:

Are we building the right product?

For web applications, the automation of this testing can be done directly with Selenium by simulating user expected behaviour. This simulation could be done by record/playback or through the different supported languages as explained in this documentation. Note: Acceptance testing is a subtype of functional testing, which some people might also refer to.

Functional testing

This type of testing is done to determine if a feature or system functions properly without issues. It checks the system at different levels to ensure that all scenarios are covered and that the system does what it’s supposed to do. It’s a verification activity that answers the question:

Are we building the product right?

This generally includes: the tests work without errors (404, exceptions…), in a usable way (correct redirections), in an accessible way and matching its specifications (see acceptance testing above).

For web applications, the automation of this testing can be done directly with Selenium by simulating expected returns. This simulation could be done by record/playback or through the different supported languages as explained in this documentation.

Integration Tests

Integration tests verify the interactions between different components or modules of a system. Several modules are together tested. The purpose of Integration tests is to make sure that all modules integrate and work together as expected. Automated integration tests help ensure that these interactions work as expected and that integrated components function properly together.

For example, Testing the flow of placing the order for an item in an ecommerce website along with payment.

System Tests

System Testing is a complete fully integrated product Testing. It is an end-to-end testing where in testing environment is similar to the production environment. Here, we navigate through all the features of the software and test if the end business / end feature works. We just test the end feature and don’t check for data flow or do functional testing and all.

For example, Testing the end to end flow from login to placing an order and rechecking the order in My Orders page and logoff from an ecommerce website.

Performance testing

As its name indicates, performance tests are done to measure how well an application is performing.

There are two main sub-types for performance testing:

Load testing

Load testing is done to verify how well the application works under different defined loads (usually a particular number of users connected at once).

For example, Testing that the site can handle numerous orders/users at once.

Stress testing

Stress testing is done to verify how well the application works under stress (or above the maximum supported load).

For example, Testing that your ecommerce site can handle Black Friday

Generally, performance tests are done by executing some Selenium written tests simulating different users hitting a particular function on the web app and retrieving some meaningful measurements.

This is generally done by other tools that retrieve the metrics. One such tool is JMeter.

For a web application, details to measure include throughput, latency, data loss, individual component loading times, etc.

Note 1: All browsers have a performance tab in their developers’ tools section (accessible by pressing F12)

Note 2: is a subtype of non-functional testing as this is generally measured per system and not per function/feature.

Regression testing

This testing is generally done after a change, fix or feature addition.

To ensure that the change has not broken any of the existing functionality, some already executed tests are executed again.

For example, Testing that your new search bar doesn’t break the other buttons on the menu

The set of re-executed tests can be full or partial and can include several different types, depending on the application and development team.

Test driven development (TDD)

Rather than a test type per se, TDD is an iterative development methodology in which tests drive the design of a feature.

Each cycle starts by creating a set of unit tests that the feature should eventually pass (they should fail their first time executed).

After this, development takes place to make the tests pass. The tests are executed again, starting another cycle and this process continues until all tests are passing.

This aims to speed up the development of an application based on the fact that defects are less costly the earlier they are found.

Behavior-driven development (BDD)

Behavior-Driven Development (BDD) is an iterative methodology inspired by TDD that focuses on defining system behavior through shared examples. It emphasizes collaboration between business stakeholders, developers, and testers to ensure a common understanding of requirements.

Development begins by defining specifications in a ubiquitous language, commonly expressed using Gherkin. These specifications describe expected behavior and serve as acceptance criteria. Scenarios may initially fail when automated, guiding development until the behavior is implemented.

BDD scenarios are supported by underlying code and tests, which may include: unit, integration, or UI-level automation. Tools such as Cucumber and SpecFlow enable mapping specifications to executable code, often integrating with automation tools like Selenium.

The primary goal of BDD is to prevent misunderstandings and acceptance-level defects by ensuring the right software is built from the start. In common practice, Selenium is integrated with BDD frameworks to automate browser-based behaviors described in BDD scenarios. In this setup:

BDD frameworks such as: Cucumber, JBehave, Capybara and Robot Framework are responsible for parsing and managing specifications Step definitions act as the bridge between human-readable scenarios and executable code

Selenium as the automation engine to perform browser interactions can be used in combination with the frameworks mentioned above as an optional dependency that enables UI automation when browser-level validation is required.