Unlock The Mystery Of PHPUnit (Wave PHP 2018)

Unlock The Mystery
of PHPUnit
Brian Johnson

What is a unit test?
In computer programming, unit testing is a software testing method by
which individual units of source code, sets of one or more computer program
modules together with associated control data, usage procedures, and
operating procedures, are tested to determine whether they are ﬁt for use.
https://en.wikipedia.org/wiki/Unit_testing

What is PHPUnit?
PHPUnit is a programmer-oriented testing framework for PHP.
It is an instance of the xUnit architecture for unit testing frameworks.
https://phpunit.de/

Setup/Install
$ composer require --dev phpunit/phpunit
Using version ^7.3 for phpunit/phpunit
./composer.json has been created
Loading composer repositories with package information
Updating dependencies (including require-dev)
Package operations: 27 installs, 0 updates, 0 removals
- Installing sebastian/version (2.0.1): Loading from cache
- Installing sebastian/resource-operations (1.0.0): Loading
from cache
...

$ vendor/bin/phpunit
PHPUnit 7.3.5 by Sebastian Bergmann and contributors.
Usage: phpunit [options] UnitTest [UnitTest.php]
phpunit [options] <directory>

Alternative:
composer.json:
{
"require-dev": {
"phpunit/phpunit": "^7.3"
},
"scripts": {
"test": "phpunit test"
}
}
$ composer test

A Basic Test Example
Implement a Cheerleader
Cheerleader functions:
•gimmeAn - will accept a character as an argument; will
return same character, and append character to an
ever-growing string
•whatsThatSpell - will return the stored string built by
repeated calls to gimmeAn with an ! appended to the
end
•doTheSplits - will throw an exception

<?php
namespace WavePHPCheer;
use PHPUnitFrameworkTestCase;
class CheerleaderTest extends TestCase
{
}
CheerleaderTest.php:

> phpunit test
W 1 / 1 (100%)
Time: 20 ms, Memory: 4.00MB
There was 1 warning:
1) Warning
No tests found in class "WavePHPCheerCheerleaderTest".
WARNINGS!
Tests: 1, Assertions: 0, Warnings: 1.
Script phpunit test handling the test event returned with error code 1
$ composer test

public function testGimmeAnG()
{
$cheerleader = new Cheerleader();
$this->assertThat($cheerleader->gimmeAn('G'),
$this->equalTo('G'));
}
•gimmeAn - will accept a character as an argument; will
return same character, and append character to an ever-
growing string

/**
* @test
*/
public function gimmeAnO()
{
$this->assertThat($cheerleader->gimmeAn('O'),
$this->equalTo('O'));
}

/**
* @test
*/
public function testWhatsThatSpell()
{
$cheerleader->gimmeAn('G');
$cheerleader->gimmeAn('O');
$this->assertThat($cheerleader->whatsThatSpell(),
$this->equalTo('GO!'));
}

<?php
{
{
}
/**
* @test
*/
{
}
/**
* @test
*/
{
}
}

$ composer test
> phpunit test
EEE 3 / 3 (100%)
There were 3 errors:
1) WavePHPCheerCheerleaderTest::testGimmeAnG
Error: Class 'WavePHPCheerCheerleader' not found
/Volumes/git/wavephp_phpunit/test/CheerleaderTest.php:11
2) WavePHPCheerCheerleaderTest::gimmeAnO
3) WavePHPCheerCheerleaderTest::testWhatsThatSpell
ERRORS!
Tests: 3, Assertions: 0, Errors: 3.

<?php
class Cheerleader
{
public function gimmeAn($letter)
{
}
}
Cheerleader.php:

