Automatyzacja testów aplikacji desktopowej w systemie Windows przy użyciu Selenium w języku Python

Zapewne wszyscy testerzy automatyzujący wiedzą, czym jest Selenium – jeśli nie z doświadczenia, to na pewno ze słyszenia. Nic w tym dziwnego, gdyż Selenium, a właściwie Selenium WebDriver, to bez wątpienia najbardziej znana biblioteka do automatyzacji testów aplikacji webowych, wykorzystywana z większością współczesnych języków programowania. No właśnie – aplikacji webowych.

Ale czy można za pomocą tego narzędzie pisać i wykonywać testy na aplikacjach desktopowych w systemach Windows? Oczywiście! Nic prostszego. Jak w takim razie zacząć? Odpowiedź znajdziecie w niniejszym artykule.

Konfiguracja środowiska

Pierwszym krokiem jest skonfigurowanie środowiska, na którym uruchamiane będą testy. Z racji tego, że artykuł dotyczy testowania w języku Python, zakładam, że został on już zainstalowany na komputerze.

Na wstępie należy ściągnąć i zainstalować Windows Application Driver, czyli oficjalny serwis wspierający testowanie UI aplikacji w systemie Windows. Można to zrobić z oficjalnego repozytorium projektu, wybierając najnowszą stabilną wersję.

Powinniśmy pamiętać o tym, aby włączyć tryb deweloperski w systemie Windows.

Następnie, konieczne jest zainstalowanie zewnętrznej biblioteki Appium-Python-Client, dodającej protokół WebDriver oraz podstawowe komendy Appium.

Kolejny krok stanowi instalacja Selenium. Ważnym jest, aby zainstalować odpowiednie wersje obu tych bibliotek. WinAppDriver komunikuje się z selenium/appium-python-client za pomocą protokołu JSON Wire, podczas gdy najnowsze wersje tych bibliotek używają do komunikacji protokołu W3C. Biblioteki te można zainstalować za pomocą domyślnego systemu zarządzania pakietami dla środowiska języka Python:

pip install selenium==3.141.0
	pip install appium-python-client==1.3.0

Tak przygotowane środowisko gotowe jest do rozpoczęcia pisania kodu.

Przygotowanie uchwytu

W przypadku testowania aplikacji webowych naszym uchwytem jest zazwyczaj sama przeglądarka internetowa. Do tego celu używamy m.in.: ChromeDrivera czy FirefoxDrivera.  To właśnie na takim uchwycie tworzymy swoją zmienną, na której następnie wykonywane są wszystkie kroki testu, np.:

from selenium import webdriver
from webdriver_manager.chrome import ChromeDriverManager

driver = webdriver.Chrome(ChromeDriverManager().install())
driver.get('http://www.google.com')

W naszym przypadku uchwytem (handlerem) nie będzie przeglądarka, a sama aplikacja, która podlega testowaniu. Weźmy na tapet najprostszy możliwy przykład – windowsowy kalkulator. W tym celu należy napisać metodę, która otworzy i/lub zlokalizuje nasz handler. Kod, z wykorzystaniem biblioteki appium, w najprostszej postaci może wyglądać następująco:

from appium import webdriver

class Handlers:
    def calculator(self):
        desired_caps = {}
        desired_caps['app'] = 
"Microsoft.WindowsCalculator_8wekyb3d8bbwe!App"
        self.driver = webdriver.Remote(
            command_executor="http://127.0.0.1:4723",
            desired_capabilities=desired_caps)

Desired Capabilities to słownik z kluczami i wartościami w formacie JSON, wysyłany przez Appium do uruchomionego serwera Windows Application Driver, gdy rozpoczynana jest nowa sesja. Przekazuje on ważne informacje – przede wszystkim dotyczące aplikacji, która ma zostać otwarta. Parametr path służy do podania dokładnej ścieżki do aplikacji, która ma zostać przechwycona. Adres http://127.0.0.1:4723 to adres i numer portu, na którym nasłuchuje uruchomiony Windows Application Driver.

Ważnym jest, aby WinAppDriver był uruchomiony podczas wykonywania testu. Samo włączenie go również może zostać zautomatyzowane, np. poprzez wykorzystanie biblioteki os:

class WinAppDriver:
    def __init__(self):
        self.winAppDriver = os.startfile("C:\\Program Files (x86)\\Windows Application Driver\\WinAppDriver.exe")

Podobnie można postąpić w przypadku zakończenia testów, gdy chcielibyśmy automatycznie zamknąć naszego WinAppDrivera. Wystarczy w klasie WinAppDriver dodać odpowiednią metodę zamykającą, np.:

def close(self):
    os.system("TASKKILL /F /IM WinAppDriver.exe")

Lokalizowanie elementów

Lokalizowanie elementów przy testowaniu aplikacji webowej jest (relatywnie) bardzo proste, tj. nie wymaga od nas żadnych zewnętrznych narzędzi. Wystarczy sama przeglądarka i tryb inspekcji.

W naszym przypadku musimy skorzystać ze specjalnego programu, który umożliwi nam wgląd w całą zawartość aplikacji. Takim programem może być np. Accessibility Insights, stworzony przez Microsoft. Po jego uruchomieniu możemy najechać kursorem na interesujący nas element bezpośrednio w aplikacji, by poznać jego „wnętrze”. Nas interesować będzie zazwyczaj jeden z trzech możliwych lokalizatorów:

• Name,
• ClassName,
• AutomationId.

Załóżmy, że chcemy przetestować windowsowy kalkulator. Test będzie prosty: dodajemy do siebie dwie liczby i sprawdzamy, czy wynik będzie poprawny. W tym celu musimy znaleźć przyciski z klawiatury numerycznej oraz przyciski operacji, które zamierzamy kliknąć, okno wyniku i wyświetlany w nim tekst. Wszystkie nazwy możemy zapisać do odpowiedniego pliku, by móc korzystać z nich w przyszłości:

