behat Tutoriel => Démarrer avec behat

Remarques

Cette section fournit une vue d'ensemble de ce que c'est, et pourquoi un développeur peut vouloir l'utiliser.

Il devrait également mentionner tous les grands sujets dans Behat, et établir un lien avec les sujets connexes. La documentation de behat étant nouvelle, vous devrez peut-être créer des versions initiales de ces rubriques connexes.

Test fonctionnel comme user stories

Les tests fonctionnels sont mieux décrits comme des tests pour vos user stories. Si vous avez déjà traité des user stories avant de suivre le modèle suivant:

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

Pour les exemples suivants, nous utiliserons cette user story comme exemple:

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

Les deux frameworks de test les plus populaires pour les tests fonctionnels en PHP sont Behat et PHPSpec .

Commençant par Behat

Behat fournit la syntaxe Gherkin qui est un format lisible par l'homme. Il vous permet de décrire facilement vos user stories.

Pour commencer, vous devez l'installer avec Composer puis initialiser vos fichiers de test:

$ 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

Par défaut, vous placez vos fichiers de test dans le dossier features/ et avez l'extension .feature .

Chaque fichier de test doit définir une caractéristique particulière de l'application. Une fonctionnalité est décomposée en un ensemble de scénarios et contient une série d'étapes qui doivent être effectuées avec succès pour que le scénario réussisse. Chaque scénario doit passer pour qu'une fonctionnalité passe.

# 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

Pour exécuter vos tests, vous exécutez directement le binaire Behat. Nous pouvons éventuellement spécifier le fichier de fonction à exécuter (sinon tous les tests sont exécutés). Ce fichier de fonctionnalité échouera avec des erreurs d'étapes non définies (car nous n'avons pas défini ce que ces étapes signifient):

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

Chaque étape d'un scénario exécute un morceau de code à partir d'un fichier PHP contextuel (différents tests de fonctionnalités peuvent charger différents contextes). Nous pouvons copier les exemples proposés par Behat ou créer nos propres exemples. L'étape correspond à une vérification d'expression régulière. Donc, si nous mettons en œuvre

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

Vous remarquerez l'utilisation de PHPUnit_Framework_Assert . Behat n'a pas son propre système d'affirmation, vous pouvez donc utiliser celui que vous voulez.

L'exécution des tests va maintenant exécuter le code actuel et nous pouvons tester si tout passe:

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

Étendre Behat avec Mink

Mink fournit une interface pour les pilotes Web (comme Goutte et Selenium) ainsi qu’un MinkContext qui, une fois étendu, fournit un langage Web supplémentaire pour nos étapes.

Pour installer Mink (et le pilote Goutte par défaut):

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

Ensuite, MinkContext votre contexte avec MinkContext :

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

class FeatureContext extends MinkContext … {
    …
}

Vous pouvez voir la liste complète des syntaxes disponibles dans votre installation Behat avec la commande suivante:

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

Vous devez ensuite configurer Mink pour indiquer où se trouve le site Web que vous souhaitez tester et quels pilotes Web utiliser (Goutte par défaut):

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

Voici un exemple de scénario utilisant uniquement les étapes fournies par le 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"

Vous pouvez maintenant tester cela en exécutant la fonctionnalité via Behat:

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

Vous pouvez créer vos propres étapes en utilisant MinkContext pour les étapes courantes (par exemple, la connexion est une opération très courante):

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"

Vous devrez étendre votre fichier de contexte avec MinkContext pour accéder aux pilotes Web et aux interactions de page:

<?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 fournit également des sélecteurs CSS dans la plupart de ses appels pré-fournis, ce qui vous permet d'identifier des éléments sur la page en utilisant des constructions telles que:

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

Tester JavaScript avec Mink et Selenium

Si nous voulons tester JavaScript sur un site Web, nous devons utiliser quelque chose de plus puissant que Goutte (qui est juste cURL via Guzzle). Il existe plusieurs options telles que ZombieJS , Selenium et Sahi . Pour cet exemple, je vais utiliser Selenium.

Vous devez d'abord installer les pilotes pour Mink:

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

Et vous devrez également télécharger le fichier jar de serveur autonome Selenium et le démarrer:

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

Nous devrons également indiquer à Behat que lorsque nous utilisons la balise @javascript pour utiliser le pilote Selenium et fournir l'emplacement du serveur autonome Selenium.

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

Ensuite, pour chaque test que vous souhaitez exécuter à l'aide de l'émulation du navigateur, il vous suffit d'ajouter une @javascript (ou @selenium2 ) au début de la fonctionnalité ou du scénario.

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

