Follow Us on Twitter

Testen van functionaliteit en performance met SoapUI en LoadUI

December 2012 - Veel ontwikkelaars maken gebruik van SoapUI voor het testen van webservices. Vaak blijft het alleen bij het genereren van een request en het aanroepen van een service. SoapUI kan natuurlijk nog veel meer. Zo kunnen testen heel goed worden geautomatiseerd en is SoapUI geschikt voor het doen van loadtests. LoadUI is net als SoapUI een product van SmartBear. Deze twee producten sluiten goed op elkaar aan. SoapUI is bedoeld voor performance- en functioneel testen van webservices. In combinatie met LoadUI komen ook load- en performancetests daar bij.

In dit Whitebook laten we zien hoe je testen kan opzetten in SoapUI en kan exporteren naar LoadUI. We laten zien welke mogelijkheden deze tools bieden voor het maken van verschillende testscenario's voor het doen van functionele en performance tests. De focus wordt gelegd op het testen van webservices en het combineren van de beide producten voor het doen van performance tests.

Functioneel testen

Voor het functioneel testen van webservices biedt SoapUI een groot aantal mogelijkheden. Zo kan testdata worden opgehaald uit een database of een bestand en kunnen testflows gestuurd worden aan de hand van uitkomsten van webservices. Heel krachtig hierbij is de mogelijkheid van het gebruik van Groovy. Groovy is een scripttaal en kan worden ingezet tijdens de test of voor en na het starten van een test. Verder beschikt SoapUI over een groot aantal componenten waarmee testinput en testoutput kan worden gevalideerd en waarmee condities kunnen worden gemaakt om testflows te sturen.

Performance testen

Er is een aantal manieren waarop performance van webservices getest kan worden:

  • Normaal testen, waarbij wordt getest of een systeem kan omgaan met dataload onder normale omstandigheden;
  • Load testen, het testen van een systeem waarbij het aantal requests wordt vergroot tijdens de test. Hierbij is het niet de bedoeling een systeem onderuit te halen;
  • Schaalbaar testen, waarbij niet het aantal requests maar de hoeveelheid data per request wordt verhoogd;
  • Stresstesten, het testen van een systeem waarbij het systeem zo zwaar wordt belast dat het niet meer of bijna niet meer functioneert;
  • Lange termijn testen, waarbij een systeem gedurende langere tijd wordt getest.

We gaan later nog in op mogelijkheden om verschillende loadtests te kunnen uitvoeren.

Testen in SoapUI

Om in SoapUI een test te kunnen opzetten moet eerst een project worden aangemaakt aan de hand van een WSDL. Tijdens het aanmaken vraagt SoapUI of er een TestSuite moet worden aangemaakt voor het project. Eventueel kan dit ook nog na het aanmaken van een project.

Aanmaken nieuw SoapUI project
Aanmaken van een nieuw SoapUI project

TestSuite en TestCases

Bij het creëren van een TestSuite wordt opgegeven of één of meerdere TestCases worden aangemaakt en welke operaties van de webservice in de test worden betrokken. Tevens kan worden gekozen om een default LoadTest aan te maken voor de TestSuite.

Het genereren van een TestSuite
Het genereren van een TestSuite

In de volgende afbeelding is te zien dat SoapUI voor een voorbeeldoperatie (echo) naast het standaard request een TestSuite heeft aangemaakt met daarin een TestCase, een bijbehorende TestSteps en een LoadTest.

Met een SecurityTest kan de beveiliging van een webservice worden getest, dit onderwerp valt buiten de scope van dit Whitebook.

Standaard aangemaakte onderdelen in SoapUI
Standaard aangemaakte onderdelen in SoapUI

In een TestSuite kan een aantal TestCases worden aangemaakt. Elke TestCase bestaat uit een aantal TestSteps en LoadTests. Er kunnen meerdere TestSteps aangemaakt worden om verschillende situaties of testflows te simuleren. Ook kunnen er meerdere LoadTests worden aangemaakt waarmee performance van een service op verschillende manieren worden getest. Zo kan een test gedurende een bepaalde tijd een constante bevraging doen, kan de frequentie van de bevraging worden opgevoerd en kan SoapUI de bevraging laten fluctueren.

