As we continue consolidating automated tests from several different teams into one suite of tests, one of the things we are looking at is figuring out where there is duplication. Even though each of the previous teams had their own area of focus for testing, they were all still working on a common platform and in some cases there is significant overlap between some of the test sets. It is easy to just accept that as a given (and indeed I think some level of overlap will always be there due to leaky abstractions and other considerations), but I wonder if the level of test duplication we are seeing is a symptom of something. I wonder if it points to a trust and communication issue.
Why would Team A add tests that exercise functionality from area B? Well, Team A depends on that functionality working a certain way and so they want to make sure that the stuff Team B is doing will indeed work well for their needs, and so Team A duplicates some of the testing Team B is doing. But what if Team A trusted that Team B was checking for all the things that Team A needed to be there. Would they be adding tests like this? It’s very unlikely anyone would do this. If you knew that the kinds of things you cared about were being dealt with at a priority level you would give them, there would be no need to check those things yourself. The problem of course was that we didn’t trust each other to do that.
This begs the question of why. Why didn’t we trust each other like this? This most obvious answer to this is that we didn’t show ourselves to be trustworthy to each other. If Team A ended up getting hurt a number of times due to Team B not checking for the things Team A needed, it would be very rational for them to check for those things themselves even it if meant duplicating effort.
With a new team structure, we may have less trust issues that will cause test duplication, but test automation isn’t the only place this comes into play. For example, how much duplication of testing is there between the work that developers do and the work that testers do? If a developer has done a lot of testing do we trust that testing? What if a product manager has tested a feature. Do we trust that testing? Why is is that we often feel to the need to do our own testing? This distrust may be well founded (we do it because past experience has taught us that they might be missing important things), but the reality is, it hurts our teams. It slows us down and makes us less efficient. We need to work on building trust, communication and trustworthiness so that we can stop redoing other people’s work. What are you doing to learn about the testing others on your team are doing? What are you doing to help them grow so that their testing is more trustworthy?