behat Samouczek
Pierwsze kroki z behat

Uwagi

Testy funkcjonalne jako historie użytkowników

Testy funkcjonalne najlepiej opisać jako testy historii użytkowników. Jeśli masz do czynienia z historiami użytkowników, zanim będą one normalnie następowały:

As a [role], I want to [desire], so that [benefit/desired outcome]

W poniższych przykładach wykorzystamy tę historię użytkownika jako przykład:

As a Dungeon Master, I want to ensure harmony and mutual trust, so that
the party can work together as a team

Dwie najpopularniejsze struktury testowania testów funkcjonalnych w PHP to Behat i PHPSpec .

Począwszy od Behat

Behat zapewnia składnię korniszonu, która jest formatem czytelnym dla człowieka. Pozwala łatwo opisać historie użytkowników.

Aby rozpocząć od Behat, należy zainstalować go za pomocą Composer, a następnie zainicjować pliki testowe:

$ composer require --dev behat/behat="^3.0.5"

$ ./vendor/bin/behat --init

+d features # place your *.feature files here
+d features/bootstrap # place your context classes here
+f features/bootstrap/FeatureContext.php # place your definitions, transformations and hooks here

Domyślnie umieszczasz swoje pliki testowe w folderze features/ i masz rozszerzenie .feature .

Każdy plik testowy powinien określać określoną funkcję aplikacji. Funkcja jest podzielona na kilka scenariuszy i zawiera serię kroków, które należy wykonać pomyślnie, aby scenariusz mógł zostać zrealizowany. Każdy scenariusz musi przejść, aby funkcja mogła przejść.

# features/PartyHarmony.feature
Feature: Party Harmony
    As a Dungeon Master, I want to ensure harmony and mutual trust, so that
    the party can work together as a team

    Scenario: Teach members to respect each others property
        Given that the Wizard has 10 cookies
        And the Bard eats 1 cookie
        Then the Bard is mysteriously on fire

Aby uruchomić testy, uruchom bezpośrednio plik binarny Behat. Opcjonalnie możemy określić, który plik funkcji ma zostać uruchomiony (w przeciwnym razie uruchamiane są wszystkie testy). Ten plik funkcji zawiedzie z błędami niezdefiniowanych kroków (ponieważ nie zdefiniowaliśmy, co oznaczają te kroki):

$ ./vendor/bin/behat features/PartyHarmony.feature
Feature: Party Harmony
    As a Dungeon Master, I want to ensure harmony and mutual trust, so that
    the party can work together as a team

  Scenario: Teach members to respect each others property # features/PartyHarmony.feature:6
    Given that the Wizard has 10 cookies
    And the Bard eats 1 cookie
    Then the Bard is mysteriously on fire

1 scenario (1 undefined)
3 steps (3 undefined)
0m0.01s (10.49Mb)

--- FeatureContext has missing steps. Define them with these snippets:

    /**
     * @Given that the Wizard has :arg1 cookies
     */
    public function thatTheWizardHasCookies($arg1)
    {
        throw new PendingException();
    }

    /**
     * @Given the Bard eats :arg1 cookie
     */
    public function theBardEatsCookie($arg1)
    {
        throw new PendingException();
    }

    /**
     * @Then the Bard is mysteriously on fire
     */
    public function theBardIsMysteriouslyOnFire()
    {
        throw new PendingException();
    }

Każdy krok w scenariuszu uruchamia fragment kodu z kontekstowego pliku PHP (różne testy funkcji mogą ładować różne konteksty). Możemy skopiować przykłady sugerowane przez Behat lub stworzyć własne. Krok jest dopasowywany do kontroli wyrażenia regularnego. Więc jeśli wdrożymy

<?php
# 
class FeatureContext {
    /**
     * @Given that the wizard has :num cookies
     */
    public function wizardHasCookies($num) {
        // $this->wizard is a pre-existing condition.... like syphilis
        $this->wizard->setNumberOfCookies($num);
    }

    /**
     * @Given the Bard eats :num cookie
     */
    public function theBardEatsCookie($num)
    {
        $this->bard->consumeCookies($num);
    }

    /**
     * @Then the Bard is mysteriously on fire
     */
    public function theBardIsMysteriouslyOnFire() {
        PHPUnit_Framework_Assert::assertTrue(
            $this->bard->isBardOnFire()
        );
    }
}

Zauważysz użycie PHPUnit_Framework_Assert . Behat nie ma własnego systemu asercji, więc możesz użyć dowolnego z nich.

