Making the Switch to Agile Testing
Agile involves the whole team, not just programmers. A tester falling behind isn't solely their responsibility.
Join the DZone community and get the full member experience.Join For Free
Sometimes, test teams may be perplexed about how to switch to agile. If you work on such a team, you almost certainly have manual regression tests, both because you’ve never had the time to automate them or because you test from the UI, and it does not make logical sense to automate them. You most likely have excellent exploratory testers who can uncover defects within complicated systems, but they do not automate their testing and require a finished product before they begin testing. You understand how to schedule testing for a release, but everything must be completed within a two-, three- or four-week iteration. How do you pull it off? How do you stay up with technological advancements?
This is a persistent challenge. In many businesses, developers believe they have moved to agile, but testers remain buried in manual testing and cannot “stay current” after each iteration. When I communicate to these professionals that they are only experiencing a portion of the benefits of their agile transformation, developers and testers say that the testers are too sluggish.
Done Means DONE!
The challenge is not because the testers are too slow but because the team cannot own “done,” and until the team owns “done” and contributes to accomplishing it, the testers will look too sluggish. In every iteration, agile teams can deliver a functional product. They are not obligated to release, but the software is expected to be of sufficient quality. That indicates the testing, which is about risk management, is over. After all, how can you release if you don’t know the risks?
Testing provides knowledge about the product being tested. The tests do not establish that the product is perfect or that the engineers are excellent or bad, but instead that the product either does or does not accomplish what we expected to accomplish. This implies that the testing must be consistent with the product. If the product features a graphical user interface, the testing will have to use it at some point. However, there are several strategies for testing inside a system. The approach to test from within the GUI is to develop the tests as you go, so you don’t have to test from beginning to end and still get relevant information on the product under test.
If programmers just test at the unit level, they have no idea if a component is complete. If the testers cannot complete the testing from a system-level perspective, they do not know if a feature is functional. How, then, can you consider an iteration done if no one knows if a functionality is ready? You simply cannot. That is why having a collaborative definition of done is crucial. Is a story complete once the developers have tested it? Is a narrative complete once it has been integrated and built into an executable by the developers? What about the setup? How much testing does a feature require to determine whether or not it is complete?
There is no unique correct solution for every team. So, every team must evaluate its product, consumers, and challenges and reach a conclusion, “OK, we can say it’s done if all of the code has been checked in, reviewed by someone, or written in pairs; all of the developer tests have been completed; and all of the system tests for this feature have been created and run under the GUI. Every few days, we’ll handle GUI-based checking, but we won’t test using the GUI.”
I’m not sure whether that’s an acceptable definition of done for your business. It would help to consider the consequences of not doing periodic GUI testing on your product. Perhaps you don’t have a graphical user interface for your product, but you do have a database. Do the developer tests require database access? Perhaps, perhaps not. Does the testing process require access permission? I’d assume so, but maybe you have a product I’m not familiar with, and maybe they don’t really have to all the time. Perhaps additional automated tests that test db updates or migrations before anything else are required. “Done” is determined by your product and its risks. Consider the consequences of launching a product without various types of testing, and then you’ll understand what you require in an iteration to achieve a release-ready product.
Give a Mouse a Cookie
Once you’ve determined what you anticipate in an iteration, you’ll most likely require testing. Then, you’ll run into the “Give a Mouse a Cookie” scenario. In a charming child’s book that bears the same name, if you give a mouse a cookie, he wants a glass of milk to go with it. Then, he’ll need a rag to wipe the milk from his lips and a broom to sweep the crumbs off the ground. The need for more and more continues until the mouse becomes exhausted and desires another cookie, which restarts the cycle.
This is what emerges when a testing team seeks the “ultimate” test framework for their product. It’s an understandable desire. Unfortunately, you don’t always know what the ideal structure is until the project is finished. If you wait until the product is finished, testing will be included towards the end of the project, which is too little, too late.
Rather than building a flawless test framework, consider creating a just-good-enough test framework, for the time being, to refactor it as you go. This gives the testing team enough automation to get started and growing familiarity with the automation as the iteration and project progress. It does not bind you to a framework that no longer serves you because you have invested so much money and time in designing it.
Bear in mind that testers are similar to consumers. Just as your product’s consumers can’t necessarily tell what they want or need until they see it, testers can’t always tell what test automation framework they desire or require until they begin using it.
“Done” is the Result of a Collaborative Effort
What does the test squad “sustain” with development when you need to comprehend what “done” means and you construct a just-good-enough framework for testing? By ensuring that the whole team works on a story until it is finished.
Assume you have a story that calls for two programmers and one tester. The feature is created collaboratively by the developers. Simultaneously, the tester reshapes the tests, adds sufficient automation, or integrates the test into the current automation framework. But what if you’re shifting to agile and don’t have a framework? Then, one (or even more) of the programmers collaborate with the tester to build a suitable framework and integrate the tests for this functionality into it.
No law says programmers cannot assist testers in establishing test frameworks, writing test frameworks, or even writing tests to facilitate the completion of a story. Given that you have a team definition of “done,” doesn’t it make sense for team members to assist one another in getting things done?
Once you understand what “done” means for a story and the entire team is committed to completing it, you can build a culture where the testing process can convert to agile. The cross-functional project team may move to agile as long as the programmers help with testing frameworks, the business analysts help with narrative refinement, and the testers help deliver data on the product under test.
Switching to an agile methodology involves the entire project team, not just the programmers. If you have testers that can’t “catch pace,” it’s not the responsibility of the testers. It is a problem for the whole team. You need to resolve the issue with the team, change their mindset, and let them see the benefit of going in this direction. Even if you start with mediocre test frameworks, you can modify them into something spectacular over time; it’s up to you.
Published at DZone with permission of David Tzemach. See the original article here.
Opinions expressed by DZone contributors are their own.