TestSteps

De TestSteps kan, zoals de naam al doet vermoeden, meerdere Steps bevatten. Als de TestCase wordt aangemaakt is al een Step aangemaakt, namelijk een Test Request, in dit geval voor de operatie echo.

TestSteps in een TestCase
Teststeps in een TestCase

Hieronder volgt een korte beschrijving van enkele verschillende Steps die aan een TestCase kunnen worden toegevoegd.

Request/Response Steps

Request Steps worden gebruikt om een externe bron aan te roepen. Een SOAP request wordt gebruikt voor het aanroepen van een webservice. Naast SOAP biedt SoapUI ook ondersteuning voor Restservices, Http en JDBC voor het bevragen van een database. Een Mock Response stap kan worden gebruikt voor het testen van asynchrone services.

Met een SOAP Request wordt een operatie van de webservice toegevoegd als stap in een TestCase. Bij het aanmaken van een Test Request vraag SoapUI waarop de response van de operatie moet worden gevalideerd. Deze validatieregels worden Assertions genoemd.

De volgende assertions worden getoond:

  • Is het response bericht een valide SOAP bericht?
  • Kan het response bericht worden gevalideerd tegen de xsd?
  • Bevat het response bericht geen SOAP Fault?

Toevoegen van validatieregels aan TestCase
Toevoegen van validatieregels aan TestCase

Na het aanmaken van de Test Request kunnen er nog meer assertions worden toegevoegd. Zo kan er worden gecontroleerd of een service antwoord geeft binnen een bepaalde tijdslimiet.

Definitie van een SLA validatie
Definitie van een SLA validatie

Maximale responsetijd voor een call
Maximale responsetijd voor een call

Berichten kunnen gevalideerd worden met behulp van XPath of XQuery en er kan worden gecontroleerd of een bepaald element in een bericht wel of niet aanwezig is.

Testen op de inhoud van een bericht
Testen op de inhoud van een bericht

Steps voor het manipuleren van Properties

Properties kunnen waarden vasthouden voor later gebruik. Ze kunnen op verschillende niveaus worden aangemaakt:

  1. project niveau;
  2. testsuite niveau voor gebruikt in verschillende testcases;
  3. teststep voor gebruik binnen teststep.

De waarden van properties kunnen met een Property Transfer Step worden gezet. Daarbij wordt gebruik gemaakt van XPath. De SoapUI pro versie heeft een wizard voor het maken van XPath expersies.

Groovy script

In deze stap wordt met behulp van Groovy-scripting de test uitgebreid. Het toevoegen van Groovy script maakt het testen heel flexibel. Hier volgen enkele voorbeelden van het gebruik van Groovy:

  • In het groovy-script kan worden bepaald welke volgende stap in de test moet komen:

    testRunner.gotoStepByName("volgendestap")

  • Het uitvoeren van SQL statements voor bevraging van databases.
  • Het toevoegen van loggen statements:

    log.info('Hello World');

  • Het vullen of uitlezen van properties, zoals bijvoorbeekd het vullen van de waarde van de property 'datum' met de huidige datum:

    def sdf = new java.text.SimpleDateFormat("yyyy-MM-dd")
    testRunner.testCase.setPropertyValue( "datum", sdf.format(new Date()) )

Bekijk het weblog Groovy in SoapUI voor meer informatie en voorbeelden hierover.

Conditional Goto

In deze stap wordt met behulp van een XPath expressie bepaald welke vervolgstap in de TestCase moet worden genomen.

Delay

De delay is er voor het maken van een pauze in de test.

Loadtesten in SoapUI

