Die Testing-Plattform Robot Framework, Teil 2 Erste Bots und Keywords mit dem Robot Framework

Von Mirco Lang 6 min Lesedauer

Was das Robot Framework kann, haben wir beleuchtet, nun ist es Zeit für etwas Praxis: Der Weg zu ersten laufenden Tests und eigenem Code ist im Grunde recht simpel – und anschließend ist der Spieltrieb garantiert geweckt.

Report eines Testdurchlaufs mit dem Robot Framework.(Bild:  Lang / Robot Framework)
Report eines Testdurchlaufs mit dem Robot Framework.
(Bild: Lang / Robot Framework)

Die Robot-Framework-Grundlagen zu verstehen, ist ziemlich einfach, insbesondere simple Testfälle sind durch die Keywords intuitiv nachvollziehbar. Etwas komplexer wird es, wenn es ans Hands-on-Training geht. Hier lauern kleine Hürden und die an sich recht gute Dokumentation ist mehr Referenz als Anleitung. Es gibt zwar offizielle Tutorials und Beispiele, aber über etliche Quellen verteilt, teils unvollständig und für Einsteiger überhaupt schwer zu identifizieren.

Im Folgenden zeigen wir Schritt für Schritt, wie man das Robot Framework unter Ubuntu zum Laufen bringt, die offizielle Web-Demo verarbeitet und sie anschließend um einen eigenen Hello-World-Test erweitert. Wir werden eigenen Python-Code als Keyword einbauen, mit Variablen arbeiten und zeigen wie die unterschiedlichen Dateien zusammenhängen.

Gleich zu Beginn wird es ein wenig obskur: Ausgerechnet unter Ubuntu ist der Einstieg deutlich lästiger als selbst unter Windows …

Firefox unter Ubuntu vorbereiten

Robot Framework bietet eine Demo zum Testen eines Logins im Browser mit der Selenium-Bibliothek. Auf den meisten Systemen ist das kein Problem, aber hier kommt Firefox zum Einsatz, den Ubuntu per Snap bereitstellt – und damit funktionieren etliche Beispiele nicht. Also muss zunächst die Snap-Version vom Firefox der Apt-Version weichen. Zunächst benötigen wir das zugehörige PPA (Personal Package Archive):

sudo add-apt-repository ppa:mozillateam/ppa

Anschließend muss die Apt-Version den Vorzug vor der Snap-Version bekommen; einfach im Ganzen per Copy-and-Paste im Terminal ausführen:

echo '
Package: *
Pin: release o=LP-PPA-mozillateam
Pin-Priority: 1001
Package: firefox
Pin: version 1:1snap1-0ubuntu2
Pin-Priority: -1
' | sudo tee /etc/apt/preferences.d/mozilla-firefox

Nun lassen sich der Snap-Firefox entfernen und der Apt-Firefox installieren:

sudo snap remove firefox
sudo apt install firefox

Damit stehen die Voraussetzungen für die Web-Demo.

Robot Framework einrichten

Die Ausführung von Robot-Framework-Suiten geschieht in der Regel in virtuellen Umgebungen, standardmäßig via venv, wo weitere Abhängigkeiten per pip installiert werden. Zunächst die Installationsanweisung für die Voraussetzungen:

sudo apt update
sudo apt install python3 python3-pip python3-venv

Anschließend können wir die virtuelle Umgebung einrichten und starten – in einem beliebigen Projekt-Ordner, der fortan alle Suiten und Tests beinhalten soll (hier: ~/projects).

cd ~/projects
python -m venv .venv
source .venv/bin/activate

Nun befinden wir uns in der virtuellen Umgebung, zu erkennen am Prompt, und die Demo kann heruntergeladen werden:

git clone https://github.com/robotframework/WebDemo.git
cd WebDemo

Nun sollen die Abhängigkeiten installiert werden, die in der „requirements.txt“ gelistet sind:

pip install -r requirements.txt

Damit werden insbesondere Robot Framework selbst sowie die Selenium-Bibliothek installiert, die Funktionen zum Testen via Browser zur Verfügung stellt. Was noch fehlt, ist die zu testende App. Diese liegt im Ordner „demoapp“ und lässt sich via …

./demoapp/server.py &

… starten und auf Wunsch in den Hintergrund versetzen. Damit ist alles fertig eingerichtet und wir können Robot Framework auf den Ordner „login_tests“ loslassen, der wiederum mehrere Suiten, also robot-Dateien enthält:

robot login_tests