$ composer test
> phpunit test
FFE 3 / 3 (100%)
There was 1 error:
1) WavePHPCheerCheerleaderTest::testWhatsThatSpell
Error: Call to undeﬁned method WavePHPCheerCheerleader::whatsThatSpell()
--
There were 2 failures:
1) WavePHPCheerCheerleaderTest::testGimmeAnG
Failed asserting that null matches expected 'G'.
2) WavePHPCheerCheerleaderTest::gimmeAnO
Failed asserting that null matches expected 'O'.
ERRORS!
Tests: 3, Assertions: 2, Errors: 1, Failures: 2.

<?php
class Cheerleader
{
private $word = '';
{
$this->word .= $letter;
return $letter;
}
public function whatsThatSpell()
{
return $this->word . '!';
}
}
• gimmeAn - will accept a character
as an argument; will return same
character, and append character to
an ever-growing string
• whatsThatSpell - will return the
stored string built by repeated calls
to gimmeAn with an ! appended to
the end

$ composer test
> phpunit test
... 3 / 3 (100%)
OK (3 tests, 3 assertions)

<?php
{
{
}
/**
* @test
*/
{
}
/**
* @test
*/
{
}
}
$ composer test
> phpunit test
... 3 / 3 (100%)

/**
* @expectedException WavePHPCheerLackOfFlexibilityException
*/
public function testTheSplits()
{
$cheerleader->doTheSplits();
}

<?php
use Exception;
class LackOfFlexibilityException extends Exception { }
LackOfFlexibilityException.php:

public function doTheSplits()
{
throw new LackOfFlexibilityException("I can't do that!");
}
Cheerleader.php:

$ composer test -- --debug
> phpunit test '--debug'
Test 'WavePHPCheerCheerleaderTest::testGimmeAnG' started
Test 'WavePHPCheerCheerleaderTest::testGimmeAnG' ended
Test 'WavePHPCheerCheerleaderTest::gimmeAnO' started
Test 'WavePHPCheerCheerleaderTest::gimmeAnO' ended
Test 'WavePHPCheerCheerleaderTest::testWhatsThatSpell' started
Test 'WavePHPCheerCheerleaderTest::testWhatsThatSpell' ended
Test 'WavePHPCheerCheerleaderTest::testTheSplits' started
Test 'WavePHPCheerCheerleaderTest::testTheSplits' ended

use InvalidArgumentException;
...
public function testGimmeAnInvalidArg()
{
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage(
'WavePHPCheerCheerleader::gimmeAn may only '
. 'accept a single char arg');
$this->expectExceptionCode(619);
$cheerleader->gimmeAn("This is not a single character");
}

use InvalidArgumentException;
...
{
if (!is_string($letter) || 1 != mb_strlen($letter)) {
throw new InvalidArgumentException(__METHOD__
. ' may only accept a single char arg', 619);
}
$this->word .= $letter;
return $letter;
}
Cheerleader.php:

Test 'WavePHPCheerCheerleaderTest::testGimmeAnInvalidArg' started
Test 'WavePHPCheerCheerleaderTest::testGimmeAnInvalidArg' ended

MOCKS!
The practice of replacing an object with a test double
that veriﬁes expectations, for instance asserting that a
method has been called, is referred to as mocking.

<?php
class Pompom
{
public function shake()
{
// return true if shake successful
return true;
}
}
Pompom.php:

private $pompom;
...
public function __construct(Pompom $pompom = null)
{
if (empty($pompom)) {
$pompom = new Pompom();
}
$this->setPompom($pompom);
}
Cheerleader.php:

public function setPompom(Pompom $pompom)
{
$this->pompom = $pompom;
}
...
{
$this->pompom->shake();
}
Cheerleader.php:

getMockBuilder($type)
createMock($type)
How do I make a mock?
The createMock($type) method immediately returns a test double object for
the speciﬁed type (interface or class). The creation of this test double is
performed using best practice defaults. The __construct() and __clone()
methods of the original class are not executed) and the arguments passed to
a method of the test double will not be cloned. If these defaults are not what
you need then you can use the getMockBuilder($type) method to customize
the test double generation using a ﬂuent interface.

