behat Handledning
Komma igång med behat

Anmärkningar

Funktionell testning som användarberättelser

Funktionella tester beskrivs bäst som tester för dina användarhistorier. Om du har behandlat användarhistorier innan de normalt följer följande mönster:

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

För följande exempel använder vi den här användarhistorien som exempel:

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

De två mest populära testramarna för funktionella tester i PHP är Behat och PHPSpec .

Börjar med Behat

Behat tillhandahåller Gherkin Syntax som är ett mänskligt läsbart format. Det gör att du enkelt kan beskriva dina användarhistorier.

För att börja med Behat bör du installera det med Composer och sedan initialisera dina testfiler:

$ 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

Som standard placerar du dina testfiler i features/ mappen och har tillägget .feature .

Varje testfil ska definiera en särskild funktion i applikationen. En funktion delas upp i ett antal scenarier och innehåller en serie steg som måste utföras framgångsrikt för att scenariot ska passera. Varje scenario måste passera för att en funktion ska kunna passera.

# 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

För att köra dina test utför du Behat-binären direkt. Vi kan valfritt specificera vilken funktionsfil som ska köras (annars körs alla tester). Den här funktionsfilen kommer att misslyckas med odefinierade stegfel (eftersom vi inte har definierat vad dessa steg betyder):

$ ./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();
    }

Varje steg i ett scenario kör ett kodstycke från en PHP-fil för kontext (olika funktionstester kan ladda olika sammanhang). Vi kan kopiera exemplen som Behat föreslår eller skapa våra egna. Steget matchas med en vanlig uttryckskontroll. Så om vi implementerar

<?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()
        );
    }
}

Du kommer att märka att du använder PHPUnit_Framework_Assert . Det som inte har sitt eget påståssystem så att du kan använda det du vill ha.

Genom att köra testerna kommer verklig kod att utföras och vi kan testa om allt går:

$ ./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)

Utöka Behat med Mink

Mink tillhandahåller ett gränssnitt för webbdrivrutiner (som Goutte och Selenium) samt en MinkContext som, när den utökas, ger ytterligare webbspråk för våra steg.

Så här installerar du Mink (och standarddrivrutinen för Goutte):

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

Förläng sedan ditt sammanhang med MinkContext :

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

class FeatureContext extends MinkContext … {
    …
}

Du kan se hela listan över syntax som finns i din Behat-installation med följande kommando:

$ ./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>(?:[^"]|\\")*)"$/

Du måste sedan konfigurera Mink för att ange var webbplatsen du vill testa finns och vilka webbdrivrutiner som ska användas (Goutte som standard):

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

Här är ett exempel på ett scenario som bara använder stegen Mink:

# ./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"

Du kan nu testa detta genom att köra funktionen via Behat:

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

Du kan skapa dina egna steg med MinkContext för vanliga steg (till exempel att logga in är en mycket vanlig åtgärd):

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"

Du måste utöka din kontextfil med MinkContext att få åtkomst till MinkContext :

<?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 tillhandahåller också CSS-väljare i de flesta av sina förutsatta samtal som gör att du kan identifiera element på sidan med konstruktioner som detta:

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()]"

Testa JavaScript med Mink och Selenium

Om vi vill testa JavaScript på en webbplats måste vi använda något som är lite kraftfullare än Goutte (som bara är CURL via Guzzle). Det finns ett par alternativ som ZombieJS , Selenium och Sahi . För det här exemplet använder jag Selenium.

Först måste du installera drivrutinerna för Mink:

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

Och du måste också ladda ner Selenium fristående serverburkfil och starta den:

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

Vi måste också berätta för Behat att när vi använder @javascript taggen för att använda Selenium-drivrutinen och tillhandahålla Selenium-fristående serverns placering.

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

Sedan behöver du bara lägga till en @javascript (eller @selenium2 ) -tagg till början av funktionen eller scenariot för varje test du vill köra med webbläsaremulering.

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

Testet kan sedan köras via Behat (som alla andra test). Den ena skillnaden är att när testet körs borde det spawn ett webbläsarfönster på datorn som kör Selenium fristående server som sedan utför de beskrivna testerna.

