Beginnen wir mit Laravel, BDD und Ihnen-PHP-Tutorial-php.cn

让我们从 Laravel、BDD 和你开始

Willkommen zu einer Reihe über die Entwicklung von Laravel-Anwendungen mit Methoden der verhaltensgesteuerten Entwicklung (BDD). Full-Stack-BDD kann komplex und einschüchternd wirken. Es gibt so viele Möglichkeiten, dies zu erreichen, wie es Entwickler gibt.

In dieser Serie führe ich Sie durch den Entwurf einer Laravel-Anwendung von Grund auf mit Behat und PhpSpec.

Es gibt viele Ressourcen zu BDD im Allgemeinen, aber Laravel-spezifisches Material ist schwer zu finden. Deshalb konzentrieren wir uns in dieser Serie mehr auf Aspekte im Zusammenhang mit Laravel und nicht auf die allgemeinen Dinge, die Sie an vielen anderen Stellen lesen können.

Beschreiben Sie das Verhalten

Bei der Beschreibung von Verhaltensweisen (auch bekannt als das Schreiben von Geschichten und Spezifikationen) verwenden wir einen Outside-In-Ansatz. Das bedeutet, dass wir jedes Mal, wenn wir eine neue Funktion erstellen, zunächst eine komplette User Story schreiben. Dies erfolgt in der Regel aus Kunden- oder Stakeholder-Perspektive.

Was erwarten wir, wenn wir das tun? 块引用>
Solange wir vorhandenen Code nicht umgestalten, dürfen wir keinen Code schreiben, es sei denn, wir treffen auf einen fehlgeschlagenen roten Schritt.

Manchmal ist es notwendig, einen kleinen Teil einer Geschichte oder eines Features (ich verwende die beiden Wörter synonym) an dem wir arbeiten, iterativ anzugehen. Dies bedeutet normalerweise, Spezifikationen mit PHPSpec zu schreiben. Manchmal sind mehrere Iterationen auf Integrations- oder Einheitenebene erforderlich, bevor die gesamte Story abgeschlossen ist (auf der Akzeptanzebene). Das hört sich alles kompliziert an, ist es aber nicht. Ich bin ein großer Verfechter des „Learning by Doing“ und denke daher, dass alles mehr Sinn ergeben wird, wenn wir anfangen, echten Code zu schreiben.

Wir werden Geschichten und Spezifikationen auf vier verschiedenen Ebenen schreiben:

1. Akzeptanz

Meistens fungiert unsere Feature-Suite als unsere Akzeptanzschicht. Die Art und Weise, wie wir Funktionen in einer Feature-Suite beschreiben, wird der Art und Weise, wie wir Akzeptanzgeschichten schreiben (mithilfe des Automated Browser Framework), sehr ähnlich sein, daher wird es viele Duplikate geben.

Solange die Geschichten das Verhalten aus der Sicht des Kunden beschreiben, können sie als Akzeptanzgeschichten dienen. Wir werden Symfony DomCrawler verwenden, um die Ausgabe der Anwendung zu testen. Später in dieser Serie stellen wir möglicherweise fest, dass wir einen Test mit einem echten Browser durchführen müssen, der auch JavaScript ausführen kann. Das Testen über den Browser bringt einige neue Probleme mit sich, da wir sicherstellen müssen, dass die stündliche Testumgebung geladen wird, während die Suite ausgeführt wird.

2. Funktionalität

In unserer Feature-Suite haben wir Zugriff auf Laravel-Anwendungen, was sehr praktisch ist. Erstens ermöglicht es eine einfache Unterscheidung von Umgebungen. Zweitens wird unsere Testsuite schneller, wenn wir nicht über den Browser gehen. Wann immer wir eine neue Funktion implementieren möchten, verwenden wir Behat, um eine Geschichte in unserer Feature-Suite zu schreiben.

3. Integration

Unsere Integrationssuite testet das Verhalten von Kernteilen Ihrer Anwendung, die nicht unbedingt Zugriff auf Laravel erfordern. Integrierte Suiten sind normalerweise eine Mischung aus Behat-Geschichten und PhpSpec-Spezifikationen.

4. Einheit

Unsere Unit-Tests werden in PhpSpec geschrieben und testen unabhängige kleine Einheiten des Kerns der Anwendung. Unsere Entitäten, Wertobjekte usw. werden alle Spezifikationen haben.

Fall

