softify.pro Flow — Getest door COCO

Control. Clarity. Flow.

Elk serieus softwareproduct ontwikkelt uiteindelijk een tweede product achter het product.

Klanten zien het misschien nooit. Bezoekers weten misschien nooit dat het bestaat. Maar beheerders, operators en ontwikkelaars zijn er elke dag van afhankelijk.

Voor softify.pro Flow is die applicatie Administration — de operationele console die verantwoordelijk is voor het beheren van gebruikers, rollen, toegangsniveaus, authenticatiestatussen, databaseomgevingen en andere configuratie die een Flow-installatie onder controle houdt.

Het aanmeldscherm draagt drie woorden:
Control. Clarity. Flow.

Ze zijn oorspronkelijk gekozen om de ervaring te beschrijven die we beheerders wilden geven bij het bedienen van het systeem.

Maar ze beschrijven ook verrassend goed hoe wij vinden dat software getest zou moeten worden.

Dat maakte softify.pro Flow — Administration een voor de hand liggende kandidaat voor een echte COCO-test.
Geen laboratoriumdemonstratie.
Geen verzameling losse knoppen die speciaal voor een AI-demo zijn voorbereid.
Een echte platformonafhankelijke desktopapplicatie met echte applicatielogica, meerdere vensters, meerdere database-backends, authenticatie, rechten, lokalisatie en genoeg status om ogenschijnlijk kleine regressies handmatig moeilijk te herkennen te maken.

Voor de hier getoonde publieke demonstratie werkte COCO uitsluitend met gegenereerde demogegevens. De applicatie was gelicentieerd aan het fictieve bedrijf Presentation GmbH, en er is geen productieklantinformatie, geen inloggegevens en geen persoonlijke gegevens gebruikt.

Het doel was eenvoudig:
laat COCO de applicatie benaderen zoals een tester dat zou doen, en bepaal of de volledige administratieve workflow zich nog gedraagt zoals de software beweert.

The Challenge

Op het eerste gezicht lijkt het testen van een beheerapplicatie eenvoudig.

Open het.
Log in.
Klik door verschillende vensters.
Controleer of alles er correct uitziet.

Die aanname verandert snel zodra de applicatie groeit.

softify.pro Flow — Administration is geen enkel statisch formulier. Het is een verzameling met elkaar verbonden operationele weergaven binnen één applicatieschil.

Onder andere kan een beheerder werken met:

• gebruikersaccounts
• rollen en toegangsniveaus
• authenticatie-informatie
• status van tweefactorauthenticatie
• informatie over het besturingssysteem
• netwerk- en IP-informatie
• databaseconfiguratie
• sorteer- en weergaveopties
• live taalkeuze
• applicatie- en licentie-informatie

De interface ondersteunt momenteel elf talen. De applicatie werkt ook met MySQL en PostgreSQL als database-backends. Afzonderlijk vormt geen van deze functies een ongebruikelijk testprobleem.

De moeilijkheid ontstaat door de combinaties ervan.
Een gebruikerstabel kan correct werken in het Engels maar een verouderde kolomnaam tonen in het Kroatisch.
Sorteren kan correct werken bij verbinding met MySQL maar zich anders gedragen na het overschakelen naar PostgreSQL.

Een taalwijziging kan de meeste interface-elementen bijwerken terwijl één statusbericht onvertaald blijft. De applicatie kan succesvol van database wisselen maar verouderde informatie van de vorige verbinding behouden. Een nieuwe release kan een functie introduceren terwijl de Over-dialoog nog de vorige beschrijft. Het programma hoeft niet vast te lopen om zo'n situatie een regressie te maken. Sterker nog, sommige van de vervelendste softwaredefecten zijn precies de gevallen waarin alles lijkt te werken.

De applicatie start.
Het venster opent.
De knop reageert.
Maar er klopt iets niet meer helemaal onder de oppervlakte.
Daarom is herhaaldelijk regressietesten belangrijk.

En het is precies het soort werk waar mensen steeds slechter in worden nadat ze dezelfde reeks tientallen keren hebben herhaald.

Why Manual Testing Becomes Expensive

Iets één keer testen is eenvoudig.
Het betrouwbaar testen na elke relevante release is anders.

Kijk alleen al naar drie dimensies: 11 interfacetalen × 2 database-backends × meerdere applicatieworkflows.