public function testPomShake()
{
$mockPom = $this->createMock(Pompom::class);
$mockPom->expects($this->once())
->method('shake');
$cheerleader = new Cheerleader($mockPom);
$cheerleader->whatsThatSpell();
}

public function testPomShakeFail()
{
->method('shake')
->willReturn(false);
$this->expectException(PomShakeFailException::class);
}

{
if (!$this->pompom->shake()) {
throw new PomShakeFailException();
}
}
Cheerleader.php:

Test 'WavePHPCheerCheerleaderTest::testPomShake' started
Test 'WavePHPCheerCheerleaderTest::testPomShake' ended
Test 'WavePHPCheerCheerleaderTest::testPomShakeFail' started
Test 'WavePHPCheerCheerleaderTest::testPomShakeFail' ended
There was 1 error:
1) WavePHPCheerCheerleaderTest::testPomShake
WavePHPCheerPomShakeFailException:
/Volumes/git/wavephp_phpunit/src/Cheerleader.php:33
ERRORS!
Tests: 7, Assertions: 9, Errors: 1.

{
if (!$this->pompom->shake()) {
throw new PomShakeFailException();
}
}
Cheerleader.php:
{
$mockPom = $this->createMock(Pompom
->method('shake');
$cheerleader = new Cheerleader($mockP
}

{
->method('shake')
->willReturn(true);
}

Test 'WavePHPCheerCheerleaderTest::testPomShake' started
Test 'WavePHPCheerCheerleaderTest::testPomShake' ended
Test 'WavePHPCheerCheerleaderTest::testPomShakeFail' started
Test 'WavePHPCheerCheerleaderTest::testPomShakeFail' ended

Data Providers
A test method can accept arbitrary arguments. These
arguments are to be provided by a data provider
method.

{
}
/**
* @test
*/
{
}

/**
* @dataProvider gimmeAnProvider
*/
public function testGimmeAn($parameter, $expectedResponse)
{
$this->assertThat($cheerleader->gimmeAn($parameter),
$this->equalTo($expectedResponse));
}

public function gimmeAnProvider()
{
return [
['G', 'G'],
['O', 'O']
];
}
A data provider method must be public and either return an array of
arrays or an object that implements the Iterator interface and yields an
array for each iteration step. For each array that is part of the collection
the test method will be called with the contents of the array as its
arguments.

<snip>
Test 'WavePHPCheerCheerleaderTest::testGimmeAn with data set #0 ('G', 'G')' started
Test 'WavePHPCheerCheerleaderTest::testGimmeAn with data set #0 ('G', 'G')' ended
Test 'WavePHPCheerCheerleaderTest::testGimmeAn with data set #1 ('O', 'O')' started
Test 'WavePHPCheerCheerleaderTest::testGimmeAn with data set #1 ('O', 'O')' ended

Testing PHP Errors
By default, PHPUnit converts PHP errors,
warnings, and notices that are triggered during
the execution of a test to an exception.

use PHPUnitFrameworkErrorError;
use PHPUnitFrameworkErrorNotice;
...
public function testExpectedPHPError()
{
$this->expectException(Error::class);
}
public function testExpectedPHPNotice()
$this->expectException(Notice::class);
}

$ composer test -- --coverage-html coverage --whitelist src

So much more...
•online doc: https://phpunit.de/
•command line options
•test filtering, test coverage options, logging, set php.ini
vals, and more...
•config file (phpunit.xml)
•assertions
•annotations

Brian Johnson
@TheOtherBrianJ
@peakphp | peakphp.org
paylease.com
https://joind.in/talk/2b86d

Unlock The Mystery Of PHPUnit (Wave PHP 2018)

More Related Content

What's hot

Similar to Unlock The Mystery Of PHPUnit (Wave PHP 2018)

Recently uploaded

Unlock The Mystery Of PHPUnit (Wave PHP 2018)