Ställa in testdata

Med funktionell testning ändras data ofta. Detta kan orsaka att efterföljande körningar av testsviten misslyckas (eftersom data kan ha ändrats från det ursprungliga tillståndet de var i).

Om du har konfigurerat din datakälla med hjälp av en ORM eller ramverk som stöder migrering eller sådd (som Doctrine , Propel , Laravel ), kan du använda den här för att skapa en ny testdatabas komplett med fixturdata på varje testkörning.

Om du för närvarande inte använder någon av dessa (eller motsvarande) kan du använda verktyg som Phinx för att snabbt ställa in en ny testdatabas eller förbereda en befintlig databas för varje testkörning (rensa upp testposter, återställa data till det ursprungliga läget ).

# 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

Lägg till dina databaser med ./phinx.xml .

$ php vendor/bin/phinx create InitialMigration

Du kan ange hur dina databastabeller skapas och fylls med den syntax som finns i dokumentationen .

Sedan kör du ett skript så här varje gång du kör dina test:

#!/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

Nu bör dina funktionella tester inte misslyckas på grund av dataförändringar.

Fånga e-postmeddelanden

Funktionell testning kan också innehålla testprocesser som lämnar din miljö, till exempel externa API-samtal och e-postmeddelanden.

Föreställ dig att du testar registreringsprocessen för din webbplats. Det sista steget i denna process innebär att skicka ett e-postmeddelande med en aktiveringslänk. Tills du har besökt denna länk är kontot inte helt registrerat. Du vill testa båda:

1. Att e-postmeddelandet kommer att skickas korrekt (formatering, utbyte av platshållare, etc) och,
2. Att aktiveringslänken fungerar

Nu kan du testa e-postmeddelandet men använda en IMAP- eller POP-klient för att hämta det skickade e-postmeddelandet från brevlådan, men det här innebär att du också testar din Internet-anslutning, fjärr-e-postservern och eventuella problem som kan uppstå vid leverans (spammetektering till exempel).

En enklare lösning är att använda en lokal tjänst som fångar utgående SMTP-anslutningar och dumpar den skickade e-posten till disken.

Ett par exempel är:

smtp-sink - Ett verktygsprogram som levereras med 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

Glöm inte att döda smtp-sink och starta om postfix-tjänsten efteråt:

# Restart postfix
sudo service postfix start

FakeSMTP - En Java-baserad klient som fångar utgående e-post

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

Alternativt kan du använda en fjärrtjänst som tillhandahåller den här tjänsten som e- post, men sedan är din testning beroende av Internet-åtkomst.

Installation eller installation

Behat / Mink

Installera med kompositör (för andra metoder kontrollera) behat.org Om du använder Linux, var noga med att installera php-curl (normal curlinstallation fungerar inte)

Linux

sudo apt-get install php5-curl

Om du använder Windows , se till att du har PHP, Curl och Git installerat. Du hittar dem under följande länkar:

• 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

Din kompositör.json skulle innehålla följande:

behat - kompositör.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/"
  }
}

(när du sparar composer.json-filen i Windows måste du välja "Alla filer" som filtyp och "ANSI" -kodning)

Utför sedan följande kommandon:

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

Efter det här tillägget Behat, Mink och Behat-Mink har installerats för att köra behat

köra behat

$ bin/behat

För att aktivera Behat-Mink Extension använd: behat.yml skapa en fil "behat.yml" med följande innehåll

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"

Den här filen kommer att finnas i samma katalog som innehåller bin-katalog och länk till behat.
Observera också att i yml-filen inte använder flikar för indragning. använd utrymmen. För att få en lista med kommandon tillgängliga i behat-mink, använd

$ bin/behat -di

Gör behat till en del av ditt system

Linux

Gå till din hemdirektör och gör följande:

$ sudo vi .bashrc

Och lägg till dessa rader i slutet av katalogen

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

Starta om konsolen eller skriv "source .bashrc"

Windows

Gå över systeminställningarna och lägg till Path of behat / bin till miljövariablerna

Andra drivrutiner Över drivrutiner som Selenium, phantomjs, goutte, etc. måste också installeras.