Het aantal combinaties groeit snel.
Voeg verschillende gebruikersrollen, authenticatiestatussen, sorteergedrag, configuratiewijzigingen en operationele omgevingen toe, en de testmatrix wordt te groot om als een incidentele handmatige checklist te behandelen.

Hier begint regressietesten vaak te eroderen.
Niet opzettelijk.
Een releasedeadline komt dichterbij.
Iemand herinnert zich dat de applicatie vorige week is getest.
Een ontwikkelaar controleert snel het belangrijkste scherm.

Duits werkt.
Engels werkt.
MySQL werkt.
De aanname wordt:
"De rest is waarschijnlijk in orde."

Meestal is dat zo.
Tot de release waarbij dat niet zo is.
COCO bestaat deels om die aanname uit het proces te halen.

What COCO Actually Did

COCO startte softify.pro Flow — Administration vanuit een koude applicatiestatus, zonder te vertrouwen op een vooraf voorbereid scherm of handmatig gepositioneerde workflow.

De eerste interactie was dezelfde als die aan een menselijke beheerder wordt getoond: het aanmeldvenster.

COCO identificeerde de authenticatie-interface met:

• gebruikersnaam
• wachtwoord
• tweefactorauthenticatiecode

en de regel direct onder de softify.pro Flow-identiteit:
Control. Clarity. Flow.

Van daaruit werkte COCO zich door een gedefinieerde regressiesessie. Het ging er niet simpelweg om te bepalen of de applicatie kon worden geopend.

Het ging erom te verifiëren of de status van de applicatie intern consistent bleef terwijl COCO ermee interacteerde.

Authentication Is Only the Beginning

Login-tests zijn een van de meest voor de hand liggende kandidaten voor automatisering, maar een geslaagde authenticatie alleen zegt heel weinig over de rest van een beheerapplicatie.

Eenmaal binnen ging COCO naar de daadwerkelijke werkomgeving. Het inspecteerde de gebruikersbeheer-interface en verifieerde dat de verwachte informatie aanwezig was.

Dat omvatte gegevens zoals:

• gebruikersnamen
• gemaskeerde wachtwoorden
• 2FA-indicatoren
• toegewezen rollen
• informatie over het besturingssysteem
• IP-adressen

COCO interacteerde vervolgens met de tabel in plaats van deze alleen te observeren.
De gebruikerslijst werd gesorteerd op gebruikersnaam.
De resulterende volgorde werd geïnspecteerd.
Het belangrijke was niet of het klikken op de kolomkop een zichtbare verandering opleverde.

COCO verifieerde dat de resulterende tabelstatus overeenkwam met de gevraagde bewerking.

Dat onderscheid is belangrijk.
Een functionele test vraagt:
"Reageerde de knop?"

Een nuttige regressietest vraagt:
"Kwam de applicatie terecht in de juiste status?"

Testing the Database Boundary

softify.pro Flow ondersteunt meer dan één database-backend.

Dat maakt van databaseoverschakeling een bijzonder belangrijke regressiegrens.
COCO wijzigde de actieve backend van MySQL naar PostgreSQL.

Na de overschakeling inspecteerde het opnieuw de gebruikersinformatie.
De test zocht naar meer dan een geslaagde verbinding.
Er werd gecontroleerd of de applicatie de verwachte records bleef tonen en of de via de interface getoonde informatie consistent bleef.

COCO schakelde daarna weer terug.

Dit soort overgang wordt gemakkelijk onderschat.
De gebruikersinterface kan visueel identiek blijven terwijl de onderliggende opslaglaag volledig verandert.
Vanuit het perspectief van een beheerder zou die overgang bijna saai moeten aanvoelen.
Dezelfde gebruikers zouden nog steeds begrijpelijk moeten zijn.
Dezelfde rollen zouden nog steeds logisch moeten zijn.

Hetzelfde interfacegedrag zou nog steeds moeten gelden.

Die schijnbaar onbewogen continuïteit is precies wat bewezen moet worden.

Eleven Languages, One Application State

Lokalisatie is een ander gebied waar oppervlakkig testen bijzonder gevaarlijk is.

Het is relatief eenvoudig om te verifiëren dat een applicatie in een andere taal kan starten.
Het is veel waardevoller om te verifiëren wat er gebeurt wanneer de taal verandert terwijl de applicatie al draait en status vasthoudt.

COCO wisselde de interfacetaal live.

