Testautomation för WebApplikationer – Selenium
Skrivet av:
Paul Arcombe,
Certified ISTQB Foundation SoftwareTester,
Örestad-Linux, Malmö
Projektet går ut på att
- Undersöka vad Selenium kan erbjuda inom automatiserad test av webapplikationer.
- Installera och sätta upp Selenium.
- Bygga och slutligen använda enskilda tester med hjälp av Selenium.
- Att sätta upp och få igång en fungerande testmiljö bestående av Selenium, Java och JUnit
- BASICS: Hur man använder testsviter/multipla test från Selenium m.h.a. Java och JUnit.
- ADVANCED (I): Skriva/modifiera skript m.h.a. skriptspråket Selenese.
- ADVANCED (II): Loggar, Test sammanfattningar och Test rapporter
Projektet är avsett att uppdateras en gång per vecka, med start 091116. Avslutat 091231.
KAPITEL 5: BASICS: Hur man använder testsviter/multipla test från Selenium m.h.a. Java och JUnit.
I detta kapitel skall vi lära oss grundmetodiken för hur man lägger upp en strategi inför körning av hela testsviter. De alternativ man kan stå inför när man skall sätta ihop en testsvit kan vara att:
- sätta upp en testsvit innehållande många helt nya test.
- sätta upp en testsvit innehållande många gamla test ur tidigare regressionstester.
- sätta upp en testsvit innehållande en blandning av gamla och nya test, som inte kommer att hämtas från en och samma server / lagringsplats.
Dessa punkter kan sammanfattas i två spår att följa:
- Skriv ett TC som kör java.class filer för varje enskillt TC. Den samling av TC du får körs sedan av ett Batch-skript.
- Skriv ett dynamiskt TC som kör java.class filer efterhand, oberoende av var de befinner sig (TC och PATH hårdkodat i TC eller datafil)
Innan vi drar igång kodningen av exempelprogram, går vi igenom lite basics för att underlätta förståelsen av det som komma skall.
Att använda Base URL för att köra Test Fall (= Test Cases = TC) i olika Domäner
Base URL fältet längst upp i Selenium IDE fönstret används för att definiera domännamnet för respektive TC som skall köras. Detta underlättar så man inte nödvändigtvis MÅSTE ange korrekt domän inne i koden. Titta på nedanstående exempel från din tidigare WikiSearch.java:
Base URL i setup-metoden är wikipedias svenska hemsidas domännamn. Detta är en absolut URL (fullständig, börjar med “http eller https”):
medan en relativ URL i testmetoden anger var i domänen man vill starta:
En fullständig absolut URL skapas av Domännamns absolut URL + relativ URL. Detta gör Selenium automatiskt när det kör ditt test.
Exempel 1: Om man lägger upp en testversion av denna wikipedia på ett annat ställe i domänen och vill köra ett eller flera test specifikt på denna, anger man bara dess relativa URL som start för de testen.(t.ex. selenium.open(”/betatest/wiki/Portal:Huvudsida”)) Sedan återgår man till den ursprungliga relativa URL’en igen.
Exempel 2: Om man lägger en testversion på en helt annan testdomän, anger man den nya domänen istället. (t.ex. setup(”http://www.stenstures.testserver.se”))
Att skapa och använda Batch-skript.
Batch skript skrives i någon texteditor som Edit (doseditor), Notepad (Windowsapplikation), TextPad (tredjepartsprogram).
För att ha full DOS kompabilitet bör man hålla sig till en enkel namngivning av batch filerna med 8+3 tecken. Exempel: filnamnx.bat. Batch filen brukar läggas så nära roten (C:\) som möjligt. Helst under en egen katalog t.ex. C:\batch\..x.bat01..y.bat….
För att nå hjälpen i DOS, öppnar du en kommandoprompt genom att
- gå till START – KÖR –
- skriv in ”cmd” i Öppna fältet och
- tryck på OK
- vid kommandoprompten skrive du ”help”
Detta ger dig alla de doskommando som finns tillgängliga i den OS version du kör. För att få detaljerad hjälp för de olika kommandona skriver du ”help” och kommandot, eller bara kommandot och ”/?”.
Hjälp för att skriva (syntax) batchfiler kan man finna på följande länkar:
http://www.scribd.com/doc/970858/MsDos-Batch-Script-Guide-Script-Language-Syntax-and-Exam
http://ss64.com/nt/syntax.html
För att köra batchfilen, startar du den
- från kommandoprompten genom att navigera fram till den och skriva dess namn,
- eller genom att lägga en länk till den från en startkatalog och sedan starta den direkt från startkatalogen manuellt eller inifrån ett annat program.
Att skapa och använda paket (package) filer i java
Varje fil måste ha en package deklaration som kommer före all annan kod. Package namnet måste vara det samma som den mapp vari filen är placerad. Om en package deklaration inte anges, föutsättes alla klasser i den mappen tillhöra detta ”default” package.
Exempel: två filer som ligger i C:\packagetest\
package packagetest;
class ClassA {
public static void main (String [] args) {
ClassB.greet();
}
}
och
package packagetest; // Same as in previous file.
class ClassB {
static void greet() {
System.out.println(”Packagetest in progress!”);
}
}
Notera att dessa källfiler måste namnges ClassA.java och ClassB.java (obs känslighet för versaler), och de måste vara i sökvägen packagetest. För att kompilera exempelfilerna måste du vara utanför packagetest mappen.
javac packagetest/ClassB.java
javac packagetest/ClassA.java
För att köra main programmet i ClassA:
java packagetest.ClassA
eller
java packagetest/ClassA
Nu har du gått igenom de grunder som krävs för att kunna gå vidare med hantering av multipla testfallskörningar i Selenium med java och JUnit enligt de två metoder som nämndes tidigare:
- Skriv många standalone TC som kör respektive java.class fil för varje enskilt TC. Den samling av TC du får körs sedan av ett Batch-skript där PATH, CLASSPATH och TC-sökvägar specificeras. Vidare så samlar Batch-skriptet ihop testresultaten i en resultatfil (textfil).
- Skriv ett dynamiskt TC som kör java.class filer efterhand, oberoende av var de befinner sig (TC och PATH hårdkodat i TC eller datafil)
Att köra multipla testfall (Skriv många standalone TC)
I många fall kommer du att behöva köra fler än ett testskript. Här följer ett exempel på hur man kör multipla skript och sparar resultatet av körningarna mha batch fil enligt ovanstående metod 1.
Börja med att skapa följande standalone testskript (gör dem så enkla som möjligt, tex vanliga 1-stegs Google search test):
WikiSearch1a, WikiSearch3a och WikiSearch1b
WikiSearch1d, WikiSearch2d och WikiSearch3d
Modifiera dem som fristående javaprogram såsom WikiSearch testet tidigare.
För att skapa en batchfil som skall köra testen, öppnar du enklast notepad och skriver in följande text (eller liknande som passar dina testfall)
@cls
@echo ==========================================================
@echo = This is the startup script for running multiple standalone java TC’s on =
@echo = Selenium Server RC ver. 1.0.1. This script collect the testresults in a =
@echo = txt file as well. =
@echo ==========================================================
@echo.
@echo ———————————————————-
@ cd\
@REM add new specific path’s you need after %CLASSPATH%;…..
@set CLASSPATH=%CLASSPATH%;
@REM add new specific system path’s you need after %PATH%;…..
@set PATH=%PATH%;
@REM
@REM Navigate to your main testfolder
@ cd C:\selenium\Tests\wikinew
@REM Run the tests in main testfolder,
@REM note the first line has one > (overwrite the file)
@REM and the rest has two >> (add text to file)
@java WikiSearch1d >c:\TestResults.txt
@REM This pauses the program. To continue you have to confirm.
@REM This step may be omitted when you run TC’s in real environments
@pause
@java WikiSearch2d >>c:\TestResults.txt
@REM This pauses the program. To continue you have to confirm.
@REM This step may be omitted when you run TC’s in real environments
@pase
@java WikiSearch3d >>c:\TestResults.txt
@REM This pauses the program. To continue you have to confirm.
@REM This step may be omitted when you run TC’s in real environments
@pause
@REM
@REM Navigate to other testfolders if required
@ cd C:\selenium\Tests\wikiold
@REM Run the tests in other testfolder
@java WikiSearch1a >>c:\TestResults.txt
@REM This pauses the program. To continue you have to confirm.
@REM This step may be omitted when you run TC’s in real environments
@pause
@java WikiSearch3a >>c:\TestResults.txt
@REM This pauses the program. To continue you have to confirm.
@REM This step may be omitted when you run TC’s in real environments
@pause
@java WikiSearch1b >>c:\TestResults.txt
@REM Now the tests are finished and we complete
@REM the run display the whole list of result
@echo.
@echo ———————————————————-
@echo.
@ echo off
set TEXT_T=”C:\file.txt”
FOR /F “eol= tokens=* delims= usebackq” %%i in (%TEXT_T%) do (echo %%i)
@REM Or the simpler statement: @FOR /F %%i IN (TestResults.txt) DO @echo %%i
@echo ———————————————————-
@ echo on
@echo.
Vad som händer här är att du kör först 3 st testfall från C:\selenium\Tests\wikinew:
WikiSearch1d, WikiSearch2d och WikiSearch3d.
- Dessa testfalls resultat läggs in I resultatfilen TestResults.txt.
- Sedan kör du ytterligare testfall från C:\selenium\Tests\wikiold:
WikiSearch1a, WikiSearch3a och WikiSearch1b
- Dessa testfalls resultat läggs även de in I resultatfilen TestResults.txt.
- Slutligen skrives all info som lagrats i TestResults.txt ut på skärmen I kommandofönstret.
Om du vill rationalisera dina test, kan du även lägga in start av selenium servern i Batch skriptet:
@REM PATH to server:
@cd C:\selenium-remote-control-1.0.1\selenium-server-1.0.1
@java -jar selenium-server.jar -log session.log
@pause
Att köra multipla testfall (Skriv ett dynamiskt TC)
Det kan vara jobbigt att använda sig av ovanstående metod om man inte är van att skriva skript, eller föredrar att ha allt i sin javakod. Därför kan vi även ta med detta exempel hur man lägger upp sin testsvit för att köras direkt från javafil.
Först börjar du med att lägga upp alla test som java packages. Ett generellt schema att följa ser ut så här (läs bara igenom, det kommer ett komplett exempel längst ner):
package com.example.tests;
import com.thoughtworks.selenium.*;
import java.util.regex.Pattern;
public class NewTest extends SeleneseTestCase {
public void setUp() throws Exception {
setUp( “http://www.google.com/” , “*firefox” );
}
public void testNew() throws Exception {
selenium.open( “/” );
selenium.type( “q” , “selenium rc” );
selenium.click( “btnG” );
selenium.waitForPageToLoad( “30000″ );
assertTrue(selenium.isTextPresent( “Results * for selenium rc” ));
}
}
Där du modifierar:
- package (sökväg till ditt eget paket)
- public class (namnet på din egen klass)
- setUp( “” ) (den URL och browser du själv använder)
- public void — () throws Exception (Namnet på din egen TC-klass)
- samt allt som står under TC-klassen är specifikt för ditt test
Sedan skapar du en testsuite klass med main i vilken du lägger till dina testfall (se Arkiv i Selenium IDE verktygslist). Vilken ser ut så här i grundutförande:
import junit.framework.Test;
import junit.framework.TestSuite;
public class Testsuite {
public static Test suite() throws Exception {
TestSuite suite = new TestSuite();
suite.addTestSuite(Untitled.class);
[...]
suite.addTestSuite(Untitled.class);
[...]
return suite;
}
public static void main(String[] args) {
junit.textui.TestRunner.run(suite());
}
}
Här lägger du till dina testfallsklasser i strängar som:
suite.addTestSuite(Untitled.class);
Untitled.class bytes ut mot klassfilens namn.
[...] här skriver du ev. tillägg som behöver köras mella respektive test om det behövs.
Ett annat sätt att skriva Test suite () funktionen kan vara så här:
public static Test suite() throws Exception {
TestSuite suite = new TestSuite();
addTestCase(suite, Untitled.class);
[...]
addTestCase(suite, Untitled.class);
[...]
return (suite);
}
Här får du ett komplett exempel (sånär som på javakoden för resp. test. Där kan du lägga in egna test…)
Att skriva en TestSuite.
En testsuite är en samling testfall (som visas i Selenium IDE’s vänstra panel,”TestCase”). TestCase panelen kan öppnas eller stängas manuellt genom att klicka på det prickiga området längst ut i kanten till vänster. Den kommer även upp om man skapar ett nytt testcase. Här väljer man sedan vilket/vilka testcase man skall arbeta med.
I Selenium IDE’s Arkiv meny i verktygslisten, väljer du om en ny TestSuite skall skapas eller om du vill öppna upp en gammal. Problemet är att du måste ha tillgång till HTML-filerna för alla de testfall du vill arbeta med, annars får du skapa nya sådana. Selenium IDE kan inte arbeta med några andra format då TestSuites skall skapas. Alternativet är att skapa din TestSuite genom att manuellt editera den (vilket i och för sig inte är särskillt svårt, eftersom man bara behöver namnet på filen).
En testsuite fil är en HTML fil som innehåller en enkolumns tabell. Varje cell av varje rad i <body> sektionen innehåller en länk till ett testfall. Exemplet nedan kommer från en testsuite som innehåller två testfall, MyFirstTestCase.html och MysecondTC.html. Dessa testfall ligger i sökvägen C:\Selenium\tests\. Testfallen skapades först och exporterades som java JUnit filer. Sedan skapades TestSuiten som en ny TestSuite, där testfallens HTML filer lades till från menyn Arkiv – Add Test Case…:
<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”>
<html xmlns=”http://www.w3.org/1999/xhtml” xml:lang=”en” lang=”en”>
<head>
<meta content=”text/html; charset=UTF-8″ http-equiv=”content-type” />
<title>Test Suite</title>
</head>
<body>
<table cellpadding=”1″ cellspacing=”1″ border=”1″><tbody>
<tr><td><b>Test Suite</b></td></tr>
<tr><td><a href=”tests/MyFirstTestCase.html”>MyFirstTestCase</a></td></tr>
<tr><td><a href=”tests/MysecondTC.html”>MysecondTC</a></td></tr>
</tbody></table>
</body>
</html>
För att sedan skapa din TestSuite som en fristående javafil behöver du egentligen inte göra så mycket mer. Efter det du skapat din HTML-fil, exporterar du den som javakod (Gå till Selenium RC menyn):
Arkiv – Export TestSuite As…- Java (JUnit)-Selenium RC
Sedan är det klart, och du får ett slutresultat som ser ut så här:
import junit.framework.Test;
import junit.framework.TestSuite;
public class NewtestSuite {
public static Test suite() {
TestSuite suite = new TestSuite();
suite.addTestSuite(MyFirstTestCase.class);
suite.addTestSuite(MysecondTC.class);
return suite;
}
public static void main(String[] args) {
junit.textui.TestRunner.run(suite());
}
}
Nu har du lärt dig grundmetodiken för vad som krävs för att kunna köra multipla tester / TestSuites och hur de fungerar i Java.
Du har lärt dig hur man skapar dem manuellt och mha inbyggda TestSuite funktioner i Selenium IDE. Du har lärt dig lite om att skriva skript som kan styra TestSuites samt grunder för att själv modifiera standalone javaprogram så de kan köra dina TestSuites individuellt anpassat efter specifika krav. Du är nu klar att gå vidare till nästa kapitel.