Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Writing Your First Tests

4:56 with Alena Holligan

PHP Unit is built on assertions. These are actions that state something forcefully. Assertions is just a fancy way of saying true or false. These assertions describe how the code-under-test is supposed to be working. The vast majority of tests you write using PHPUnit will be using assertions.

Step 1

Install PHPUnit

composer require --dev phpunit/phpunit ^8

Step 2

Create a test folder and add your first test file, ending with Test.php

tests/FirstTest.php

Step 3

Add a class that extends from the PHPUnit\Framework\TestCase class.

class FirstTest extends PHPUnit\Framework\TestCase
{

}

Step 4

Add a test function, either named with "test" at the beginning, or using the @test annotation.

/** @test */
function firstAssertion()
{
    $this->assertTrue(false);
}
  • 0:00

    Let's start with a search for PHP Unit.

  • 0:04

    The first result, it's PHPUnit.de which is what we want.

  • 0:09

    We're going to choose Getting Started at the top, and

  • 0:12

    then we see the versions four through eight.

  • 0:15

    The version you choose is based off which PHP version you have installed.

  • 0:19

    Since I'm using PHP 7.2 or later, I can go with PHPUnit 8.

  • 0:25

    Like any good package, PHPUnit can be installed with Composer.

  • 0:30

    Two things to know, first, it is not recommended to install PHPUnit globally.

  • 0:37

    You should install it per project.

  • 0:39

    Second, PHP unit is for

  • 0:41

    testing on your development environment before you pushed production.

  • 0:47

    So we want to install this for development using the dev flag.

  • 0:52

    We'll be working in Visual Studio code where we have a built-in terminal.

  • 0:57

    We're in a new empty directory named TESTING.

  • 1:00

    From within this folder we can run composer require --dev phpunit/phpunit ^8.

  • 1:10

    Once PHP Unit is installed, we're ready to write our first test.

  • 1:15

    PHP unit is built on assertions.

  • 1:18

    These are actions that state something forcefully.

  • 1:22

    Assertions are just a fancy way of saying true or false.

  • 1:26

    These assertions describe how the code on your test is supposed to be working.

  • 1:32

    The vast majority of test that you write using PHP unit will be using assertions.

  • 1:38

    There are some edge cases when dealing with testing for exceptions to be thrown.

  • 1:43

    The simplest test and the good starting point or

  • 1:46

    temporary place order is assertTrue (false), that's it, very simple.

  • 1:52

    These assertions either fail or pass.

  • 1:56

    They're either true or false.

  • 1:58

    Since false is not true, this assertion would fail.

  • 2:02

    To translate it into php unit, it looks like this, $this->assertTrue(false);.

  • 2:09

    Let's write this as our first test.

  • 2:12

    We'll start by creating a folder named tests.

  • 2:18

    Then we'll add a new class file named FirstTest.php.

  • 2:26

    We'll define a class named FirstTest that extends,

  • 2:33

    PHP unit, framework, Test case.

  • 2:41

    Then we can write a function for each test.

  • 2:44

    We'll start with our true false assertion.

  • 2:47

    Create a new function named first assertion.

  • 2:53

    Then we can call this assertTrue and pass false.

  • 3:01

    Now we want to run our test.

  • 3:03

    PHP unit is primarily a command line script, so

  • 3:06

    we'll be in our terminal just like we were for composer.

  • 3:09

    From here, we can run vendor/bin/phpunit and

  • 3:15

    then the path to our test file, tests/FirstTest.php.

  • 3:21

    I get a warning that no tests were found.

  • 3:25

    By default, if I don't start my function name with test, it won't be run as a test.

  • 3:31

    Let's add a second function.

  • 3:36

    Test second assertion.

  • 3:43

    And we'll add this, assertTrue again And pass false.

  • 3:53

    If everything works, we'll see our first failure.

  • 3:57

    A failed test is marked with an F, and the message is displayed below.

  • 4:04

    Failed asserting that false is true.

  • 4:07

    Let's create a third assertion.

  • 4:10

    This time, instead of studying our function name with test,

  • 4:14

    we have a second option.

  • 4:15

    We can use annotation in a method stuck block to market as a test method.

  • 4:23

    Test, and now we can say function,

  • 4:28

    third assertion.

  • 4:31

    This time we'll use this->assertTrue and pass true.

  • 4:37

    Now we see that we are running two tests.

  • 4:41

    The first one fails with an F and the second one passes showing a dot.

  • 4:47

    We also continue to see a failure message.

  • 4:51

    Let's run the example from the PHP unit Getting Started page

You need to sign up for Treehouse in order to download course files.

Sign up