Teraz uruchomione testy wykonają rzeczywisty kod i możemy przetestować, czy wszystko przejdzie:

$ ./vendor/bin/behat features/PartyHarmony.feature
Feature: Party Harmony
    As a Dungeon Master, I want to ensure harmony and mutual trust, so that
    the party can work together as a team

  Scenario: Teach members to respect each others property # features/PartyHarmony.feature:6
    Given that the Wizard has 10 cookies                  # FeatureContext::thatTheWizardHasCookies()
    And the Bard eats 1 cookie                            # FeatureContext::theBardEatsCookie()
    Then the Bard is mysteriously on fire                 # FeatureContext::theBardIsMysteriouslyOnFire()

1 scenario (1 passed)
3 steps (3 passed)
0m0.01s (10.59Mb)

Rozszerzanie Behata o Mink

Mink zapewnia interfejs dla sterowników sieciowych (takich jak Goutte i Selenium), a także MinkContext który po rozszerzeniu zapewnia dodatkowy język WWW dla naszych kroków.

Aby zainstalować Mink (i domyślny sterownik Goutte):

$ composer require --dev behat/mink-extension="^2.0"
$ composer require --dev behat/mink-goutte-driver="^1.0"

Następnie rozszerz swój kontekst za pomocą MinkContext :

<?php
use Behat\MinkExtension\Context\MinkContext;

class FeatureContext extends MinkContext … {
    …
}

Możesz zobaczyć całą listę składni dostępną w instalacji Behat za pomocą następującego polecenia:

$ ./vendor/bin/behat -dl

Given /^(?:|I )am on "(?P<page>[^"]+)"$/
 When /^(?:|I )reload the page$/
 When /^(?:|I )move backward one page$/
 When /^(?:|I )move forward one page$/
 When /^(?:|I )press "(?P<button>(?:[^"]|\\")*)"$/
 When /^(?:|I )follow "(?P<link>(?:[^"]|\\")*)"$/
 When /^(?:|I )fill in "(?P<field>(?:[^"]|\\")*)" with "(?P<value>(?:[^"]|\\")*)"$/

Następnie musisz skonfigurować Mink, aby wskazywał, gdzie znajduje się strona internetowa, którą chcesz przetestować, i których sterowników sieci Web używać (domyślnie Goutte):

# ./behat.yml
default:
    extensions:
        Behat\MinkExtension:
            base_url: "[your website URL]"
            sessions:
                default:
                    goutte: ~

Oto przykład scenariusza wykorzystującego tylko kroki dostarczone przez Minka:

# ./features/Authentication.feature
Feature: Authentication
    As a security conscious developer I wish to ensure that only valid users can access our website.

    Scenario: Login in successfully to my website
        When I am on "/login"
        And I fill in "email" with "[email protected]"
        And I fill in "password" with "my_password"
        And I press "Login"
        Then I should see "Successfully logged in"

    Scenario: Attempt to login with invalid credentials
        When I am on "/login"
        And I fill in "email" with "[email protected]"
        And I fill in "password" with "not_my_password"
        And I press "Login"
        Then I should see "Login failed"

Możesz to teraz przetestować, uruchamiając tę funkcję przez Behat:

./vendor/bin/behat features/Authentication.feature

Możesz tworzyć własne kroki za pomocą MinkContext dla typowych kroków (na przykład logowanie jest bardzo częstą operacją):

Feature: Authentication
    As a security conscious developer I wish to ensure that only valid users can access our website.

    Scenario: Login in successfully to my website
        Given I login as "[email protected]" with password "my_password"
        Then I should see "Successfully logged in"

    Scenario: Attempt to login with invalid credentials
        Given I login as "[email protected]" with password "not_my_password"
        Then I should see "Login failed"

Musisz rozszerzyć plik kontekstowy o MinkContext aby uzyskać dostęp do sterowników sieciowych i interakcji ze stronami:

<?php
use Behat\MinkExtension\Context\MinkContext;

class FeatureContext extends MinkContext {
    /**
      * @Given I login as :username with password :password
      */
    public function iLoginAsWithPassword($username, $password) {
        $this->visit("/login");
        $this->fillField("email", $username);
        $this->fillField("password", $password);
        $this->pressButton("Login");
    }
}

Mink zapewnia również selektory CSS w większości wcześniej dostarczonych wywołań, które pozwalają identyfikować elementy na stronie za pomocą takich konstrukcji:

When I click on "div[id^='some-name']"
And I click on ".some-class:first"
And I click on "//html/body/table/thead/tr/th[first()]"

Testowanie JavaScript z Mink i Selenium

