The adaptability of a perceptive tester

Our group of fellow testers gets together once in a while to discuss our profession of testing and quality assurance. This time we discussed some remarkable examples of our own experience that perceptive testers (who are aware of the specific situation they’re in) adapt their approach to fit the specific needs.

Leo van der Aalst starts with this anecdote:

Currently more and more IT projects are done in an agile way. It was just a matter of time I, being a tester, would be involved in an agile project. So it happened that in the beginning of this year I was member of a scrum team. In a traditional development lifecycle I would have to read comprehensive documents like requirements and functional designs. And then write a report whether these documents were consistent, complete and testable (TMap NEXT calls this ‘intake of the test basis’).

But of course, when you are dealing with sprints of three weeks, this approach doesn’t work. So instead of reading documents, I had talks with the designer, developer and product owner about the features they would deliver in the current sprint. I asked them questions and when I got all the answers I needed, the intake of the test basis was done and I could start creating test cases. So, no time was lost with reading comprehensive documents, writing a report about the findings and then lose some more time because I would have to wait for these findings to be solved before I could start writing the actual test cases.

Rob Baarda shares his recent experience:

When I was writing the book “End-to-End testing with TMap Next” the expertise group started off finding the best practices from many E2E testing projects. Being an End-to-End-test manager in an E2E test project myself I immediately noticed that some of these practices were certainly good practices but did not apply in my situation. Other practices fitted perfectly and applying them helped me speed up my testing. So these collected practices are great to inspire test managers to adapt the way of working to their specific situation.

Ewald Roodenrijs enters the role of people into the story:

A few years ago, when I started in a new project, I found the project consisted of some loose ends in people that didn’t cohere with each other; we needed to bring them together and focus on the same result. I knew I needed to get the people involved in testing, we all needed to work together to get to a well-tested software product.

We started the project by getting all together as stakeholders of the project and perform a product risk analysis. This helped us all to get an understanding of what everybody wanted in the information system and the issues that existed between people and departments. During the project we found, as often happens, that the requirements and circumstances changed. So while involving all people we adapted the test strategy. In the end the information system went live as a great success, thanks to the effort of all people involved in the project, not because of the process, but because of all of us working together towards the same goal.

Bart Vrenegoor experienced that circumstances often change:

Some years ago, I worked for a large bank that was in the process of merging with another bank. I was the test coordinator working on a project that was responsible for automatically sending letters to millions of clients who were affected by the merger.

The image of the bank was at stake, the quality of the letters had to be high and we simply couldn’t afford to have major defects. Based on the outcome of the product risk analysis, we decided to do a considerable amount of testing to cover the risks identified. Most of these tests were done by external consultants like myself.

During the project circumstances changed radically. The financial crisis emerged and struck the bank hard. As a result, most external consultants had to leave to reduce cost. The project had always been driven by quality, but now had to make a huge shift to cost driven. It is obvious that this impacted our test approach as well. We simply didn’t have the manpower to do all the work we initially planned to do.

Eventually everything worked out fine. The remaining consultants focused their testing on high-risk areas and additional acceptance tests were planned to cover other areas. We couldn’t do all tests we planned, but this was accepted by our stakeholders. The letters were eventually sent without any major disturbances. I believe this is a great example on how to adapt to changing situations.

Ben Visser expands on change and the fact that a system should solve some problem:

Recently I entered a very large migration program that was running for over two years already and the final acceptance stage was about to start. Some diehard process tigers had implemented a rigid test process, based on TMap NEXT but ‘ameliorated’ to their own ideas: they had picked some TMap elements they thought were useful but had forgotten to involve the end user perspective. All in all, the test process had become ‘test centric’ instead of ‘solution centric’. We were just in time to transform the test approach to fit the actual context and do justice to all involved in testing and accepting the solution. We facilitated cooperation between end users, developers and testers by organizing test goal workshops, risk workshops and test design workshops. Furthermore, reporting – based on test goals and risks – was placed in context and adapted to the needs of the relevant stakeholders which contributed greatly to actually implement a system that was a solution to the needs of the stakeholders.

Thomas Veltman tells about the challenges a test team has to overcome:

