Laravel, BDD dan Anda: Mari kita mulai

() translation by (you can also view the original English article)

Selamat datang di seri ini tentang mengembangkan aplikasi Laravel menggunakanbehavior-driven development (BDD). Full stack BDD dapat tampak rumit dan menakutkan. Ada cara yang sama seperti banyak melakukan hal itu karena ada pengembang.

Dalam seri ini, saya akan memandu Anda melalui pendekatan saya menggunakan Behat dan PhpSpec untuk desain Laravel aplikasi dari awal.

Ada banyak resource untuk BDD secara umum, tapi bahan tertentu Laravel sulit untuk menemukan. Oleh karena itu, dalam seri ini, kita akan fokus lebih pada Laravel terkait aspek dan kurang pada hal-hal umum yang Anda dapat membaca tentang tempat-tempat lain.

Describing Behavior

Ketika menggambarkan behavior, yang juga dikenal sebagai menulis cerita dan spesifikasi, kita akan menggunakan pendekatan outside-in Ini berarti bahwa setiap kali kita membangun fitur baru, kita akan mulai dengan menulis kisah pengguna secara keseluruhan. Hal ini biasanya dari perspektif klien atau stakeholders lainnya.

Apa kita mengharapkan terjadi ketika kita melakukan ini?

Kami tidak diperbolehkan untuk menulis kode apapun sampai kita telah gagal, langkah merah misalnya, kecuali kita adalah refactoring kode yang sudah ada.

Kadang-kadang, maka akan diperlukan untuk iteratively memecahkan sebagian kecil dari cerita atau fitur (dua kata yang saya gunakan secara bergantian) di mana kita bekerja. Ini sering berarti menulis spesifikasi dengan PhpSpec. Kadang-kadang ini akan memakan banyak iterasi pada tingkat integrasi atau unit sebelum seluruh cerita (pada tingkat penerimaan) adalah passing. Ini semua terdengar sangat rumit tapi sebenarnya tidak. Saya percaya besar dengan learning by doing, jadi saya berpikir bahwa segala sesuatu akan membuat lebih masuk akal sekali kita mulai menulis beberapa code yang sebenarnya.

Kami akan menulis cerita dan spesifikasi pada empat tingkat yang berbeda:

1. Acceptance

Sebagian besar waktu, suite fungsional kami akan berfungsi sebagai acceptance layer. Cara kami akan menggambarkan fitur kami di suite fungsional akan sangat mirip dengan bagaimana kita akan menulis acceptance story (menggunakan automated browser framework) dan dengan demikian akan membuat banyak duplikasi.

Sebagai cerita yang menggambarkan perilaku dari klien,sudut pandang, mereka melayani sebagai acceptance story. Kami akan menggunakan Symfony DomCrawler untuk menguji output dari aplikasi kita. Kemudian dalam seri ini, kita mungkin menemukan bahwa kita perlu untuk menguji melalui browser yang sebenarnya yang dapat menjalankan JavaScript juga. Pengujian melalui browser menambahkan beberapa kekhawatiran baru, karena kita perlu memastikan bahwa kami beban lingkungan pengujian jam ketika suite dijalankan.

2. Functional

Di functional suite, kita akan memiliki akses ke aplikasi Laravel, yang sangat nyaman. Pertama-tama, itu membuat mudah untuk membedakan antara environment. Kedua dari semua, tidak akan melalui browser membuat test suite kami jauh lebih cepat. Setiap kali kita ingin menerapkan fitur baru, kami akan menulis sebuah cerita di functional suite menggunakan Behat.

3. Integration

Integration suite kita akan menguji perilaku bagian inti dari aplikasi kita yang tidak selalu perlu untuk memiliki akses ke Laravel. Suite integrasi biasanya akan campuran Behat story dan PhpSpec spesifikasi.

4. Unit

Unit tes kita akan ditulis dalam PhpSpec dan akan dites terisolasi kecil unit inti aplikasi. Entity kami, value objek dll semua memiliki spesifikasi.

The Case

