kentoh - Fotolia
Continuous testing is the Ferris wheel of automated and manual QA tests. Like a well-maintained Ferris wheel, testing efforts carry on at a consistent pace without racing out of control.
Continuous testing is about managing and developing a collection of test cases -- also called a test suite -- in a way that they can execute nonstop during and after new development. Think of it as ongoing smoke and regression test execution, always trawling for bugs, either from new code or from regression defects in existing code.
Agile software development puts new code in front of QA rapid-fire, without long test execution cycles. Continuous testing must keep up with this continuous development cycle. The most effective way to keep pace is to break up tests into the smallest possible actions, but testers can struggle to understand how to cover a full workflow -- or perform end-to-end system tests -- when they break test stories into tiny pieces. Continuous testing in Agile environments provides a way to execute a full range of testing types and coverage without sacrificing time or quality.
Tiny tests never stop
Tests are split into small, user story-sized pieces as the developers deploy code. The biggest advantage of Agile development is that QA finds errors faster and earlier when it tests tiny pieces of code rather than large implementations with unclear interactions and dependencies. Another advantage of testing tiny is, if an item fails, the project is held back until the issue is fixed and passes testing. Therefore, QA testers are not at odds with developers trying to bury defects to get to a finished product. Quality is built in by default with tiny testing.
Testing tiny also enables workflow and end-to-end test cases to evolve alongside code development. Development and testing remain in sync, so there's no bottleneck after development and before release. With continuous testing in Agile, QA testers continuously circle back to the beginning of a sequence of stories and re-execute the group. Testing the project code from the first story to the last naturally increases coverage, one tiny test at a time; eventually, these tests build a workflow test case suite. Each tiny test combines to create integration, regression, security and other test types during the development process.
Over time, the QA test suite comprises functional groupings of stories that link together to test complex integration and user workflows. Consider this natural combination of stories into a test suite as a tiny grouping.
Increase test coverage and efficiency
To create tiny groupings, arrange the tests you develop and execute for individual user stories, like application functions, together. For example, a QA testing project has 25 stories in progress with developers. Those stories come through in a preferred order, either based on code requirements or by product management that prioritizes crucial functions. Testers group each story into functions. The 25 stories yield a full workflow that can be manipulated to cover various possible user scenarios. Testers can add integration points to increase test coverage without any work necessary on the specific cases. Test execution is as simple as continuously executing the story suite by function, as the team completes the project. Continuous testing in Agile does not require any additional test planning, development or execution cycles.
In the Ferris wheel analogy, new user stories are the passengers on the wheel. Each time testers add or remove stories in a continuous testing cycle, it pauses continuous testing progress, but the process to find defects as stories develop remains the same and resumes quickly. The wheel keeps turning, regardless of dates, workload or releases to production. Testing covers the entire application, without separate efforts branching off in new directions.
Ferris wheel vs. roller coasters
The continuous testing Ferris wheel spins at a consistent rate. By contrast, traditional QA testing is a roller coaster.
In traditional testing, stories get developed and built up, but then their requirements veer in a new direction. Eventually, code comes crashing downstream to QA at a high speed. QA tests can add twists and turns to code development, as defects slow the process and lead to more work.
QA testers try to plan test development and execution schedules, while development starts climbing another metaphorical hill of features and user stories. As a result, much-needed QA testing often gets shortened or skipped, as the team instead must brace for the next drop or wild turn to keep development on track.