Automation

Type of testing

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

1. 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.
2. 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.

1. 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.
2. 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.
3. Regression Tests:
   Regression tests run a combination of Functional and Non-functional tests to check if the software has “regressed” after a given change.
4. 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.
5. 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.
6. 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

1. 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.
2. 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.
3. 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

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.

1. 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.
2. 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.
3. 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

Frameworks we use