De sessie omvatte overgangen tussen talen zoals:
Duits → Engels → Kroatisch
terwijl de administratieweergave actief bleef.

COCO observeerde of interface-elementen op hun plaats correct veranderden:

• tabelkoppen
• bedieningselementen
• knoppen
• labels
• statusberichten

Ook de onderliggende tabel en applicatiestatus moesten die overgang overleven.
Dit is belangrijk omdat meertalige software uit meer bestaat dan vertaalde tekststrings.
Taalwijzigingen kunnen blootleggen:

• vergeten resources
• verouderde labels
• opmaakproblemen
• onvertaalde statusberichten
• coderingsproblemen
• statusresets
• problemen bij het opnieuw aanmaken van besturingselementen

Een venster dat er correct uitziet wanneer het direct in het Kroatisch wordt gestart, kan zich toch onjuist gedragen wanneer de gebruiker tijdens een actieve sessie van Duits naar Kroatisch overschakelt.

Dat is het verschil tussen het controleren van een screenshot en het testen van een workflow.

Restoring Application State

COCO herstelde vervolgens de standaard sorteerconfiguratie van de applicatie.

Ook hier eindigde de test niet met de klik zelf.

De resulterende volgorde en de bevestiging die via het statusgebied van de applicatie werd getoond, werden geëvalueerd. Dit soort verificatie lijkt misschien onbeduidend vergeleken met het testen van authenticatie of databasetoegang.

Dat is het niet.

Enterprise-applicaties verzamelen honderden van dit soort kleine statusovergangen.
Gebruikers vertrouwen erop zonder er bewust over na te denken.
De software voelt betrouwbaar aan juist omdat die interacties voorspelbaar blijven.
Regressietesten bestaat om die voorspelbaarheid te beschermen.

Testing the Information Around the Software

COCO opende ook de Over-dialoog van de applicatie.

Waarom een Over-venster testen?

Omdat softwaredocumentatie begint binnen de software zelf.
Het versienummer, de functiebeschrijving en de licentie-informatie die aan de operator worden getoond, zouden moeten overeenkomen met de applicatie die daadwerkelijk draait.

Een applicatie kan perfect functioneren terwijl deze nog steeds verouderde versie-informatie toont of mogelijkheden beschrijft die niet meer overeenkomen met de release.

Dat laat geen database vastlopen.
Het doet iets subtielers:
het vermindert vertrouwen.

Voor enterprise-software omvat operationele nauwkeurigheid ook deze ogenschijnlijk kleine details. COCO controleerde daarom ook deze.

Control.

Het eerste woord in de softify.pro Flow-slogan is ook het eerste principe van de testomgeving.

Control betekent weten wat er wordt getest, tegen welke status en met welke gegevens.

De publieke COCO-demonstratie gebruikt geen productiegegevens van klanten.

Het draait met bewust voorbereide demogegevens waarvan de verwachte status bekend is.

Dat maakt resultaten reproduceerbaar.

Het betekent ook dat verschillen tussen testruns onderzocht kunnen worden in plaats van weg te worden verklaard als willekeurige veranderingen in productiegegevens.

Belangrijker nog, COCO is ontworpen als een self-hosted AI-testsysteem.

Testbewijs, applicatiescreenshots en interne workflow-informatie kunnen binnen de infrastructuur blijven onder de eigen controle van de klant of operator, in plaats van standaard te worden verzonden naar een niet-gerelateerde externe clouddienst.

Voor interne bedrijfsapplicaties is dat niet louter een infrastructuurvoorkeur.
Het kan deel uitmaken van de testvereiste zelf.

Clarity.

Automatisering is niet bijzonder nuttig als de uiteindelijke uitvoer is: FAILED
gevolgd door honderden regels technische uitvoer die iemand handmatig moet reconstrueren voordat hij begrijpt wat er is gebeurd.

COCO is ontworpen om een begrijpelijk bewijsspoor te behouden.

Het rapport beschrijft:

• wat er is getest
• welke interactie plaatsvond
• in welke volgorde dit gebeurde
• wat COCO observeerde
• welke status verwacht werd
• waar het gedrag afweek toen iets mislukte

Screenshots en uitvoeringsbewijs kunnen die reeks vergezellen.
Het doel is niet om technische details te verbergen.

Het is om het resultaat begrijpelijk te maken voordat iemand een debugger moet openen.

