Most applications today are designed with a service-oriented architecture structure. The application is interconnected with many subsystems that can be outside of the application environment.
If there’s a failure in any of the subsystems, it can cause the entire application to crash.
So to make sure everything is working fine, we need to test the entire flow of an application from start to finish (or end-to-end).
E2E testing mainly serves two purposes:
- To test the entire application for major business components such as communicating with the other systems, interfaces, databases, networks, and other applications.
- To create a complete production-like scenario and test happy flow, so that we can simulate real-time settings and environment and avoid any application crash.
Why Do We Need End-to-End Testing in Agile?
In each sprint, both the dev and test teams focus on a single service out of all the integrated services used in an application. But there are chances that they missed out on the sub-systems or services that could potentially break.
Therefore, the QA team must make sure that specific changes in a single service don’t affect the entire workflow.
How Is E2E Testing Different From Traditional Testing?
Traditional testing comprises Unit, Integration, System, and UAT. But End-to-end testing is started after System testing.
Sometimes we get confused between System/Unit/Integration testing and end-to-end testing. But these are quite different.
Here’s a short example for some clarity — let’s assume we have an application with three subsystems:
In the current sprint, requirement specification changes in the payment subsystem are: Adding new payment options should be visible to the customers.
So as per the requirement, System testing will take care of the functionality related only to the newly added payments option.
But end-to-end testing will have the scenarios starting from Search to Payment (with newly added payment option) with the Order confirmation.
The scope, complexity, and maintenance of E2E testing are higher than that of the Unit and Integration testings.
So while preparing test cases and automation scripts, it’s always better to first understand the application architecture with the complete happy flow so that it will be easy to define the coverage.
Who Can Perform E2E Testing?
E2E testing should be performed by someone who has in-depth knowledge of application and aware of the product architecture. So apart from QA, a business analyst, client, product owner or even technical manager are good candidates to perform E2E testing.
End-to-End Testing Methods:
Horizontal E2E Testing
It works through every phase of business workflow and ensures that the functional requirement document maps with the developed application.
A horizontal end-to-end test verifies each and every workflow through individual applications from start to finish ensuring that each interrelated process works correctly. In general, this type of testing takes place at the end of the release cycle and in a stable environment setup. So with this approach, we can get more coverage on the functional part but it cannot be performed until all release changes are fully implemented.
Vertical E2E Testing
This method refers to testing in layers, tests happen in sequential, hierarchical order. Vertical testing used to test each component separately and thoroughly, and it is more part of SDLC. The most common approach to performing this is BDD, TDD, and CI-CD.
The best way to achieve it by performing unit tests for each component and then perform testing on network infrastructure, API integration, and UI layers. So by using this we can get high coverage of testing for the core code. As it can be implemented in stages so easy to find defects respective to each stage.
Steps for End to End Testing Process
These are the steps essential to E2E testing:
Requirements Analysis: Analyze the requirement thoroughly and cover major business components in the E2E workflow.
Environment Set-Up: Set up a test environment keeping the production environment details in mind. Try to make it as similar to the production in terms of software and hardware requirements.
Sub-Systems: Make sure that all the sub-systems are part of E2E flow.
TestCase Design: Design test cases with maximum coverage and add test data to test common user scenarios. Focus on functionality of high priority, and design more elaborate test cases to verify it.
Execution: Execute the entire E2E test suite and then analyze the results. Never forget to run a suite in the proper sequence. If required, execute the E2E scenario in multiple browsers.
Maintain Order: Since E2E testing comprises the entire application, test cases are more complex than functional test cases. Each component of the system has to be tested, which increases failure percentage. Structure and sequence of execution are very crucial in E2E testing. Conduct unit tests and integration tests first to resolve the initial level of errors. Once end to end testing begins, simultaneously run the smoke and sanity tests with high-risk user scenarios.
How To Make E2E Testing in Agile More Efficient
Try to automate the E2E test cases with maximum coverage.
- Keep the E2E automation suite separate from Smoke, Sanity, and BVT.
- Execute E2E suite before any sprint release to make sure that the happy flow of the application is working as expected and new changes don’t have any impact on the subsystems of the product.
- Integrate the E2E suite with CI/CD pipeline using any tool like Jenkins.
- As E2E suites take time to execute so create Jenkins job and schedule it at night so that all the failed test cases can be analyzed in the working hours.
- Every so often, E2E does contain some cross-browser and parallel testing too, so in that case, try to take advantage of Selenium Grid with Docker. Use Docker containers for different browsers and execute the test cases in parallel using TestNG.
- While running the E2E automation suite, it is required to create an environment similar to production and need to avoid any environment level issue, so to achieve this, you can use Docker containers.
E2E Test Deliverables
The E2E test team will create the following work products:
- Test cases with detailed steps for the E2E test suite.
- Enterprise test automation framework configured for the application.
- Automated test execution reports and defects encountered during the End-to-End test suite.
- The requirement traceability matrix will ensure that the entire requirement on the E2E workflow.
- Transactional test data generated during test execution.
- Documentation and manuals.
- Script coding and management standards.
- Script Development/Execution tracker.
- Functional Issue log tracker.
- Workflow diagram of the application.
- Ensure maximum coverage with data, process, and the logic behind the functional workflow.
Benefits of End-to-End Testing
Ensures Stability and Quality of Product
Since the application is tested at different layers like data, business, integration, and presentation, it ensures the stability and quality of the application.
Increases Confidence on E2E Business Workflow
End-to-end testing increases the confidence in the functional flow and performance before its release as the application is validated across all endpoints for different devices, browsers, platforms.
Frequent Testing Reduces Risks
As the application is tested in every iteration and sprints, it reduces the chances of any major bugs.
Reduces Repetitive Testing Efforts
End-to-end testing reduces the occurrences of frequent breakdowns and thus reduces repetitive testing efforts.
Costs Effective and Less Time
Implementing E2E testing reduces error recurrence in the later stage of product development, so fixing those issues during the early phase of the SDLC saves lots of budgets. As in E2E we make sure of the major business flows so by performing it we can avoid all major issues which can be a blockage for sprint release. Automation of the end-to-end test allows quickly adapt changing business requirements and enhance agility to the testing project.
The objective of end-to-end is to verify system integration with the functional flow. Thus, while testing any application, it is important to note that the user interface or presentation layer is not the only area to be focused but the underlying data, processes, and logic behind the application’s behavior need to be verified too. The connected systems and integrations are equally relevant to assure the quality of the application in terms of frontend, backend, functional flow, and integration.