Sepanjang seri ini, mulai dari artikel berikutnya, kami akan membangun sebuah sistem untuk melacak waktu. Kita akan mulai dengan menggambarkan perilaku dari luar dengan menulis Behat fitur. Perilaku internal aplikasi kita akan dijelaskan menggunakan PhpSpec.

Bersama dua tool itu akan membantu kita merasa nyaman dengan kualitas aplikasi yang sedang kita bangun. Kami terutama akan menulis fitur dan spesifikasi pada tiga level:

Fungsional
Integration
Unit

Di suite kami fungsional, kami akan crawl HTTP response dari aplikasi kita dalam mode headless, berarti bahwa kita tidak akan pergi melalui browser. Ini akan membuat lebih mudah untuk berinteraksi dengan Laravel dan membuat suite kami fungsional yang berfungsi sebagai acceptance layer, juga.

Kemudian jika kita akhirnya memiliki UI yang lebih rumit dan mungkin perlu untuk menguji beberapa JavaScript juga, kita bisa menambahkan sebuah acceptance suite. Seri ini masih karya dalam proses, jadi jangan ragu untuk memberi saran Anda di bagian komentar.

Pengaturan kita

Perhatikan bahwa untuk tutorial ini, saya menganggap Anda memiliki instalasi baru dari Laravel (4.2) dan berjalan. Sebaiknya Anda menggunakan Laravel Homestead juga, yang adalah apa yang saya gunakan ketika saya menulis kode ini.

Sebelum kita mulai dengan pekerjaan nyata, mari kita pastikan kita memiliki Behat dan PhpSpec dan berjalan. Pertama walaupun, saya ingin melakukan sedikit membersihkan setiap kali aku memulai sebuah proyek laravel baru dan menghapus hal-hal yang kurang diperlukan:

1	git rm -r app/tests/ phpunit.xml CONTRIBUTING.md

Jika Anda menghapus file-file ini, pastikan untuk memperbarui file composer.json Anda seperti:

"autoload": {
    "classmap": [
        "app/commands",
        "app/controllers",
        "app/models",
        "app/database/migrations",
        "app/database/seeds"
    ]
},

Dan, tentu saja:

1	$ composer dump-autoload

Sekarang kita siap untuk menarik alat BDD yang kami butuhkan. Cukup tambahkan bagian require-dev ke composer.json Anda:

"require": {
    "laravel/framework": "4.2.*"
},
"require-dev": {
    "behat/behat": "~3.0",
    "phpspec/phpspec": "~2.0",
    "phpunit/phpunit": "~4.1"
},

"Mengapa kita pulling PHPUnit?" Anda mungkin berpikir? Kami tidak akan menulis baik ol ' PHPUnit uji kasus dalam seri ini, tapi pernyataan adalah tool yang berguna bersama-sama dengan Behat. Kita akan melihat bahwa nanti dalam artikel ini ketika kita menulis fitur pertama kami.

Ingat untuk memperbarui Anda dependensi setelah memodifikasi composer.json:

1	$ composer update --dev

Kita hampir selesai menginstal dan mengatur tool. PhpSpec bekerja seperti seharusnya:

$ vendor/bin/phpspec run

0 specs
0 examples 
0ms

Tetapi Behat perlu melakukan lari cepat dengan opsi--init untuk menyiapkan segalanya:

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

Perintah yang pertama dibuat mengkilap baru FeatureContext kelas, dimana kita dapat menulis definisi langkah yang diperlukan untuk fitur kami:

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

Menulis fitur pertama kami

Fitur pertama kami akan sangat sederhana: kita hanya akan membuat yakin bahwa instalasi Laravel baru kami menyambut kami dengan "You have arrived" pada homepage. Aku meletakkan di agak konyol Given langkah juga, Given I am logged in, yang hanya berfungsi untuk menunjukkan betapa mudahnya berinteraksi dengan Laravel di fitur kami.

Secara teknis, saya akan mengkategorikan jenis fitur sebagai functional test, karena ia berinteraksi dengan framework, tetapi juga berfungsi sebagai acceptance test, karena kita tidak akan melihat apapun hasil yang berbeda dari menjalankan tes serupa melalui browser alat pengujian. Untuk sekarang kita akan menempel dengan functional test suite.