Terminal-Ausgabe des robot-Befehls.(Bild:  Lang / Canonical)
Terminal-Ausgabe des robot-Befehls.
(Bild: Lang / Canonical)

Daraufhin wird es auf dem Desktop hektisch: Es öffnet sich ein Browser mit der Login-Seite der eben gestarteten Demo-Anwendung, die Felder für Nutzername und Passwort werden ausgefüllt, der Browser schließt sich und so weiter. Im Terminal erscheint eine simple Ausgabe mit den diversen Tests und – hoffentlich – dem Status „Pass“.

Report eines Testdurchlaufs.(Bild:  Lang / Robot Framework)
Report eines Testdurchlaufs.
(Bild: Lang / Robot Framework)

Zudem werden einige Dateien im Ordner abgelegt. Wichtig sind hier der Report und die ausführlichere Log-Datei. Der Report findet sich in der Datei „report.html“. Der Report ist aber nicht bloß eine schlichte HTML-Datei. Vielmehr ist es möglich, diesen zu durchsuchen oder nach Tags zu filtern und sich durch die einzelnen Tests zu klicken.

Detailliertes Log eines Testdurchlaufs.(Bild:  Lang / Robot Framework)
Detailliertes Log eines Testdurchlaufs.
(Bild: Lang / Robot Framework)

Von hier aus kommen wir auch zur Log-Datei, die im Ordner als „log.html“ abgelegt wurde. Hier lassen sich die Ergebnisse bis hinunter auf die letzten Keywords aufklappen. Wenn so weit alles funktioniert, empfiehlt sich ein kurzer Blick in die Tests und Dateien, um die Zusammenhänge zu verstehen.

Tests und Zusammenhänge

Hier erst mal ein leicht gekürzter Auszug aus der Suite „valid_login.robot“:

*** Settings ***
...
Resource resource.robot
...
*** Test Cases ***
Valid Login
   Open Browser To Login Page
   Input Username   demo
   Input Password   mode
   Submit Credentials
   Welcome Page Should Be Open
   [Teardown]   Close Browser

Die „Test Cases“ dürften hier intuitiv verständlich sein: Der Browser wird mit der „Login Page“ geöffnet, dann folgt das Login und die „Welcome Page“ sollte gezeigt werden. Nun stellt sich die Frage, wo genau die „Login Page“ liegt und wie die „Welcome Page“ aussehen soll. Das zeigt die hier „importierte“ Datei „resource.robot“, die Keywords und Variablen bereit hält – für alle Suiten, die diese referenzieren. Im Folgenden ein kleiner Auszug:

Jetzt Newsletter abonnieren

Täglich die wichtigsten Infos zur IT-Sicherheit

Mit Klick auf „Newsletter abonnieren“ erkläre ich mich mit der Verarbeitung und Nutzung meiner Daten gemäß Einwilligungserklärung (bitte aufklappen für Details) einverstanden und akzeptiere die Nutzungsbedingungen. Weitere Informationen finde ich in unserer Datenschutzerklärung. Die Einwilligungserklärung bezieht sich u. a. auf die Zusendung von redaktionellen Newslettern per E-Mail und auf den Datenabgleich zu Marketingzwecken mit ausgewählten Werbepartnern (z. B. LinkedIn, Google, Meta).

Aufklappen für Details zu Ihrer Einwilligung
*** Settings ***
Library      SeleniumLibrary
*** Variables ***
${SERVER}      localhost:7272
${BROWSER}      Firefox
${LOGIN URL}   http://${SERVER}/
${WELCOME URL}   http://${SERVER}/welcome.html
*** Keywords ***
Open Browser To Login Page
Open Browser   ${LOGIN URL}   ${BROWSER}
Maximize Browser Window
Set Selenium Speed   ${DELAY}
Login Page Should Be Open
Login Page Should Be Open   Title Should Be   Login Page

Im Bereich „Settings“ wird die Selenium-Bibliothek referenziert, die wiederum die Browser-Funktionalität bereitstellt. Unter „Variables“ finden sich die Werte für den Host, den gewünschten Browser, Login-URL und so weiter. Verwendung finden diese bei den „Keywords“. So übersetzt sich also im Grunde „Open Browser ${LOGIN URL} ${BROWSER}“ zu einem Aufruf wie „firefox localhost:7272“.

Die „valid_login.robot“ nutzt also die „resource.robot“ quasi wie eine Bibliothek, die wiederum Bibliotheken importiert, Variablen und Keywords bereitstellt. Das ganze Konstrukt käme freilich ohne die resource-Datei aus, Keywords & Co. ließen sich auch direkt in der „foobar.robot“ setzen. Über diese einfache Verschachtelung lassen sich aber schön abstrakte Sammlungen aufbauen.