In dieser Serie werden wir, beginnend mit dem nächsten Artikel, ein System zur Zeiterfassung aufbauen. Wir werden zunächst das äußere Verhalten beschreiben, indem wir ein Behat-Merkmal schreiben. Das interne Verhalten unserer Anwendung wird mit PHPSpec beschrieben.

Diese beiden Tools zusammen werden uns helfen, mit der Qualität der von uns erstellten Anwendung zufrieden zu sein. Wir werden Funktionen und Spezifikationen hauptsächlich auf drei Ebenen schreiben:

Funktionalität

Integration

Einheit

In unserer Feature-Suite erfassen wir die HTTP-Antwort der Anwendung im Headless-Modus, was bedeutet, dass wir nicht über den Browser gehen. Dies erleichtert die Interaktion mit Laravel und ermöglicht es unserer Funktionssuite, auch als unsere Akzeptanzschicht zu fungieren.

Wenn wir später eine komplexere Benutzeroberfläche haben und vielleicht auch etwas JavaScript testen müssen, fügen wir möglicherweise eine dedizierte Akzeptanzsuite hinzu. Die Serie ist noch in Arbeit, Sie können also gerne Ihre Vorschläge im Kommentarbereich abgeben.

Unsere Einstellungen

Bitte beachten Sie, dass ich in diesem Tutorial davon ausgehe, dass Sie Laravel (4.2) neu installiert und ausgeführt haben. Am besten verwenden Sie auch Laravel Homestead, das ich beim Schreiben dieses Codes verwendet habe.

Bevor wir mit der eigentlichen Arbeit beginnen, stellen wir sicher, dass Behat und PhpSpec betriebsbereit sind. Wenn ich ein neues Laravel-Projekt starte, mache ich zunächst einmal gerne ein wenig Aufräumarbeiten und entferne Dinge, die ich nicht benötige:
git rm -r app/tests/ phpunit.xml CONTRIBUTING.md
Nach dem Login kopieren
Wenn Sie diese Dateien löschen, aktualisieren Sie unbedingt Ihre composer.json Dateien entsprechend:
"autoload": {
    "classmap": [
        "app/commands",
        "app/controllers",
        "app/models",
        "app/database/migrations",
        "app/database/seeds"
    ]
},
Nach dem Login kopieren
Natürlich:
$ composer dump-autoload
Nach dem Login kopieren
Jetzt sind wir bereit, die BDD-Tools vorzustellen, die wir brauchen. Fügen Sie einfach den Abschnitt require-dev zu Ihrem require-dev 部分添加到您的 composer.json hinzu:
"require": {
    "laravel/framework": "4.2.*"
},
"require-dev": {
    "behat/behat": "~3.0",
    "phpspec/phpspec": "~2.0",
    "phpunit/phpunit": "~4.1"
},
Nach dem Login kopieren
“我们为什么要引入 PHPUnit？”你可能在想？在本系列中，我们不会编写优秀的 PHPUnit 测试用例，但断言与 Behat 一起是一个方便的工具。我们将在本文后面编写第一个功能时看到这一点。

请记住在修改 composer.json 后更新依赖项：
$ composer update --dev
Nach dem Login kopieren
我们即将完成安装和设置。 PhpSpec 开箱即用：
$ vendor/bin/phpspec run

0 specs
0 examples 
0ms
Nach dem Login kopieren
但是 Behat 需要使用 --init 选项快速运行才能设置所有内容：
$ 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

$ vendor/bin/behat

No scenarios
No steps
0m0.14s (12.18Mb)
Nach dem Login kopieren
第一个命令创建了一个闪亮的新 FeatureContext 类，我们可以在其中编写功能所需的步骤定义：
<?php

use Behat\Behat\Context\SnippetAcceptingContext;
use Behat\Gherkin\Node\PyStringNode;
use Behat\Gherkin\Node\TableNode;

/**
 * Behat context class.
 */
class FeatureContext implements SnippetAcceptingContext
{
    /**
     * Initializes context.
     *
     * Every scenario gets its own context object.
     * You can also pass arbitrary arguments to the context constructor through behat.yml.
     */
    public function __construct()
    {
    }
}
Nach dem Login kopieren
编写我们的第一个功能

我们的第一个功能非常简单：我们只需确保新的 Laravel 安装以“您已到达”来迎接我们。在主页上。我还添加了一个相当愚蠢的 Given 步骤，假设我登录了 ，这仅用于显示在我们的功能中与 Laravel 交互是多么容易。