Langsung saja dan membuat welcome.feature file dan meletakkannya di features/functional:

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

Dengan meletakkan fitur fungsional dalam direktori functional, akan lebih mudah bagi kita untuk mengelola suite kami kemudian. Kami tidak ingin integrasi jenis fitur yang tidak memerlukan Laravel harus menunggu untuk suite fungsional lambat.

Saya suka menjaga hal-hal bagus dan bersih, jadi saya percaya kita harus memiliki fitur khusus konteks untuk functional suite yang dapat memberikan kami akses ke Laravel. Anda hanya dapat pergi ke depan dan salin file FeatureContext yang sudah ada dan mengubah nama kelas untuk LaravelFeatureContext. Untuk pekerjaan ini, kita juga perlu file konfigurasi behat.yml.

Membuat satu dalam direktori root dari proyek Anda dan tambahkan berikut:

default:
    suites:
        functional:
            paths: [ %paths.base%/features/functional ]
            contexts: [ LaravelFeatureContext ]

Saya pikir YAML di sini adalah diri cukup jelas. functional suitekami akan mencari fitur dalam direktori functional dan menjalankan mereka melalui LaravelFeatureContext.

Jika kita mencoba untuk menjalankan Behat saat ini, ini akan memberitahu kita untuk melaksanakan definisi langkah penting. Kita dapat memiliki Behat menambahkan metode scaffold kosong ke LaravelFeatureContext dengan perintah berikut:

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

Dan sekarang, seperti yang Anda lihat dari Keluaran, kami siap untuk mulai melaksanakan pertama dari langkah kami: Given I am logged in.

Kasus uji PHPUnit yang kapal dengan Laravel memungkinkan kita untuk melakukan hal-hal seperti $this->be($user), yang log in pengguna tertentu. Pada akhirnya, kami ingin dapat berinteraksi dengan Laravel seolah-olah kami menggunakan PHPUnit, jadi mari kita pergi ke depan dan menulis kode definisi langkah "we wish we had":

/**
 * @Given I am logged in
 */
public function iAmLoggedIn()
{
    $user = new User;

    $this->be($user);
}

Ini tidak akan bekerja tentu saja, karena Behat tidak tahu tentang hal-hal tertentu Laravel, tapi saya akan menunjukkan Anda dalam hanya kedua cara mudah untuk mendapatkan Behat dan Laravel untuk bermain dengan baik bersama-sama.

Jika Anda melihat di sumber Laravel dan menemukan Illuminate\Foundation\Testing\TestCase kelas, yaitu kelas yang kasus uji standar meluas dari, Anda akan melihat bahwa mulai dari Laravel 4.2, semuanya telah dipindahkan ke sifat. ApplicationTrait sekarang bertanggung jawab untuk booting instance Application, pengaturan klien HTTP dan memberi kita beberapa metode helper, seperti be().

Ini keren, terutama karena itu berarti bahwa kita dapat hanya menarik itu untuk konteks Behat kami dengan hampir tidak ada setup yang diperlukan. Kami juga memiliki akses ke AssertionsTrait, tetapi ini masih terikat PHPUnit.

Ketika kita menarik trait, kita perlu untuk melakukan dua hal. Kita perlu memiliki setUp() metode, seperti di Illuminate\Foundation\Testing\TestCase kelas, dan kami memerlukan createApplication() metode, seperti di standar Laravel uji kasus. Benar-benar kita dapat hanya menyalin dua metode dan menggunakannya langsung.

Ada hanya satu hal perlu diperhatikan: di PHPUnit, setUp() metode akan secara otomatis dipanggil sebelum setiap tes. Untuk mencapai hal yang sama dalam Behat, kita dapat menggunakan anotasi @BeforeScenario.

Tambahkan baris berikut ke LaravelFeatureContext Anda:

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';
    }

Cukup mudah, dan lihat apa yang kita dapatkan ketika kita menjalankan 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)

Hijau langkah pertama, yang berarti bahwa kami setup bekerja!

Berikutnya, kita dapat menerapkan When I visit step. Ini super mudah, dan kita dapat menggunakan call() metode yang menyediakan ApplicationTrait. Satu baris kode akan membuat kita di sana:

/**
 * @When I visit :uri
 */
public function iVisit($uri)
{
    $this->call('GET', $uri);
}

Langkah terakhir, Then I should see, mengambil sedikit lebih dan kita perlu untuk menarik dua dependensi. Kita perlu PHPUnit untuk assertion dan kita akan membutuhkan Symfony DomCrawler untuk mencari teks "You have arrived.".

Kita dapat menerapkan seperti ini:

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}']"));
}

Ini adalah cukup banyak kode yang sama seperti Anda akan menulis jika Anda menggunakan PHPUnit. Bagian filterXpath() sedikit membingungkan dan kami akan tidak khawatir tentang hal itu sekarang, karena itu keluar sedikit dari lingkup artikel ini. Percaya saja kepadaku bahwa ia bekerja.

Menjalankan Behat satu kali akhir adalah kabar baik:

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

Fitur ini bekerja seperti yang diharapkan dan pengembang disambut pada saat kedatangan.

Kesimpulan

LaravelFeatureContext lengkap sekarang harus terlihat seperti ini:

<?php

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

use PHPUnit_Framework_Assert as PHPUnit;
use Symfony\Component\DomCrawler\Crawler;

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';
    }

    /**
     * @Given I am logged in
     */
    public function iAmLoggedIn()
    {
        $user = new User;

        $this->be($user);
    }

    /**
     * @When I visit :uri
     */
    public function iVisit($uri)
    {
        $this->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}']"));
    }
}

Kami sekarang memiliki dasar yang benar-benar baik untuk membangun kita terus mengembangkan aplikasi Laravel baru kami menggunakan BDD. Saya berharap saya telah membuktikan kepada Anda betapa mudahnya untuk mendapatkan Laravel dan Behat untuk bermain dengan baik bersama-sama.

Kami telah menyentuh pada banyak topik yang berbeda dalam artikel yang pertama. Tidak perlu khawatir, kita akan melihat lebih mendalam semuanya sebagai seri terus. Jika Anda memiliki pertanyaan atau saran, silakan tinggalkan komentar.

1	<?php
2
3	use Behat\Behat\Context\SnippetAcceptingContext;
4	use Behat\Gherkin\Node\PyStringNode;
5	use Behat\Gherkin\Node\TableNode;
6
7	use PHPUnit_Framework_Assert as PHPUnit;
8	use Symfony\Component\DomCrawler\Crawler;
9
10	use Illuminate\Foundation\Testing\ApplicationTrait;
11
12	/**
13	* Behat context class.
14	*/
15	class LaravelFeatureContext implements SnippetAcceptingContext
16	{
17	/**
18	* Responsible for providing a Laravel app instance.
19	*/
20	use ApplicationTrait;
21
22	/**
23	* Initializes context.
24	*
25	* Every scenario gets its own context object.
26	* You can also pass arbitrary arguments to the context constructor through behat.yml.
27	*/
28	public function __construct()
29	{
30	}
31
32	/**
33	* @BeforeScenario
34	*/
35	public function setUp()
36	{
37	if ( ! $this->app)
38	{
39	$this->refreshApplication();
40	}
41	}
42
43	/**
44	* Creates the application.
45	*
46	* @return \Symfony\Component\HttpKernel\HttpKernelInterface
47	*/
48	public function createApplication()
49	{
50	$unitTesting = true;
51
52	$testEnvironment = 'testing';
53
54	return require __DIR__.'/../../bootstrap/start.php';
55	}
56
57	/**
58	* @Given I am logged in
59	*/
60	public function iAmLoggedIn()
61	{
62	$user = new User;
63
64	$this->be($user);
65	}
66
67	/**
68	* @When I visit :uri
69	*/
70	public function iVisit($uri)
71	{
72	$this->call('GET', $uri);
73	}
74
75	/**
76	* @Then I should see :text
77	*/
78	public function iShouldSee($text)
79	{
80	$crawler = new Crawler($this->client->getResponse()->getContent());
81
82	PHPUnit::assertCount(1, $crawler->filterXpath("//text()[. = '{$text}']"));
83	}
84	}