One of my most inspiring experiences as a test manager was at a startup energy company that was on the market for only a short period and was focused on low pricing. They always had a sharp focus on winning clients and less on the quality of their internal systems. This approach was very successful: the company had grown rapidly. Because of this, everyone in this company always had too little time for everything and especially for testing. This asked a lot from the testers, who were pushed to the limits of their abilities to be able to test efficiently and effectively. They had to devote a lot of time and energy to understand their surroundings and the drivers for the business which of course is a prerequisite for a successful test. Besides that this project was favored with good testers that were able and willing to look outside their profession, this was made possible by templates and techniques from TMap that could be adapted in short time to be leveraged effectively in this environment. Testers did not lose time by reinventing the wheel so they could use their intellectual powers to solve the problems they encountered.

Rik Marselis concludes that collaboration is the only real way to successful systems:

Over the years I learned that testing is no activity on its own but is an important part of quality assurance as a whole. It supplies valuable input for status – and progress reporting. The quality gate is often introduced for the decision to go from one stage to another. In recent discussions with clients and colleagues we concluded that this often doesn’t work properly. We need to have a “Quality Collaboration Point”. At the handover from one stage in the project to the next the people involved need to use their combined skills to make the right decisions that lead to doing the testing and quality assurance activities that are suited to the situation at hand and to make sure we deliver the right information system to solve the business challenge, within the bounds of time and cost.

Together we concluded that although TMap NEXT was introduced some six years ago it still is a solid foundation for any testing project since the essence of adaptiveness makes sure that any perceptive tester can collaborate in doing the right things at the right moment in any project and thus ensure that the proper quality is delivered to solve the problem of the stakeholders.

Gestructureerd testen

Wat is nu eigenlijk gestructureerd testen? Wat is eigenlijk testen? Testen doet iedereen, elke dag! We kijken of iets het doet of niet. Maar dit kan je ook in een breder verband zien dan alleen software testen. Als je bij de supermarkt staat kijken veel mensen naar de houdbaarheidsdatum. Is het product nog goed (voor de datum) of verlopen (na de datum)? Bij het kijken of zelfs kopen van een nieuwe auto vraagt men zich af is de auto mooi of niet mooi? Een nieuwe TV, is deze goedkoper bij winkel 1 of goedkoper bij winkel 2. Hierin kan ik nog heel lang doorgaan. Punt is dat al deze dingen testen zijn. Echter spreken de verwachtingen voor zich. Je wilt producten die nog niet zijn verlopen, een mooie auto en die TV bij de goedkoopste winkel. Echter soms zijn er minder makkelijk uitkomsten te bepalen. Wat is daarbij nu de verwachting en wat is het resultaat?

Indien we de verwachting gaan bepalen aan de hand van technieken en dat vastleggen en daarna de uitkomst vergelijken met de verwachting, zijn we gestructureerd bezig. Dus we gaan aan de hand van bepaalde technieken verwachtingen bepalen en controleren of de uitkomst gelijk is of niet. In het geval van software testen is het dus: het uitvoeren van vooraf bepaalde testgevallen, waarbij gecontroleerd wordt of de verwachtingen voldoen aan de uitkomsten. Deze testgevallen zijn daarbij opgesteld aan de hand van testtechnieken.

In onderstaande ga ik open deuren intrappen, maar dan is voor iedereen weer duidelijk wat gestructureerd testen nu is.

Opstellen van testgevallen
Bij gestructureerd testen is het belangrijkste om testgevallen op te stellen. Deze testgevallen geven namelijk weer wat je wilt gaan controleren. Nu is het soms heel makkelijk om testgevallen te maken. Denk bijvoorbeeld aan een postcode veld in een applicatie. Deze moet voldoen aan de postcode notatie van vier cijfers en 2 letters. Je kunt dat veld dus gaan testen door andere combinaties dan de standaardnotatie in te voegen (foutsituatie) of controleren of het veld een postcode accepteert (goedsituatie).

Bij een postcodeveld is dus duidelijk wat de juiste situatie moet zijn. Echter bij veel applicaties is dat niet altijd duidelijk. Hoe moet een bepaald scherm zich gedragen, hoe is de menustructuur, welke zaken worden er opgestart zodra ik iets invoer of juist verwerkt. Deze zaken moeten dus van te voren bekend zijn, ofwel in een ontwerpdocument staan. Vaak zijn dit functionele ontwerpen, maar het kan een ook een bierviltje zijn waarop staat hoe de applicatie moet functioneren.