Een engineer zou moeten kunnen antwoorden op:
Wat is er gebeurd? voordat hij vraagt:
Waar in de code is het gebeurd?

Dat onderscheid verkort het onderzoek drastisch wanneer een regressie optreedt.

Flow.

Traditionele UI-automatisering denkt vaak in elementen.

Selector zoeken.
Selector klikken.
Andere selector zoeken.
Waarde controleren.

Die aanpak blijft nuttig, maar applicaties worden niet ervaren als verzamelingen selectors.

Mensen ervaren flows.

Inloggen.
Beheer openen.
Een gebruiker vinden.
Een instelling wijzigen.
Van database wisselen.
Van taal wisselen.
Het resultaat verifiëren.

Doorgaan met werken.

COCO behandelt de reeks daarom als een proces in plaats van als een willekeurige verzameling bedieningselementen.

Het volgt wat de gebruiker probeert te bereiken en evalueert de applicatie in context.

Dat wordt bijzonder waardevol bij het testen van echte bedrijfssoftware, omdat storingen vaak optreden tussen schermen of tussen statussen, niet binnen een individuele knop.

Een logistieke workflow kan een order, een voorraadreservering, een pickactie, een pakbon en een verzendbevestiging bevatten.
Elk afzonderlijk scherm kan correct lijken terwijl het volledige proces fout is.
Hetzelfde principe geldt hier op kleinere schaal.
Het beheervenster is niet het product.

De workflow erdoorheen is dat wel.

Evidence Instead of Assumption

Een van de belangrijkste taken van COCO is niet klikken. Het is onthouden wat er is gebeurd.
Menselijk regressietesten eindigt vaak met een uitspraak als:
"Ik heb het getest en alles zag er goed uit."

Dat kan volkomen accuraat zijn.
Maar enkele weken later, wanneer een probleem opduikt, zijn de nuttige vragen anders:

• Welke release is getest?
• Welke database?
• Welke taal?
• Welke gebruikersstatus?
• Wat gebeurde er voorafgaand aan het probleem?
• Wat was er precies zichtbaar?

In welke volgorde zijn de acties uitgevoerd?
COCO's testruns zijn ontworpen om bewijs achter te laten.

Dat verandert een testresultaat van een mening in iets dat geïnspecteerd kan worden.
Een geslaagde run wordt daardoor ook nuttig.
Het legt een bekende referentiestatus vast waarmee later gedrag vergeleken kan worden.

COCO Is Not the Decision Maker

Er is een belangrijke grens in de manier waarop we AI gebruiken voor softwaretesten.
COCO is niet bedoeld om engineering-verantwoordelijkheid te vervangen.

Het beslist niet hoe een bedrijfsregel zou moeten zijn.

Het test gedrag tegen scenario's, vereisten en verwachtingen die voor de applicatie zijn gedefinieerd.
Voor gevoelige beslissingen over rechten, prijzen, voorraad, financiële transacties of andere kritieke bedrijfsstatussen blijft het definiëren van correct gedrag een menselijke verantwoordelijkheid.

Dat onderscheid is belangrijk.
AI is uitstekend in het herhalen van een gedetailleerde test zonder de concentratie te verliezen.
Het is uitstekend in het verzamelen van bewijs.
Het kan schermen inspecteren, verwacht en waargenomen gedrag vergelijken en discrepanties verklaren.
Maar het bedrijf bepaalt nog steeds wat correct betekent.

COCO maakt die definitie testbaar.

The Test Nobody Wants to Repeat

Er is een eenvoudige reden waarom automatisering hier waarde toevoegt.
Een menselijke tester kan deze regressiesessie absoluut uitvoeren.
De eerste taal krijgt volledige aandacht.
Waarschijnlijk de tweede ook.
Dan nog een.
Dan nog een.
MySQL is al gecontroleerd.
PostgreSQL moet nog gecontroleerd worden.
De sorteertest is al meerdere keren uitgevoerd.
De Over-dialoog is al maanden niet veranderd.

Het is vrijdagmiddag.

En menselijke aandacht doet wat menselijke aandacht van nature doet.
Ze begint te optimaliseren.
COCO niet.
In de eigen geest van COCO:

• Ik word niet moe van het klikken op dezelfde knop in elf talen. Ik sla de PostgreSQL-ronde niet over omdat het vrijdagmiddag is. Ik neem niet aan dat de sortering hield alleen omdat het in de vorige release werkte.