Tijdens het aanmaken van een LoadTest in SoapUI wordt een default LoadTest aangemaakt. In de LoadTest wordt een aantal parameters opgegeven. Het gaat daarbij om aantal minuten dat de test in totaal duurt, het aantal threats dat wordt gebruikt tijdens een testronde en het aantal milliseconden dat tussen de tests moet worden gepauzeerd. Ook kan een test-strategie worden gekozen. De test-strategie bepaalt de manier waarop wordt getest. Enkele voorbeelden hiervan zijn 'Simpel' (voor een zo eenvoudig mogelijke test) en 'Burst' (voor het Stress-testen van een systeem). Ook kan het aantal threats tijdens een test langzaam worden opgevoerd. Tegelijkertijd kan worden gemonitord hoe een systeem reageert en bij welke hoeveelheid threats er problemen ontstaan.

Voor het monitoren van testen zijn eenvoudige grafieken beschikbaar. Bovendien kan de testdata ook worden geëxporteerd naar een CSV bestand zodat de data later kan worden geanalyseerd. De SoapUI pro versie biedt daarnaast meerdere mogelijkheden voor het opstelling van rapportages. Zo kan SoapUI pro direct een rapport genereren en kan data worden geëxporteerd naar een xml bestand.

Voor het loadtesten zijn er LoadTestAssertions. Hiermee wordt bijvoorbeeld het maximum aantal errors gecontroleerd dat een loadtest mag hebben tijdens een test.

De log - het overzicht van de resultaten van een test
De log - het overzicht van de resultaten van een test

LoadUI

Testen gemaakt met SoapUI kunnen ook worden uitgevoerd in LoadUI. LoadUI is een applicatie met een mooie userinteface en 'drag and drop' funcionaliteit.

Vanuit SoapUI kan een project worden geëxporteerd naar LoadUI waarbij de loadtest settings van SoapUI worden overgenomen. Bij het migreren van een TestCase zal SoapUI vragen om het pad naar LoadUI is geinstalleerd.

Instellingen voor LoadUI in SoapUI
Instellingen voor LoadUI in SoapUI

Als de locatie van LoadUI bekend is, wordt een nieuw project aangemaakt.

Converteren van SoapUI tests naar LoadUI
Converteren van SoapUI tests naar LoadUI

Als vanuit een SoapUI TestCase een LoadUI project wordt gegenereerd, worden er in LoadUI een aantal componenten aangemaakt waarmee een test direct kan worden gestart.

In onderstaande afbeelding zijn drie belangrijke windows te onderscheiden. De eerste is het Load window waarmee een test wordt aangestuurd. Dit window wordt afgeleid van de test-strategie zoals die in SoapUI is geconfigureerd. Het Load window wordt verbonden met de Runner window, die bepaalt welke TestSteps worden uitgevoerd. De TestSteps worden overgenomen uit SoapUI. Ten slotte is een Statics window aanwezig waarop de test realtime kan worden gemonitord aan de hand van de output van het Runner window.

LoadUI beschikt over een Statics Workbench, een geavanceerde grafische interface waarmee de test geanaliseerd kan worden. Met het Load window kan de testsnelheid realtime worden verhoogd of verlaagd. Veranderingen die daardoor optreden worden direct in de Statics Workbench getoond.

De grafische gebruikersinterface van LoadUI
De grafische gebruikersinterface van LoadUI

Conclusie

Met SoapUI is het mogelijke om zeer uitgebreide functionele- en performance tests te maken en uit te voeren. De kracht ligt onder meer in het grote scala aan teststappen die kunnen worden gebruikt. De teststappen worden in een TestCase gebruikt en geven de mogelijkheid voor het doen van uitgebreide functionele tests. De waarde van performance tests ligt vooral in het kunnen combineren van SoapUI en LoadUI. SoapUI kan loadtesten aanmaken, uitvoeren en biedt wat mogelijkheid tot het en analyseren van data die door de test is gegenereerd. LoadUI gaat hierin nog verder. Zo kan LoadUI testen langdurig uitvoeren, parameters kunnen realtime worden aangepast en testen kunnen realtime worden gemonitord in een geavanceerde userinterface.

Referenties

Waardering:
 

Reacties

Nieuwe reactie inzenden

De inhoud van dit veld is privé en zal niet openbaar worden gemaakt.

Meer informatie over formaatmogelijkheden

CAPTCHA
Deze vraag is om te testen of u een persoon bent en om spam te voorkomen
Image CAPTCHA
Enter the characters shown in the image.