Aan de hand van dat ontwerp wil je dus de testgevallen opstellen. Dat kan op vele manieren, maar hoe kan je nou zoveel mogelijk uit de kast halen om de hele applicatie af te dekken. Natuurlijk 100% testen bestaat niet vanwege tijd en kosten, maar stel nou dat het wel kan. Dan moeten we elk onderdeel in het ontwerp aan een test onderwerpen en dus voor al die onderwerpen een testgeval opstellen. Nu lijkt dat makkelijker dan het is, maar in een document van meer dan 10 bladzijden wordt het al moeilijk om volledig dekkend te zijn om de juiste testgevallen op te stellen. Daarom zijn er gelukkig meerdere testtechnieken, of testontwerptechnieken, die je kunnen helpen bij het opstellen van de testgevallen. Er zijn werkelijk allerlei verschillende testtechnieken die je kunnen gebruiken bij het opstellen van de testgevallen. Op zo’n manier krijg je dus de beste testgevallen of de meest simpele manier. Ook al zijn sommige testontwerptechnieken soms best complex. Bekende voorbeelden zijn real-life test, gegevenscyclustest, beslissingstabeltest en datacombinatietest. Natuurlijk zijn er nog veel meer testontwerptechnieken te vinden.

Tip: Zoek eens op Google of Wikipedia naar testontwerptechnieken die je kunt gebruiken. Ook op o.a. tmap.net is informatie te vinden.

Verwachtingen bepalen
Als eenmaal bekend is wat er getest gaat worden is het wel van belang te bepalen wat de verwachtingen zijn bij het uitvoeren van deze testgevallen. Dus gaan we de verwachte uitkomsten bepalen van die testgevallen die we willen gaan uitvoeren en dit verwerken bij die testgevallen. Ook dit doen we aan de hand van de ontwerpdocumenten. In de ontwerpdocumenten staat namelijk ook beschreven wat de reactie van de applicatie moet zijn. Dus kunnen we van te voren bepalen wat de verwachte uitkomst is. Denk aan iets simpels als de ‘Start’ knop in Windows. Als je op deze knop drukt verschijnt het startmenu. In de ontwerpen van Windows heeft dus gestaan dat bij het klikken op die knop het startmenu zou moeten verschijnen. Natuurlijk is dit een simpel voorbeeld, maar soms is testen ook heet simpel. Een andere mogelijkheid is bijvoorbeeld het invullen van een bankrekening op een webshop. Er bestaat namelijk de mogelijkheid om een bankrekening te controleren of deze echt bestaat, de zogenaamde 11-check. Hetzelfde geld voor BSN-nummers (oude sofinummer), maar die heeft een andere controle. De applicatie kan zodra de bankrekening is ingevoerd een controle uitvoeren of het rekeningnummer echt bestaat door de 11-check uit te voeren. Dus bij het invullen van een bestaand rekeningnummer verwacht je dat deze goed gaat en bij een niet bestaand nummer verwacht je een foutmelding. Je uitkomst is dus afhankelijk van je invoer in de applicatie. Dus bij het opstellen van je testgevallen dien je daar al van te voren rekening mee te houden.

Uitkomsten controleren
Nu we de testgevallen hebben opgesteld en de verwachte uitkomsten hebben bepaald is het zaak om deze ook echt te gaan uitvoeren. Zodra de applicatie is gebouwd kunnen we van start gaan. Soms ook eerder, maar laten we het simpel houden. We gaan de testgevallen uitvoeren en controleren daarbij de uitkomsten.

Indien een uitkomst overeen komt dan noteren we dat. Maar indien een uitkomst niet overeenkomst dan noteren we dat ook. Daarbij kijken we ook wat er mis is. Het noteren van een foute test noemen we een bevinding. In een bevinding noteren we wat er fout is en wanneer we het hebben ontdekt. Ook geven we nog andere informatie mee die een administratie van bevindingen verbeterd en een bouwer van de applicatie het versimpeld de bevindingen op te lossen.

Zodra dit is gebeurd doen we, normaal gesproken, een nieuwe test (hertest) op dat testgeval om te kijken of alles nu wel goed functioneert. Ook deze uitkomst noteren we weer. Uiteindelijk zijn alle testgevallen uitgevoerd die we hebben willen uitvoeren en kunnen we zeggen of de applicatie goed is of juist slecht.

Op deze manier heb ik geprobeerd simpel uit te leggen wat gestructureerd testen nu eigenlijk is. In andere postings van ons zullen we soms dieper ingaan op de problemen rond gestructureerd testen.