Am I Wrong?

I happened across Exploratory Testing: Why Is It Not Ideal for Agile Projects? by Vitaly Prus this week and I was triggered. But why? I took a few minutes to think that through.

Partly, I guess, I feel directly challenged. I work on an agile project (by the definition in the article) and I would say that I use exclusively exploratory testing. Naturally, I like to think I'm doing a good job. Am I wrong?

After calming down, and re-reading the article a couple of times, I don't think so. 😸

From the start, even the title makes me tense. The ideal solution is a perfect solution, the best solution. My context-driven instincts are reluctant to accept the premise, and I wonder what the author thinks is an ideal solution for an agile project, or any project.

I notice also that I slid so easily from "an approach is not ideal" into "I am not doing a good job" and, in retrospect, that makes me smile. It doesn't do any harm to be reminded that your cognitive biases influence your interpretation, even when you take them into account. I'll christen that Cogstadter's Law, maybe.

At the end, too, the conclusions set my teeth on edge. This is not how I see my role: "The primary objectives of QA and testing activities in general are to ensure a sound, high-performance software operation that helps businesses attain set goals and for end users to obtain an intuitive, user-friendly IT product." 

Testing, for me, is the pursuit of relevant incongruity. It's about taking actions that I gauge will obtain the right kind of information at the right kind of cost at the right kind of time for the right kind of people.

Throughout the piece, there appears to be an underlying assumption that exploratory testing is a luxury, an add-on to scripted test cases, a route to creating scripted test cases, a time-filler, an end-user simulation, or simply something that is reached for when circumstances are outside of the ordinary. It asserts that exploratory testing and automation cannot mix, that learning cannot easily be taken outside of exploratory testing, and that it will be inefficient because the risk of repeating work is high.

That is not the exploratory testing I practice.

My team is building a new service. It's been running with dummy responses for a while as various layers and other dependencies were refined, fleshed out, and connected. Last week, while I was looking at the latest incremental change in that plumbing, I thought that there might be just enough functionality that I could navigate a journey.

So I did a quick proof-of-concept with Postman, took the requests that worked into Python, hacked in some heuristics and hard-coding for pieces that were still not functional, and was able to write a client that could run through a workflow from near the start to near the end.

I added some randomness to my client and, in repeated runs, it was able to find variant paths through the journey.

I added the ability to visualise the paths taken across multiple runs as a state machine. By comparing that to the state machine that defines the service I showed  that, even in this early state, the engine is exposing only legal paths.

I learned about some of the rough edges that our API has.

I learned about problems we're going to have when testing this service for real, and agreed a debug endpoint with the team that will help to resolve some of them.

None of this work was done because of acceptance criteria or existing test cases, and none of it has produced test cases for someone else to run next time.

The code I've written is pretty scrappy but as far as I'm concerned it's throwaway stuff.  Despite that, it has value. I'm already using it as a workbench to test the stories that have been finished since and perhaps some of the ideas from it will be taken into more formal test code later.

The work was timely for the PO because he's able to see that we're on the path he's expecting. It was appreciated by the team too, because they can see that their work so far works so far and that I care to look at what they do with a sympathetic but sceptical eye,  and without reporting every rough edge. 

It was useful for me to have some for-real contact with the API. Now I can begin to get a feel for it so that I can make better judgements in future about where there might be risks and how I could investigate them.

That is the exploratory testing I practice: driven by context, and by proportionate effort, using or creating tools and resources to seek relevant value.  

I wouldn't be so vain as to say it's ideal and I'm not so naive as to say that others wouldn't do something different and possibly more valuable. But I'd say that about pretty much any approach to testing anything. (Side note: on some days I might try to argue that doing no testing is the same for everyone.)

Although we have pretty divergent perspectives, I'm grateful to Vitaly for reminding me that it's worth taking a moment to wonder whether I'm wrong.
Image: https://flic.kr/p/oj6yVS