Jeśli chcemy przetestować JavaScript na stronie, musimy użyć czegoś nieco potężniejszego niż Goutte (który jest po prostu CURL przez Guzzle). Istnieje kilka opcji, takich jak ZombieJS , Selenium i Sahi . W tym przykładzie użyję Selenium.

Najpierw musisz zainstalować sterowniki dla Mink:

$ composer require --dev behat/mink-selenium2-driver="^1.2"

Musisz także pobrać samodzielny plik jar serwera Selenium i uruchomić go:

$ java -jar selenium-server-standalone-2.*.jar

Musimy też powiedzieć Behatowi, że kiedy używamy tagu @javascript aby użyć sterownika Selenium i podać lokalizację autonomicznego serwera Selenium.

# ./behat.yml
default:
    # …
    extensions:
        Behat\MinkExtension:
        base_url: "[your website URL]"
        sessions:
            # …
            javascript:
                selenium2:
                    browser: "firefox"
                    wd_host: http://localhost:4444/wd/hub

Następnie do każdego testu, który chcesz uruchomić przy użyciu emulacji przeglądarki, wystarczy dodać @javascript (lub @selenium2 ) na początku funkcji lub scenariusza.

# ./features/TestSomeJavascriptThing.feature
@javascript # or we could use @selenium2
Feature: This test will be run with browser emulation

Test można następnie uruchomić za pomocą Behat (jak każdy inny test). Jedną różnicą jest to, że po uruchomieniu testu powinno się pojawić okno przeglądarki na komputerze z samodzielnym serwerem Selenium, który następnie wykona opisane testy.

Konfigurowanie danych testowych

Dzięki testom funkcjonalnym dane są często modyfikowane. Może to spowodować niepowodzenie kolejnych uruchomień zestawu testów (ponieważ dane mogły ulec zmianie z pierwotnego stanu, w którym były).

Jeśli masz skonfigurowane źródło danych za pomocą ORM lub frameworka, który obsługuje migrację lub seedowanie (takie jak Doctrine , Propel , Laravel ), możesz użyć tego do utworzenia nowej testowej bazy danych wraz z danymi Fixture dla każdego uruchomienia testowego.

Jeśli obecnie nie używasz żadnego z nich (lub odpowiednika), możesz użyć narzędzi takich jak Phinx, aby szybko skonfigurować nową testową bazę danych lub przygotować istniejącą bazę danych dla każdego uruchomienia testowego (wyczyść wpisy testowe, przywróć dane do stanu pierwotnego ).

# Install Phinx in your project
$ php composer.phar require robmorgan/phinx

$ php vendor/bin/phinx init
Phinx by Rob Morgan - https://phinx.org. version x.x.x
Created ./phinx.xml

Dodaj poświadczenia bazy danych do ./phinx.xml .

$ php vendor/bin/phinx create InitialMigration

Możesz określić sposób tworzenia i wypełniania tabel bazy danych za pomocą składni podanej w dokumentacji .

Następnie za każdym razem, gdy przeprowadzasz testy, uruchamiasz skrypt w następujący sposób:

#!/usr/bin/env bash

# Define the test database you'll use
DATABASE="test-database"

# Clean up and re-create this database and its contents
mysql -e "DROP DATABASE IF EXISTS $DATABASE"
mysql -e "CREATE DATABASE $DATABASE"
vendor/bin/phinx migrate

# Start your application using the test database (passed as an environment variable)
# You can access the value with $_ENV['database']
database=$DATABASE php -d variables_order=EGPCS -S localhost:8080

# Run your functional tests
vendor/bin/behat

Teraz testy funkcjonalne nie powinny zakończyć się niepowodzeniem z powodu zmian danych.

Przechwytywanie wiadomości e-mail

Testy funkcjonalne mogą również obejmować procesy testowe opuszczające środowisko, takie jak zewnętrzne wywołania interfejsu API i wiadomości e-mail.

Na przykład wyobraź sobie, że funkcjonalnie testujesz proces rejestracji witryny. Ostatnim krokiem tego procesu jest wysłanie wiadomości e-mail z linkiem aktywacyjnym. Do czasu odwiedzenia tego linku konto nie jest całkowicie zarejestrowane. Chcesz przetestować oba:

1. Czy wiadomość e-mail zostanie wysłana poprawnie (formatowanie, zastąpienie symboli zastępczych itp.) Oraz,
2. Czy link aktywacyjny działa