从技术上讲，我将这种类型的功能归类为功能测试，因为它与框架交互，但它也可以作为验收测试，因为我们不会看到通过浏览器测试运行类似测试有任何不同的结果工具。现在我们将坚持使用我们的功能测试套件。

继续创建一个 welcome.feature 文件并将其放入 features/functions:
# features/functional/welcome.feature

Feature: Welcoming developer
    As a Laravel developer
    In order to proberly begin a new project
    I need to be greeted upon arrival

    Scenario: Greeting developer on homepage
        Given I am logged in
        When I visit "/"
        Then I should see "You have arrived."
Nach dem Login kopieren
通过将功能特性放在 featured 目录中，我们以后可以更轻松地管理我们的套件。我们不希望不需要 Laravel 的集成类型功能必须等待缓慢的功能套件。

我喜欢让事情保持美观和干净，所以我相信我们应该为我们的功能套件提供一个专用的功能上下文，以便我们可以访问 Laravel。您可以继续复制现有的 FeatureContext 文件并将类名称更改为 LaravelFeatureContext。为此，我们还需要一个 behat.yml 配置文件。

在项目的根目录中创建一个并添加以下内容：
default:
    suites:
        functional:
            paths: [ %paths.base%/features/functional ]
            contexts: [ LaravelFeatureContext ]
Nach dem Login kopieren
我认为这里的 YAML 是非常不言自明的。我们的功能套件将在 functioning 目录中查找功能，并通过 LaravelFeatureContext 运行它们。

如果我们此时尝试运行 Behat，它会告诉我们实现必要的步骤定义。我们可以使用以下命令让 Behat 将空脚手架方法添加到 LaravelFeatureContext 中：
$ vendor/bin/behat --dry-run --append-snippets
$ vendor/bin/behat

Feature: Welcoming developer
    As a Laravel developer
    In order to proberly begin a new project
    I need to be greeted upon arival

  Scenario: Greeting developer on homepage # features/functional/welcome.feature:6
    Given I am logged in                   # LaravelFeatureContext::iAmLoggedIn()
      TODO: write pending definition
    When I visit "/"                       # LaravelFeatureContext::iVisit()
    Then I should see "You have arrived."  # LaravelFeatureContext::iShouldSee()

1 scenario (1 pending)
3 steps (1 pending, 2 skipped)
0m0.28s (12.53Mb)
Nach dem Login kopieren
现在，正如您从输出中看到的那样，我们已准备好开始实施第一个步骤：鉴于我已登录 。

Laravel 附带的 PHPUnit 测试用例允许我们执行诸如 $this->be($user) 之类的操作，它会登录给定用户。最终，我们希望能够像使用 PHPUnit 一样与 Laravel 交互，所以让我们继续编写“我们希望拥有”的步骤定义代码：
/**
 * @Given I am logged in
 */
public function iAmLoggedIn()
{
    $user = new User;

    $this->be($user);
}
Nach dem Login kopieren
这当然行不通，因为 Behat 不知道 Laravel 的具体内容，但我很快就会向您展示让 Behat 和 Laravel 很好地协同工作是多么容易。

如果您查看 Laravel 源代码并找到 Illuminate\Foundation\Testing\TestCase 类（默认测试用例扩展自该类），您会发现从 Laravel 4.2 开始，一切都已更改转移到一个特质。 ApplicationTrait 现在负责启动 Application 实例、设置 HTTP 客户端并为我们提供一些辅助方法，例如 be()。

这非常酷，主要是因为这意味着我们可以将其拉入我们的 Behat 上下文中，几乎不需要任何设置。我们还可以访问 AssertionsTrait，但这仍然与 PHPUnit 相关。

当我们引入特征时，我们需要做两件事。我们需要一个 setUp() 方法，如 Illuminate\Foundation\Testing\TestCase 类中的方法，并且需要一个 createApplication() 方法，如默认 Laravel 测试用例中的方法。其实我们直接复制这两个方法就可以了。

只有一件事需要注意：在 PHPUnit 中，方法 setUp() 会在每次测试之前自动调用。为了在 Behat 中实现相同的效果，我们可以使用 @BeforeScenario 注释。

将以下内容添加到您的 LaravelFeatureContext：
use Illuminate\Foundation\Testing\ApplicationTrait;

