Quite a lot actually! Typically, automated testing is divided into the type of testing, the type of tests, and the phase of testing. (Please note that some of these may overlap and the classification is often dependent on workflow and preferences).

Type of testing

There are 2 main types, functional and non-functional:

Functional: Which tests the real-world, business application of a software solution. For example, a ride-sharing app like Uber must be able to connect end users to drivers when all conditions are met, at the bare minimum.
Non-functional: Which tests the remaining requirements of the software (for example performance, security, data storage, etc.) With the ride-sharing example, this type of testing will ensure that the app is fast and efficient when performing its most essential functions, like connecting end users to drivers in this case.

Type of tests

Aside from the types of automation testing; Smoke Tests, Integration Tests, Regression Tests, Security Tests, Performance Tests, Acceptance Tests, etc. are also common in the field of test automation.

Smoke Tests:
Smoke tests are a type of Functional test that only covers the most crucial features of a software solution to ensure that it could be further tested without “catching fire,” hence the name Smoke Tests.
Integration Tests:
Integration tests take all the individual pieces and functionalities of a software solution and test them together as a whole to guarantee smooth operation between all of them.
Regression Tests:
Regression tests run a combination of Functional and Non-functional tests to check if the software has “regressed” after a given change.
Security Tests:
Security tests cover Functional and Non-functional tests that screen the software for any vulnerabilities. They reveal weaknesses and any potential exploit in a system.
Performance Tests:
Performance tests are often Non-functional tests that help testers evaluate criteria like responsiveness and stability as the software handles load and stress.
Acceptance Tests:
Acceptance tests are functional tests that determine how acceptable the software is to the end-users. This is the final test a solution must pass before it could be released.

Phase of testing

Unit: As the name implies, this phase tests the individual components, or units, of software. Unit testing is the very first phase of testing, usually done manually by developers before handing the software off to testers, but it could also be automated.
API: Application Programming Interface (or API for short) acts as the “middleman” between all of the systems that your software uses, and thus, is then tested after the development process to ensure smooth integration between systems and software. This phase of testing is fairly flexible; it could be conducted either before or after the UI phase, which we will go over shortly, and by either the development or the testing team.
UI: Last but not least, User Interface (AKA UI) is what the end-users see and interact with and, thus, is usually tested at the very end of the process. This phase of testing is run by testers after the UI of the application has been drafted for the most authentic replication of user experience possible. This is where the business logic of the software is examined and optimized, which also falls under the Functional test classification.

Automation Test Frameworks

Types of Automation Test Framework

Once the types of automated testing used in a project have been determined, an automation test framework is then chosen to help testers organize and standardize the process. The benefits of standardization are clear in many ways. Having an overarching structure and guidelines makes projects more accessible to newcomers which helps teams scale, especially bigger teams where there are potentially tens to hundreds of individual approaches to automated testing. If all of them were implemented haphazardly without any form of control, it would be disastrous for the quality of the product and the success of the team as a whole.

Types of Framework

There are many frameworks to choose from, but here are some of the most common ones.

Linear Framework (AKA Record and Playback):
This is the most basic kind of framework. Testers write and run a test script for each individual test case, like recording and playing back a clip on a screen, hence the name “record and playback.” Because of its simplicity, it is most suited for small teams and test automation beginners.
Modular Based Framework:
As the name implies, this framework organizes each test case into smaller parts called modules, and these modules are independent of each other. Modules of any given scenario are then handled uniformly by a “master script,” saving testers a lot of time and optimizing their workflow. However, prior planning and test automation knowledge are required to successfully implement this framework.
Library Architecture Framework:
Building on top of the Modular Framework, the Library Architecture Framework boasts several advantages over the former. Instead of breaking up the test case, this framework groups similar tasks within the test script into functions and then stores them in a library. Since these functions consist of tasks with common objectives, they can be called upon by the test script whenever a functionality is needed. This kind of structure allows for even greater reusability and flexibility in testing but at the cost of more time writing the script and test automation experience required.

Tools to Use for Your Automated Tests

Top Automation Testing Tools

After choosing the right test automation framework to follow, an automation tool is needed to conduct your tests. Based on specific testing demands, only one or a handful of these popular automation tools may fit your requirements.

Selenium

Undoubtedly, the most popular test automation tool currently available. Selenium is great for testing Web applications and offers flexibility unlike any other tool out on the market. It supports a whole host of programming languages (C#, Groovy, Java, Pearl, PHP, Python, and Scala) and runs on the three most common OS’s (Windows, Mac, and Linux).

Website: https://www.selenium.dev/

Katalon Studio

If comprehensive testing is what you’re looking for then look no further than Katalon Studio. Built on top of Selenium, it leverages Selenium’s best qualities while also enabling testers to do more. Katalon Studio supports Web testing as well as API, mobile, and desktop application testing, truly an all-in-one automation solution.

Website: https://www.katalon.com/

Ranorex

For all of your UI testing needs, Ranorex might prove to be the answer. It is built with usability in mind and supports a wide variety of web, desktop, and mobile platforms. On top of that, Ranorex’s smart object recognition allows tests to continue running even if there are changes mid-test, ensuring ease of mind.

Website: https://www.ranorex.com/

Apache Jmeter

When it comes to performance testing needs, you could do much worse than Apache Jmeter. Supporting Web services and applications, Apache Jmeter can simulate heavy loads on a server, a group of servers or a network to evaluate its strength and how well it can handle different load types; a performance geek’s tool of choice!

Website: https://jmeter.apache.org/

For more detailed tool reviews, please refer to these lists below:

Conclusion

While not exhaustive, we hope that this brief overview of the different types of automation testing and the variety of test automation frameworks have given you a better understanding of test automation. And perhaps you might even try your hands at some of the tools that we have highlighted here. Should you choose to do so, we wish you the best in your testing journey and that you may help others start their own by sharing this article.

Read more