Le test peut alors être exécuté via Behat (comme tout autre test). La seule différence est que, lors de l'exécution du test, une fenêtre de navigateur devrait apparaître sur l'ordinateur exécutant le serveur autonome Selenium, qui exécutera ensuite les tests décrits.

Configuration des données de test

Avec les tests fonctionnels, les données sont souvent modifiées. Cela peut entraîner l'échec des exécutions ultérieures de la suite de tests (car les données ont pu être modifiées par rapport à l'état d'origine).

Si vous avez configuré votre source de données à l'aide d'un ORM ou d'une structure prenant en charge la migration ou l'amorçage (comme Doctrine , Propel , Laravel ), vous pouvez créer une nouvelle base de données de test avec des données Fixture à chaque test.

Si vous n'utilisez pas l'un de ces outils (ou équivalent), vous pouvez utiliser des outils tels que Phinx pour configurer rapidement une nouvelle base de données de test ou préparer une base de données existante pour chaque test. ).

# 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

Ajoutez vos informations d'identification de base de données à ./phinx.xml .

$ php vendor/bin/phinx create InitialMigration

Vous pouvez spécifier comment vos tables de base de données sont créées et remplies à l'aide de la syntaxe fournie dans la documentation .

Ensuite, chaque fois que vous exécutez vos tests, vous exécutez un script comme celui-ci:

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

Désormais, vos tests fonctionnels ne doivent pas échouer en raison de modifications de données.

Capturer les emails

Les tests fonctionnels peuvent également inclure des processus de test qui quittent votre environnement, tels que des appels API externes et des e-mails.

À titre d'exemple, imaginez que vous testez de manière fonctionnelle le processus d'enregistrement de votre site Web. La dernière étape de ce processus consiste à envoyer un courrier électronique avec un lien d'activation. Tant que ce lien n'est pas visité, le compte n'est pas complètement enregistré. Vous souhaitez tester les deux:

Que l'e-mail sera envoyé correctement (formatage, remplacement d'espace réservé, etc.) et,
Que le lien d'activation fonctionne

Vous pouvez maintenant tester l'envoi de courrier électronique à l'aide d'un client IMAP ou POP pour récupérer le courrier électronique envoyé depuis la boîte aux lettres, mais vous testez également votre connexion Internet, le serveur de messagerie distant et tout problème de livraison par exemple).

Une solution plus simple consiste à utiliser un service local qui intercepte les connexions SMTP sortantes et vide le message envoyé sur le disque.

Quelques exemples sont:

smtp-sink - Un utilitaire fourni avec 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

N'oubliez pas de tuer smtp-sink et de redémarrer votre service postfix ensuite:

# Restart postfix
sudo service postfix start

FakeSMTP - Un client basé sur Java qui intercepte le courrier sortant

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

Vous pouvez également utiliser un service distant qui fournit ce service comme mailtrap, mais vos tests dépendent de l'accès à Internet.

Installation ou configuration

Behat / Mink

Installer en utilisant compositeur (pour vérifier les autres méthodes) behat.org Si vous utilisez linux, veuillez vous assurer que vous avez installé php-curl

Linux

sudo apt-get install php5-curl

Si vous utilisez Windows , assurez-vous que PHP, Curl et Git sont installés. Vous pouvez trouver ceux sous les liens suivants:

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

Votre composer.json contiendrait les éléments suivants:

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/"
  }
}

(lorsque vous enregistrez le fichier composer.json sous Windows, vous devez choisir "Tous les fichiers" comme type de fichier et codage "ANSI")

Ensuite, exécutez les commandes suivantes:

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

Après que Behat, l'extension Mink et Behat-Mink est installée, pour exécuter behat

exécuter behat

$ bin/behat

Pour activer l'extension Behat-Mink, utilisez: behat.yml créez un fichier "behat.yml" avec le contenu suivant

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"

Ce fichier sera dans le même répertoire que celui contenant le répertoire bin et le lien vers behat.
Notez également que dans le fichier yml, n'utilisez pas d'onglets pour l'indentation. utiliser des espaces. Pour obtenir une liste des commandes disponibles dans behat-mink, utilisez

$ bin/behat -di

Fais partie de ton système

Linux

Accédez à votre répertoire d'origine et procédez comme suit:

$ sudo vi .bashrc

Et ajoutez ces lignes à la fin du répertoire

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

Redémarrez la console ou tapez "source .bashrc"

les fenêtres

Passez en revue les paramètres système et ajoutez le chemin d'accès de behat / bin aux variables d'environnement

D'autres pilotes sur des pilotes comme Selenium, phantomjs, goutte, etc. doivent également être installés.

Modified text is an extract of the original Stack Overflow Documentation

Sous licence CC BY-SA 3.0

Non affilié à Stack Overflow

behat Tutoriel
Démarrer avec behat

Recherche…