Continuous testing is the process of incorporating automated feedback at different stages of the software development life cycle (SDLC) in support of better speed and efficiency when managing deployments.

Continuous testing is a critical driver behind the effectiveness of CI/CD (continuous integration/continuous delivery) processes and plays a crucial role in accelerating SDLC timelines by improving code quality, avoiding costly bottlenecks, and expediting DevOps processes.

One of the fundamental principles in developing a practical DevOps approach is to bridge the gap between rapid software delivery and reliable user experiences. However, the conventional way of manually gaining feedback at each software development stage (i.e., project design, coding, testing, deployment, and maintenance) has led to an insufficient and ineffective use of organizational resources and, ultimately, longer integration cycles and delayed product updates.

Continuous testing addresses these inefficiencies by helping DevOps teams "shift left," providing them with valuable feedback early in the SDLC while automating manual testing processes and minimizing human error.

Continuous testing works by using automated tools to load pre-defined QA scripts at all stages of production. These automated scripts eliminate the need for regular human intervention when running QA tests and sequentially validate source code efficiencies while ensuring any relevant feedback is immediately provided to the appropriate teams.

If automated tests fail, development teams are notified at that individual stage of development so they can make the necessary adjustments to their source code “before” it impacts other teams at different stages of the SDLC. If automated tests pass inspection, projects are automatically passed on to the next stage of the SDLC, giving organizations the ability to create a sustainable delivery model that maximizes productivity and improves interdepartmental coordination.

In the following video, Eric Minick goes further into the topic:

Incorporating continuous testing into DevOps processes provides several benefits to growing enterprises.

Better efficiency and higher-quality deployments. Continuous testing provides an automated method of managing quality assurance and quality interoperation between workflows at each stage of the software development life cycle (SDLC). By integrating continuous feedback loops into user and unit testing modules, developers can receive the actionable insight they need to improve the compatibility and performance of their code before it gets deployed. This efficiency resolves disconnections between multiple DevOps team members and supports accelerated software delivery schedules.

Rapid error discovery and remediation for distributed projects. Today's modern development architectures are multifaceted and multilayered. Continuous testing helps development teams break down these complexities by incorporating a scalable, automated testing solution that significantly improves error discovery and remediation timelines.

Improved user experience. Advanced continuous testing methods can simulate a variety unique use cases and troubleshooting scenarios and observe how users respond to them. The insight gathered from these simulations enables developers to remove the inefficiencies in the user interface earlier and avoid unwanted surprises after the physical product has been deployed.

Reduced costs due to development-related business disruption. Especially in large interconnected systems, an error in just one module of an application can have ripple effects that can cause unwanted downtime, negatively impacting productivity and the bottom line.

Cloud providers, for example, routinely report breakdowns at one end that paralyze an entire region and cause outages lasting several hours. This can be particularly devastating to organizations that are dependent on high service availability. Continuous testing at a granular level identifies errors that might otherwise be invisible in large software systems and helps to avoid the costs of business disruption.

Continuous testing involves a spectrum of tests that ensure system reliability, security, operations performance, and usability. Tests on the spectrum include the following:

• Shift-Left testing: This approach prioritizes software and system testing early in the software development life cycle (SDLC) to help reduce or prevent significant debugging problems down the road.
  
  
• Shift-Right testing: This approach prioritizes testing near the end of the SDLC, with a focus on improving user experience, overall performance, failure tolerance, and functionality.
  
  
• Smoke tests: These tests, which can be manual or automated, provide an initial cursory screening for conspicuous flaws in software. While smoke tests are not elaborate in their construction, they still provide a quick and inexpensive solution for the elimination of gross errors in software.
  
  
• Unit testing: These are ideal for small-scale stress, load, volume, or memory leak checks across builds to identify degradations in early developmental stages.
  
  
• Integration and messaging testing: These check for errors when software modules are working in conjunction with each other. Continuous testing virtualizes missing dependencies so teams can test how well the end-to-end processes and scenarios perform collectively. The composite code is then compiled and executed at run time to test whether they perform as expected.
  
  
• Performance testing: Testing the performance of application software by itself may not take into account the hardware and middleware in the final production environment. Integrated system testing is required to effectively assess the overall performance of the solution.
  
  
• Functional testing: This form of testing checks whether the user experience meets expectations and whether functional workflows execute as needed across a software system. For example, supply chain software should be able to alert trucks to arrive at factories when inventory is available for shipping. (In contrast, non-functional testing focuses on performance, usability, reliability, response time, load time, scalability, etc. and gauges the readiness of the software to deliver the desired customer experience.)
  
  
• Regression testing: This testing checks whether there are any changes in performance, functionality, or dependencies after errors are corrected in any dependent software and that the system performs as before.
  
  
• User-acceptance testing: Also called application testing or end-user testing, this is when the application is tested in a real-world situation by some subset of intended users. Beta testing is an example of user-acceptance testing.

IT systems and applications run a greater risk of errors because of the following characteristics:

• They are increasingly integrated with a host of emerging technologies—e.g., cloud computing, Internet of Things (IoT), software-defined networking, augmented reality (AR)
  
  
• They are increasingly distributed across multiple regions, with a seamlessly interconnected core and edge. Applications for smart cities, autonomous cars, and smart utilities are beneficiaries of such an architecture

In these cases, continuous testing is more demanding because development does not happen in a single location or a company. Third parties, including remote teams, may supply some elements of the system. The system may be integrated with application programming interfaces (APIs). Each development team operates in different IT environments, including legacy software. The physical environment of every one of the teams is impossible to reproduce for continuous testing.

Fortunately, continuous testing can be virtualized to create a testing environment where the entire system can be virtually reproduced in a single interface. A virtualized environment can be reconfigured with ease to test for a different IT system or for one that has been changed to correct errors

In a DevOps environment, continuous testing is performed automatically throughout the software development life cycle (SDLC) and works hand in hand with continuous integration to automatically validate any new code integrated into the application.

Testing tools are preloaded with testing scripts that execute automatically whenever new code is integrated into the application. Typically, the tests start with integration testing and move automatically to system testing, regression testing, and user-acceptance testing.

The tests generate data feeds from each application module, and the feeds are analyzed to ensure that all modules impacted by the new code perform as expected. If a test fails, the code goes back to the development team for correction; then it is reintegrated and the testing cycle starts anew.

Once all tests are passed, the application or project moves to the next stage of the SDLC—typically continuous delivery.

See Andrea Crawford's explanation of DevOps for some background on the topic:

A continuous testing framework is needed for sets of tests to ensure their consistency across modules in an application, their connectors (or APIs and containers), the platforms, their infrastructure, and the scenarios that define their requirements.

The sets of tests can be sequential (e.g., regression tests follow unit tests) or they can be concurrent (e.g., a new iteration of a module is accompanied by a test with corresponding tests for its dependencies).

A continuous testing framework provides a wrapper around the set of tests so that they are applied consistently and prepare the way for automation. Developers want to be sure that the approach they take for a module is not dissimilar from those applied to related modules. When the modules evolve, so do a gamut of tests for interrelated software.

Frameworks provide a standard way to conveniently modify the scripts and functions for testing. Automation will reap gains when the inconsistencies in testing are removed, otherwise it will generate a series of misleading test results.