Teraz możesz przetestować wysyłanie wiadomości e-mail, ale przy użyciu klienta IMAP lub POP w celu pobrania wysłanej wiadomości e-mail ze skrzynki pocztowej, ale oznacza to również, że testujesz również połączenie internetowe, zdalny serwer e-mail i wszelkie problemy, które mogą pojawić się w trakcie dostarczania (wykrywanie spamu na przykład).

Prostszym rozwiązaniem jest użycie usługi lokalnej, która przechwytuje wychodzące połączenia SMTP i zrzuca wysłaną wiadomość e-mail na dysk.

Kilka przykładów to:

smtp-sink - Program narzędziowy dostarczany w pakiecie z Postfix.

# Stop the currently running service
sudo service postfix stop

# Dumps outgoing emails to file as "day.hour.minute.second"
smtp-sink -d "%d.%H.%M.%S" localhost:2500 1000

# Now send mails to your local SMTP server as normal and they will be
# dumped to raw text file for you to open and read

# Run your functional tests
vendor/bin/behat

Nie zapomnij zabić smtp-sink i zrestartować usługę Postfix później:

# Restart postfix
sudo service postfix start

FakeSMTP - klient Java, który przechwytuje pocztę wychodzącą

# -b = Start without GUI interface
# -o = Which directory to dump your emails to
$ java -jar fakeSMTP.jar -b -o output_directory_name

Alternatywnie możesz użyć zdalnej usługi, która zapewnia tę usługę, takiej jak mailtrap, ale wtedy twoje testy zależą od dostępu do Internetu.

Instalacja lub konfiguracja

Behat / Mink

Zainstaluj za pomocą kompozytora (sprawdź inne metody) behat.org Jeśli używasz Linuksa, upewnij się, że masz zainstalowany php-curl (normalna instalacja curl nie zadziała)

Linux

sudo apt-get install php5-curl

Jeśli używasz systemu Windows , upewnij się, że masz zainstalowane PHP, Curl i Git. Można je znaleźć pod następującymi linkami:

• PHP (Xampp): https://www.apachefriends.org/de/index.html
• Curl: http://curl.haxx.se/latest.cgi?curl=win64-nossl
• Git: http://git-scm.com/download/win

Plik composer.json zawierałby następujące elementy:

behat - composer.json

{
  "require": {
    "behat/behat": "dev-master",
    "behat/mink": "dev-master",
    "behat/mink-extension": "dev-master",
    "behat/mink-selenium2-driver": "dev-master",
    "phpunit/php-code-coverage": "dev-master",
    "phpunit/phpunit-mock-objects": "dev-master",
    "phpunit/phpunit": "dev-master"
  },
  "minimum-stability": "dev",
  "config": {
    "bin-dir": "bin/"
  }
}

(podczas zapisywania pliku composer.json w systemie Windows należy wybrać opcję „Wszystkie pliki” jako typ pliku i kodowanie „ANSI”)

Następnie wykonaj następujące polecenia:

$ curl http://getcomposer.org/installer | php
$ php composer.phar install

Po tym Behat, Mink i rozszerzenie Behat-Mink są instalowane, aby wykonać behat

wykonać behat

$ bin/behat

Aby aktywować rozszerzenie Behat-Mink użyj: behat.yml utwórz plik „behat.yml” o następującej treści

behat.yml

default:
  suites:
    default:
      paths:
        features: %paths.base%/features/
        bootstrap: %paths.base%/features/bootstrap/
      contexts: 
        - FeatureContext
  extensions:
    Behat\MinkExtension:
      base_url: 'http://www.startTestUrl.de'
      selenium2:
        browser: firefox
        wd_host: "http://localhost:4444/wd/hub"

Ten plik będzie znajdować się w tym samym katalogu, który zawiera katalog bin i link do behat.
Zauważ też, że w pliku yml nie używaj tabulatorów do wcięcia. użyj spacji. Aby uzyskać listę poleceń dostępnych w behat-mink, użyj

$ bin/behat -di

Niech behat będzie częścią twojego systemu

Linux

Przejdź do swojego Homedirectory i wykonaj następujące czynności:

$ sudo vi .bashrc

I dodaj te linie na końcu katalogu

export BEHAT_HOME=/home/*user*/path/to/behat
export PATH=$BEHAT_HOME/bin:$PATH

Uruchom ponownie konsolę lub wpisz „source .bashrc”

Windows

Przejrzyj Ustawienia systemowe i dodaj Ścieżkę behat / bin do zmiennych środowiskowych

Inne sterowniki Oprócz sterowników, takich jak Selenium, phantomjs, dna moczanowa itp., Należy również zainstalować.