class CalculatorLocators:
    #MAIN
    RESULTS_ID = 'CalculatorResults'
    RESULT_TEXT = 'Wyświetlana wartość to '

    #OPERATORS
    PLUS_BUTTON_ID = 'plusButton'
    MINUS_BUTTON_ID = 'minusButton'
    EQUAL_BUTTON_ID = 'equalButton'
    DIVIDE_BUTTON_ID = 'divideButton'
    MULTIPLY_BUTTON_ID = 'multiplyButton'

    # NUMBERS
    ZERO_BUTTON_ID = 'num0Button'
    ONE_BUTTON_ID = 'num1Button'
    TWO_BUTTON_ID = 'num2Button'
    THREE_BUTTON_ID = 'num3Button'
    FOUR_BUTTON_ID = 'num4Button'
    FIVE_BUTTON_ID = 'num5Button'
    SIX_BUTTON_ID = 'num6Button'
    SEVEN_BUTTON_ID = 'num7Button'
    EIGHT_BUTTON_ID = 'num8Button'
    NINE_BUTTON_ID = 'num9Button'

Pierwszy test

Wszystko jest już gotowe, więc możemy przystąpić do napisania pierwszego testu, polegającego na dodaniu do siebie dwóch cyfr. Załóżmy, że chcemy dodać do siebie dwie liczby 5 i sprawdzić, czy wynik będzie poprawny, tj. otrzymamy wyświetlaną liczbę 10.

W tym celu możemy już użyć zwykłej składni Selenium, lokalizującej i klikającej wybrany element, kończąc wszystko asercją. Kod poszczególnych kroków w najprostszej postaci może wyglądać następująco:

WYNIK = 5 + 5

self.driver.find_element_by_accessibility_id(CalculatorLocators.FIVE_BUTTON_ID).click()
self.driver.find_element_by_accessibility_id(CalculatorLocators.PLUS_BUTTON_ID).click()
self.driver.find_element_by_accessibility_id(CalculatorLocators.FIVE_BUTTON_ID).click()
self.driver.find_element_by_accessibility_id(CalculatorLocators.EQUAL_BUTTON_ID).click()

result = self.driver.find_element_by_accessibility_id(CalculatorLocators.RESULTS_ID)
self.assertEqual(result.text, CalculatorLocators.RESULT_TEXT + str(WYNIK))

Musimy również pamiętać o samym zaimportowaniu potrzebnych rzeczy oraz o włączeniu Windows Application Drivera i zainicjowaniu uchwytu, tj. drivera. Cały kod prezentuje się zatem następująco:

mport unittest
from helpers.win_app_driver import WinAppDriver
from helpers.handlers import Handlers
from locators.calculator_locators import CalculatorLocators

class Calculator(unittest.TestCase):

    def setUp(self):
        WinAppDriver()
        Handlers.calculator(self)

    def test_dodawanie(self):
        #TEST
        WYNIK = 5 + 5

        self.driver.find_element_by_accessibility_id(CalculatorLocators.FIVE_BUTTON_ID).click()
        self.driver.find_element_by_accessibility_id(CalculatorLocators.PLUS_BUTTON_ID).click()
        self.driver.find_element_by_accessibility_id(CalculatorLocators.FIVE_BUTTON_ID).click()
        self.driver.find_element_by_accessibility_id(CalculatorLocators.EQUAL_BUTTON_ID).click()

        result = self.driver.find_element_by_accessibility_id(CalculatorLocators.RESULTS_ID)
        self.assertEqual(result.text, CalculatorLocators.RESULT_TEXT + str(WYNIK))

    def tearDown(self):
        WinAppDriver.close(self)

if __name__ == "__main__":
    unittest.main()

Idąc tym tropem, możemy dalej wykonywać kolejne testy dla pozostałych operatorów, tj. odejmowanie od siebie liczb, ich mnożenie oraz dzielenie.

Podsumowanie

Selenium WebDriver może być używany do testowania aplikacji desktopowych na systemach Windows. Jeżeli odpowiednio skonfigurujemy swoje środowisko, tj. zainstalujemy odpowiednie biblioteki i programy, jak również przyzwyczaimy się, że naszym driverem nie jest przeglądarka, a sama aplikacja podlegająca testowaniu, istnieje prosta możliwość użycia składni Selenium do przeprowadzania wielu operacji – nie tylko tych prostych jak poszczególne kliknięcia, ale również bardziej skomplikowanych.

Trzeba jednak pamiętać o pewnych ograniczeniach tego rozwiązania. W przypadku używania Selenium w aplikacji webowej możemy w testach posiłkować się np. obsługą JavaScript, co przydatne może być do m.in.:

• przesuwania elementów,
• scrollowania,
• zaznaczania,
• odznaczania elementów itp.

W przypadku Selenium w aplikacji desktopowej należy rozwiązywać problemy inaczej, w dużej mierze polegając na samym języku programowania i/lub innych, zewnętrznych bibliotekach. Ale o tym może przy innej okazji.

***

Jeżeli interesuje Cię obszar automatyzacji, polecamy inne artykuły naszych ekspertów m.in.:

• CodeceptJS – Przyjazna automatyzacja testów akceptacyjnych dla www!
• Robot Framework – wprowadzenie do automatyzacji testów aplikacji webowej
• Automatyzacja testów Systemów Wbudowanych z wykorzystaniem Robot Frameworka – część 1
• Automatyzacja testów Systemów Wbudowanych z wykorzystaniem Robot Frameworka – część 2
• ALM – automatyzacja zadań administracyjnych w Dynamics 365 F&O. Wprowadzenie