Nun folgt der richtig spannende Teil: Wie kommt eigener Python-Code in die Tests?

Python-Funktionen als Keywords

Auch hier soll es mal wieder ein simples Hello-World-Beispiel sein, das in die obige Umgebung eingebaut wird. Dafür braucht es insgesamt drei Schritte/Dateien:

  • WebDemo/login_tests/foobar.py: Bibliothek mit Python-Funktionen
  • WebDemo/login_tests/resource.robot: eigene Bibliothek, Variable, Keyword bereitstellen
  • WebDemo/login_tests/foobar.robot: minimale Suite

Die Bibliothek foobar.py soll lediglich testen, ob eine übergebene Variable dem Wert „foobar“ entspricht. Falls ja, wird nur ein Infotext ausgegeben, der Test ist erfolgreich. Falls nicht, wirft die Funktion eine Exception, statt einfach auf „False“ zu evaluieren. Mit der Exception schlägt der Test direkt fehl, über False müsste noch eine Abfrage eingebaut werden, damit Robot Framework den Fehlschlag als solchen wertet.

Hier der Code:

import sysdef test_variable(myvar):
   if myvar == "foobar":
      print('*INFO* My message true')
      return True
   else:
      print('*INFO* My message false')
      raise Exception("Process timed out")
# return False
if __name__ == "__main__":
   if len(sys.argv) != 2:
      sys.exit(1)
      myvar = sys.argv[1]
   print(test_variable(myvar))

Wichtig sind nur drei Dinge: Die Namen der Funktion, „test_variable“, der Variablen, „myvar“, und der Datei, „foobar.py“.

In der resource.robot wird aus dem Skript nun eine Bibliothek; hier die relevanten Zeilen:

*** Settings ***
Library foobar.py
*** Variables ***
${MYVAR} foobar
*** Keywords ***
fookey
   test_variable   ${MYVAR}

Wie zuvor die Selenium-Bibliothek, wird nun das Python-Skript einbezogen. Die Variable wird zur Verfügung gestellt und auch gleich auf den Wert „foobar“ gesetzt – das lässt sich aber beim Aufruf später noch ändern. Im Anschluss wird das neue Keyword „fookey“ erzeugt. Und damit lässt sich dann wieder ein Testfall umsetzen, hier die Suite foobar.robot:

*** Settings ***
Resource resource.robot
*** Test Cases ***
Testing von foobar
   Log   Variable ist ${myvar}
   test_variable   ${myvar}

Zunächst wird wieder die resource.robot einbezogen, die wiederum die lokale Python-Funktion aufruft. Anschließend folgt der eigentliche Testfall, der schlicht per Robot-Framework-internem Befehl „Log“ (quasi ein echo-Äquivalent) die Variable ausgibt und dann über „test_variable ${myvar}“ die Python-Funktion Aufruft aus dem Skript aufruft und ihr den Wert der Variablen übergibt.

Wollen wir das Ganze nun testen, müssen wir nicht wieder den kompletten Ordner mit allen Suiten ausführen lassen, sondern können direkt diese Suite auswählen:

robot login_tests/foobar.robot

Auch die Variable myvar lässt sich erneut übergeben:

robot --variable myvar:foobar-false login_tests/foobar.robot

Der erste eigene Test in der Log-Datei.(Bild:  Lang / Robot Framework)
Der erste eigene Test in der Log-Datei.
(Bild: Lang / Robot Framework)

Wieder lohnt ein Blick auf die Log-Datei. Damit sollte es nun möglich sein, Robot Framework tatsächlich in der Praxis zu nutzen – auch wenn es natürlich noch sehr viel mehr zu lernen gibt! Vieles spielt sich aber auf genau diesem Fundament ab: Organisation über Verschachtelung und Keywords, Erweiterung über fertige Bibliotheken oder individuellen Code, Schreiben von Suiten mit Keywords und Variablen und der Einsatz der robot-Kommandozeilenoptionen.

Zum Schluss noch ein kurzer Blick auf RCC, um den Beschreibungen aus Teil 1 den Praxisbezug zu geben: RCC-kompatible Suiten können direkt über die RCC-Binary ausgeführt werden – ohne jegliche Installationen, ohne die env-Umgebungen oder sonstige Konfigurationen. Spannend!

(ID:49993648)