Test Design

Articles

Icon showing clipboard with passed and failed tests Teaching Acceptance Test-Driven Development

Acceptance test-driven development is a whole-delivery cycle method that allows the entire team to define system behavior in specific terms before coding begins. These conversations align the expectations of the testers, developers, and product owners, forcing any silly arguments to happen before someone has to create the code twice. Here are some great beginner exercises for teaching ATDD.

Matthew Heusser's picture Matthew Heusser
Row of cupcakes decorated with blue frosting and rainbow sprinkles, photo by Brooke Lark Shifting Testing Left Bakes In Quality from the Start

“Shift left” is one of the latest buzz terms in software testing. Movements like agile and DevOps recommend that testers shift left, but what does that mean, exactly? Here's how one tester became a believer in the shift-left movement; how he got his team's developers, analysts, designers, and managers on board; and how his entire organization has benefited from the shift.

James Espie's picture James Espie
Lines of code, photo by Markus Spiske Reduce Technical Debt by Using Unit Tests as Documentation

Technical debt is an inevitable side effect of legacy code. Some code can (and should) be pruned, but institutional memory fades—what if there's a reason certain lines were included that may not be immediately obvious? Done right, unit tests can serve as documentation. Later on, these tests can illuminate what the developer was thinking when they created the code.

Steve Poling's picture Steve Poling
Medical syringes and needles Fault Injection Testing for an IoT Device

If someone says a feature is not testable through the methods we use, it does not absolve us from the responsibility of testing; that's still our job. When this team was given a new connected device to test, they realized their existing functional testing skills wouldn't be sufficient to test the product's core algorithm. So the team got creative, learning the source code and introducing fault injection, figuring out new ways to test.

Ali Khalid's picture Ali Khalid
Arrow pointing left Shifting Testing Left Is a Team Effort

There is a lot of talk in the testing world about shifting left. Basically, “shift left” refers to moving the test process to an earlier point in the development process, independent of the development approach. This article explores a case in which shift-left has been applied, and the lesson is that shifting left cannot be achieved by testers alone—it must result from a team effort.

Puzzle pieces being put together to spell "Usability" Testing to the Usability Standards Our Customers Expect

Allowing minor defects to be included in releases impacts our customers’ perspective on software professionalism. We’ll never catch every weird, obscure bug, but there are some design elements where they tend to lurk. By focusing our testing efforts on these areas—or at least not neglecting them—we can catch more issues before our customers do.

Nels Hoenig's picture Nels Hoenig
Man in a suit reading the Business section of a newspaper Getting Started with Business Intelligence Testing

There’s a bit of hype in terms such as business intelligence, data analytics, and data mining. In testing terms, though, it means working with scripts and databases, often without traditional GUI interaction. But core testing skills—analysis, synthesis, modeling, observation, and risk assessment—will still help you go far in business intelligence testing.

Albert Gareev's picture Albert Gareev
Three different colored keys 3 Keys to Mastering Test-Driven Development

From his decade of teaching thousands of professional software developers how to be effective with test-driven development, David Bernstein has learned that there are three key ingredients for mastering TDD: understanding what it really is, making code reliably testable, and getting hands-on experience. Let’s look at each of these factors to see what it takes to use TDD effectively on your projects.

David Bernstein's picture David Bernstein
Sign reading "Duh!" When the Code Is Too Obvious to Check

How many times does something seem too obvious to check? Most of the time this normal human response is a handy shortcut. Your brain tries to save you time—but you can’t always trust it. If your code malfunctions, each of those "too obvious to check" thoughts will bias your thinking about what caused the malfunction. We have to commit up front, before our thinking crystalizes, that the code will have to prove to us that it is correct.

Steve Poling's picture Steve Poling
Icons for education and continuous learning To Be a Good Tester, Just Do What No One Else Can

If you want to have a successful career in testing—and maybe even get beyond the day-to-day at the individual level, and improve the team or division—all you need to do is things no one else can. That means staying ahead as the industry moves on, which takes an intense and continuous investment in learning and practicing new things. Here are some suggestions for what that could look like.

Matthew Heusser's picture Matthew Heusser

Pages

StickyMinds is a TechWell community.

Through conferences, training, consulting, and online resources, TechWell helps you develop and deliver great software every day.