Robotium - raczk(test)ujemy
Jakiś czas temu zainteresował mnie temat automatycznego testowania aplikacji na system Android, więc nie czekając długo pośpieszyłem do wujka Googla, aby zadać mu ważne zapytanie "Jak testować Androida?". Wśród znalezionych wyników odnalazłem Robotium... W mej głowie zrodziło się pytanie: "Cóż to za twór? " i nie dłużej niż moment ciocia Wiki odpowiedziała: "Robotium to open-sourcowy test framework do pisania automatycznych testów czarnej skrzynki dla aplikacji na system Android."
Tyle lania wody, a teraz do rzeczy. Jak w wstępie wspomniałem Robotium to narzędzie wspomagające testowanie funkcjonalne aplikacji Androidowych. Takie test zwane są testami czarnej skrzynki (black-box tests) lub testami wyjścia/wejścia. Polegają one na sprawdzeniu poprawnego działania funkcji programu/urządzenia opisanych w dokumentacji dostarczonych przez twórcę. Owe testy mogą tylko opierać się na danych wejściowych i analizie danych wyjściowych, które otrzymujemy. W przypadku jakiejkolwiek braku implementacji funkcji wymaganych przez założenia, testy funkcjonalne wykryją błąd, a Robotium pomoże nam takie testy zautomatyzować.
3, 2, 1, 0 ... start
Aby móc rozpocząć pracę z Robotium musimy zadbać o stworzenie odpowiedniego środowiska pracy. Pierwszym krokiem będzie pobranie i instalacja odpowiednich komponentów, na które składają się:
Uprzedzając komentarze mam świadomość, że istnieje Android Developer Tools Bundle, które zawiera wszystkie niezbędne narzędzia, ale dzięki mojej wersji tworzenia środowiska, możemy bardziej zbliżyć się do zielonego robocika :)
- 1. JDK (Java Development Kit) Zaciągamy wersję JDK z strony Oracla i po prostu instalujemy metodą "Dalej, Dalej". W moim przypadku wybrałem wersję 6. [img=jdk1][join][img=jdk2]
- 2. Eclipse for Java Z tym programem robimy podobnie wybieramy wersję Eclipsa dla Javy i po pobraniu rozpakowujemy w dla nas dogodnym miejscu. [img=eclip1]
- 3. Android SDK Analoicznie do Eclipse ;) Trzeba pamiętać, żeby pobrać tylko wersję z SDK (SDK Tools Only). [img=sdk1]
- 4. Robotium J/W tylko nie rozpakowujemy Jara - on nam jest potrzebny w całości ;) [img=robo1]
W moim przypadku wszystko (prócz JDK) wrzuciłem do wspólnego katalogu:
F:\Android_Tests\ ./sdk ./eclipse ./robotium-solo-3.6.jar
Zmienne środowiskowe
Dla własnej wygody tworzymy kilka zmiennych środowiskowych (użytkownika). Takie zmienne dodajemy w System -> Właściwości systemu -> Zaawansowane - > Zmienne środowiskowe. Pierwszą z nich jest ANDROID_HOME wskazująca na folder z sdk F:\Android_Tests\sdk, dalej JAVA_HOME miejsce C:\Program Files\Java\jdk1.6.0_38 i ostatecznie zmienna PATH (jeśli już taką mamy to dopisujemy kolejne lokalizacje po średniku) %JAVA_HOME%\bin;%ANDROID_HOME%;%ANDROID_HOME%\tools;%ANDROID_HOME%\platform-tools;
Po tym klikamy Zastosuj/OK i przechodzimy do kolejnego kroku.
Konfiguracja Eclipse
Jak sam nagłówek wskazuje, w tym momencie przeprowadzimy szereg zabiegów, dzięki którym otrzymamy całe środowisku do pracy, a więc nie ma na co czekać! Do roboty!
Po uruchomieniu Eclipse niezwłocznie przechodzimy do "Help" -> "Install New Software..." Powinno otworzyć się okienko - zaś po jego prawej stronie powinniśmy zobaczyć przycisk "Add" (klikamy na niego) i dodajemy repozytorium "Android Development Tools (ADT)".
http://dl-ssl.google.com/android/eclipse/
Po dodaniu owego repozytorium powinno pojawić się ono w liście rozwijanej "Work with" - wybieramy je i ptaszkujemy całą grupę" Developer Tools". Kolejno klikamy "Next" i czekamy (może to zająć dłuższą chwilę), aż pakiety zostaną pobrane i zainstalowane w naszej "Eclipse". Teraz potrzebujemy restartu naszej E.
Gdy Eclipse włączy się ponownie musimy przejść do "Window" -> "Preferences" -> "Android" i ustawiamy ścieżkę do naszego "SDK"
W dalszym korku jesteśmy zmuszeni wejść do ustawień "kompozycji perspektywy", aby dodać potrzebne nam pozycję w menu "Window". W tym celu udajemy się do "Window" -> "Customize Perspective..." -> zakładka "Commands Groups Availability" i ptaszkujemy: "Android SDK i AVD Manager".
Następnie korzystamy z opcji "Android SDK Manager", która pojawia się w menu "Window". Tam wybieramy cały katalog "Tools" i interesującą nas wersję Androida, na którym będziemy testować nasze aplikację. Ja u siebie wybrałem dwie platformy "Androida 4.2 (API 17)" i "Android 2.3.3 (API 10)". [img=avm]
Po żmudnym zaciąganiu wymaganych paczek możemy przystąpić do stworzenia AVD (Android Virtual Devices), czyli wirtualnego urządzenia z Androidem, na którym będziemy uruchamiać nasze testy. Aby to uczynić musimy wejść w menu "Window" i wybrać Android "Virtual Device Manager". W okienku, które się pojawi klikamy przycisk "New..." i tworzymy nową maszynę. W zrzucie ekranu poniżej przedstawiona maszyna, którą utworzyłem na potrzeby swoich testów. [img=new_avd][join][img=avd]
Przygotowanie do testów:
Po tych wszystkich zabiegach możemy przystąpić do "napisania" pierwszego testu. W tej chwili posłużymy się gotowym przykładem testu i aplikacji z strony Robotium. Pierwsze musimy pobrać aplikację, którą będziemy chcieli przetestować. Program znajdziemy pod tym linkiem robotium.googlecode.com/files/AndroidCalculator.apk - klikamy i zapisujemy. Ważną rzeczą jest, aby aplik apk podpisany był takim samym kluczem debugowym jak nasza jeszcze nie stworzony projekt testu. Dlatego też pobierając taką aplikację z Internetu jesteśmy pewni, że klucz nie będzie się zgadzał, więc musimy go podpisać na nowo. Do tego posłuży nam program re-sign z strony troido.de/re-sign.jar. Owy sofcik działa bardzo prosto - plik apk przeciągamy na otwarte okienko i zapisujemy na nowo podpisaną aplikację.
Instalujemy nowo-podpisaną apkę na swoim AVD - robimy to w następujący sposób:
[list] [item]uruchamiamy wiersz poleceń (cmd) - Windows + R i w okienku wpisujemy cmd[/item][item]w cmd wpisujemy polecenie:
emulator -avd Moje_AVD
[img=cmd_avd_run] po tej czynności powinien uruchomić się stworzony przez nas emulator [img=avd_aa]
[/item][item]teraz pozostaje nam instalacja apk, umożliwia nam to polecenie
adb install F:\AndroidCalculator_debug.apk
[/item][/list]
Nareszcie zaczynamy:
W tym momencie spełniliśmy wszystkie wymagania, aby móc zacząć pisać swój pierwszy test. Teraz przed nami zadanie stworzenia projektu testowego. Tworzymy go poprzez wejście do "File" -> "Other..." i wybranie z drzewka "Android" -> "Android Test Project".
Klikamy "Next", podajemy nazwę projektu, "Next", wybieramy wersję Androida, "Finish" i mamy utworzony projekt testowy. [img=test_project3][join][img=test_project4]
Klikamy prawym przyciskiem myszy na projekcie i wybieramy "New" -> "Package". W oknie "New Java Package" wypełniamy pole "Name" - wpisujemy nazwę charakterystyczną, w moim przypadku nazwa testowanej aplikacji z przedrostkiem test - com.testcalculator.
Teraz musimy stworzyć nową klasę dlatego klikamy znów prawym przyciskiem myszy, ale tym razem na stworzonym "Package" i dajemy "New -> Class". Wpisujemy nazwę klasy np. "testowanko" i naciskamy "Finish".
W utworzonej klasie będzie zawarty cały kod naszego testu - po jego napisaniu klikamy przycisk 'Save', aby nam nie uciekł ;)
package com.testcalculator; import com.jayway.android.robotium.solo.Solo; import android.test.ActivityInstrumentationTestCase2; @SuppressWarnings("unchecked") public class Testowanko extends ActivityInstrumentationTestCase2{ //nazwa aplikacji (pakietu) testowanej private static final String TARGET_PACKAGE_ID="com.calculator"; //nazwa aktywności naszej aplikacji - Main = główne okno aplikacji private static final String LAUNCHER_ACTIVITY_FULL_CLASSNAME="com.calculator.Main"; private static Class launcherActivityClass; static{ try { launcherActivityClass = Class.forName(LAUNCHER_ACTIVITY_FULL_CLASSNAME); } catch (ClassNotFoundException e){ throw new RuntimeException(e); } } public Testowanko()throws ClassNotFoundException{ super(TARGET_PACKAGE_ID,launcherActivityClass); } private Solo solo; @Override protected void setUp() throws Exception { solo = new Solo(getInstrumentation(),getActivity()); } //metoda testowa public void testDisplayBlackBox() { //Wpisania drugiej liczby "22" w pole tekstowe o ID 00 solo.enterText(00, "11"); //Wpisania drugiej liczby "22" w pole tekstowe o ID 01 solo.enterText(01, "22"); //Kliknięcie przycisku o nazwie "Multiply" solo.clickOnButton("Multiply"); //Weryfikacja wyniku mnożenia - wyszukanie konkretnego tekstu w oknie aplikacji assertTrue(solo.searchText("242")); } @Override public void tearDown() throws Exception { solo.finishOpenedActivities(); } }
Po wpisaniu testu widzimy, że importów, czy później funkcji jest wyświetlana jako błąd - wynika to z tego że plik jar z Robotium nie został jeszcze do dany do "Build Path" projektu. Dlatego udajemy się do "Properties" naszego projektu z drzewka wybieramy "Java Build Path" i w zakładce "Libraries" dajemy "Add external JARs..." i wybieramy robotium-solo-3.6.jar, którego wcześniej zapisaliśmy w katalogu z Eclipsą i SDK. Przechodzimy do zakładki "Order & Export" i ptaszkujemy eksportowany JAR. Dajemy OK.
Ostatnim krokiem jest przejście do AndroidManifest.xml i przekierowanie naszego testu na konkretną aplikację. W tym celu musimy zmienić parametr targetPackage na nazwę naszej aplikacji testowanej - w moim teście będzie to "com.calculator".
<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.testcalculator" android:versionCode="1" android:versionName="1.0" > <uses-sdk android:minSdkVersion="10" /> <instrumentation android:name="android.test.InstrumentationTestRunner" android:targetPackage="com.calculator" /> <application android:icon="@drawable/ic_launcher" android:label="@string/app_name" > <uses-library android:name="android.test.runner" /> </application> </manifest>
Po tym zapisujemy nasz projekt, aby móc bezproblemowo uruchomić test (prawo-klik na projekcie "Run As" -> "Android JUnit Test"). Wyniki pojawiają się w dolnej części głównego okna Eclipse w zakładce JUnit.
I tylko czekać na wyniki :)
Mam nadzieję, że kogoś zainteresowałem tym tematem :)