Voor COCO kan elke regressiesessie behandeld worden alsof het de eerste is.
Dat is geen intelligentie die een menselijke tester vervangt.
Het is automatisering die de menselijke tester beschermt tegen het deel van het testen waar menselijke aandacht het minst waard is.

From Repetitive Testing to Engineering Evidence

Het grotere doel van COCO is niet het maximaliseren van het aantal geautomatiseerde acties.
Duizend geautomatiseerde klikken zijn zinloos als niemand begrijpt wat ze bewijzen. Het nuttige resultaat is vertrouwen, ondersteund door bewijs.

Voor softify.pro Flow betekent dat te kunnen zeggen dat een release is getest over de operationele gebieden die ertoe doen:

• authenticatie
• gebruikersbeheer
• rol- en toegangsinformatie
• status van tweefactorauthenticatie
• sorteergedrag
• MySQL-werking
• PostgreSQL-werking
• live lokalisatie
• statusfeedback
• applicatie-informatie
• licentie-informatie

en dat het resultaat bewaard blijft in een vorm die later beoordeeld kan worden.
Hetzelfde principe schaalt ver buiten deze applicatie.
Een inlogproces kan op deze manier getest worden.
Een boekingsworkflow kan op deze manier getest worden.
Een logistiek proces kan op deze manier getest worden.
Een platformonafhankelijke desktopapplicatie kan op deze manier getest worden.
De schermen veranderen.
De bedrijfsregels veranderen.
Het principe niet:
de verwachte workflow definiëren, deze consistent uitvoeren, bewijs verzamelen en het resultaat begrijpelijk maken.

Why We Test Our Own Software With COCO

Er is nog een reden waarom softify.pro Flow ertoe doet als COCO-case study.

Het is onze eigen software.
Dat verwijdert de comfortabele afstand die soms bestaat tussen een technologiedemonstratie en de mensen die deze uitvoeren.

Als COCO bedoeld is om enterprise-software te testen, moet het nuttig genoeg zijn om het toe te vertrouwen aan software die wij zelf ontwikkelen en uitbrengen.

Flow fungeert daarom zowel als product als testterrein.
Nieuwe testmogelijkheden kunnen worden beproefd tegen een echte applicatie.
Onverwacht gedrag kan zwaktes blootleggen in de applicatie, het testplan of COCO zelf.

Elke kant verbetert de andere.
Die feedbacklus is veel waardevoller dan het bouwen van kunstmatige demonstraties die alleen ontworpen zijn om te slagen. Een testsysteem zou niet overtuigend moeten lijken omdat de demonstratie eenvoudig was.
Het zou overtuigend moeten worden omdat het de kleine dingen blijft vinden die mensen uiteindelijk zouden stoppen te controleren.

The Result

softify.pro Flow — Administration beschikt nu over een gedocumenteerd en herhaalbaar regressieproces dat COCO kan uitvoeren voorafgaand aan relevante releases.

De test omvat beide ondersteunde databaseomgevingen en de elftalige interface van de applicatie, terwijl de applicatie wordt gevolgd zoals een beheerder deze zou gebruiken, in plaats van elk scherm als een geïsoleerd testdoel te behandelen.

COCO produceert een bewijsspoor dat toont wat er is getest, wat er is waargenomen en in welke volgorde de sessie plaatsvond.

Dat bewijs kan lokaal onder controle blijven.
Ontwikkelaars krijgen een reproduceerbaar startpunt wanneer er iets verandert.
Menselijke testers besteden minder tijd aan het herhalen van voorspelbare interacties en meer tijd aan het onderzoeken van situaties die daadwerkelijk beoordelingsvermogen vereisen.

En softify.pro Flow krijgt iets waardevollers dan een groene PASS-indicator.

Het krijgt bewijs dat de ervaring die op het aanmeldscherm wordt beloofd, blijft bestaan nadat de onderliggende code is veranderd.

Control. Weten wat er wordt getest en de omgeving onder controle houden.

Clarity. Begrijpen wat er is gebeurd zonder een ondoorzichtig automatiseringslogboek te hoeven reconstrueren.

Flow. De applicatie testen als een proces dat mensen daadwerkelijk gebruiken.

Control. Clarity. Flow.

Het werd geschreven voor de software.
Het bleek net zo goed de testfilosofie erachter te beschrijven.