/**
 * Behat context class.
 */
class LaravelFeatureContext implements SnippetAcceptingContext
{
    /**
     * Responsible for providing a Laravel app instance.
     */
    use ApplicationTrait;

    /**
     * Initializes context.
     *
     * Every scenario gets its own context object.
     * You can also pass arbitrary arguments to the context constructor through behat.yml.
     */
    public function __construct()
    {
    }

    /**
     * @BeforeScenario
     */
    public function setUp()
    {
        if ( ! $this->app)
        {
            $this->refreshApplication();
        }
    }

    /**
     * Creates the application.
     *
     * @return \Symfony\Component\HttpKernel\HttpKernelInterface
     */
    public function createApplication()
    {
        $unitTesting = true;

        $testEnvironment = 'testing';

        return require __DIR__.'/../../bootstrap/start.php';
    }
Nach dem Login kopieren
非常简单，看看我们运行 Behat 时得到的结果：
$ vendor/bin/behat

Feature: Welcoming developer
    As a Laravel developer
    In order to proberly begin a new project
    I need to be greeted upon arival

  Scenario: Greeting developer on homepage # features/functional/welcome.feature:6
    Given I am logged in                   # LaravelFeatureContext::iAmLoggedIn()
    When I visit "/"                       # LaravelFeatureContext::iVisit()
      TODO: write pending definition
    Then I should see "You have arrived."  # LaravelFeatureContext::iShouldSee()

1 scenario (1 pending)
3 steps (1 passed, 1 pending, 1 skipped)
0m0.73s (17.92Mb)
Nach dem Login kopieren
绿色的第一步，这意味着我们的设置正在运行！

接下来，我们可以实现 当我访问 步骤。这个非常简单，我们可以简单地使用 ApplicationTrait 提供的 call() 方法。一行代码即可实现：
/**
 * @When I visit :uri
 */
public function iVisit($uri)
{
    $this->call('GET', $uri);
}
Nach dem Login kopieren
最后一步，然后我应该看到，需要更多一点，我们需要引入两个依赖项。我们需要 PHPUnit 来进行断言，并且需要 Symfony DomCrawler 来搜索“您已到达”。文本。

我们可以这样实现：
use PHPUnit_Framework_Assert as PHPUnit;
use Symfony\Component\DomCrawler\Crawler;

...

/**
 * @Then I should see :text
 */
public function iShouldSee($text)
{
    $crawler = new Crawler($this->client->getResponse()->getContent());

    PHPUnit::assertCount(1, $crawler->filterXpath("//text()[. = '{$text}']"));
}
Nach dem Login kopieren
这与您使用 PHPUnit 时编写的代码几乎相同。 filterXpath() 部分有点令人困惑，我们现在不用担心它，因为它有点超出了本文的范围。请相信我，它有效。

最后一次跑步是个好消息：
$ vendor/bin/behat
Feature: Welcoming developer
    As a Laravel developer
    In order to proberly begin a new project
    I need to be greeted upon arival

  Scenario: Greeting developer on homepage # features/functional/welcome.feature:6
    Given I am logged in                   # LaravelFeatureContext::iAmLoggedIn()
    When I visit "/"                       # LaravelFeatureContext::iVisit()
    Then I should see "You have arrived."  # LaravelFeatureContext::iShouldSee()

1 scenario (1 passed)
3 steps (3 passed)
0m0.82s (19.46Mb)
Nach dem Login kopieren
该功能正在按预期工作，并且开发人员在抵达时受到欢迎。

结论

完整的 LaravelFeatureContext 现在应该与此类似：
call('GET', $uri);
    }

    /**
     * @Then I should see :text
     */
    public function iShouldSee($text)
    {
        $crawler = new Crawler($this->client->getResponse()->getContent());

        PHPUnit::assertCount(1, $crawler->filterXpath("//text()[. = '{$text}']"));
    }
}
Nach dem Login kopieren
随着我们继续使用 BDD 开发新的 Laravel 应用程序，我们现在已经有了一个非常好的基础。我希望我已经向您证明了让 Laravel 和 Behat 很好地协同工作是多么容易。

我们在第一篇文章中讨论了许多不同的主题。不用担心，随着本系列的继续，我们将更深入地研究一切。如果您有任何问题或建议，请留言。

Das obige ist der detaillierte Inhalt vonBeginnen wir mit Laravel, BDD und Ihnen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!