Unit Testing Made Simple

bool underAttack = false;
underAttack = detectEvents();
//do some other stuff
if(underAttack = true) {
launchNuclearMissles();
} else {
alert(“false alarm!”);
}

Why Test?
• Sometimes we make mistakes in our code

Why Test?
• Sometimes we forget to finish parts of our
code because we get interrupted, and then
we never come back and finish

Why Test?
• Sometimes we forget to finish parts of our
code because we get interrupted, and then
we never come back and finish
• //TODO: add another reason

Testing vs. Debugging
Testing: detecting errors
Debugging: diagnose and repair detected
errors

Types of testing
regression tests
functional tests
acceptance tests
integration tests
load/stress tests
security tests
unit tests

Unit Testing
Unit Testing: the execution of [code] that has
been written by a single programmer or team
of programmers, which is tested in isolation
from the more complete system.
- Code Complete 2nd ed.

How we end up testing stuff
class User{
public function __construct($userName){
//do stuff
}
public function checkPassword($password){
//do stuff
}
public function setLogIn(){
//do stuff
}

$u = new User(‘davidhaskins@ieee.org’);
//test to fail
$u->checkPassword(‘bad_password’);
//test to succeed
$u->checkPassword(‘s3kr3t_p@sswd’);

$u = new User(‘davidhaskins@ieee.org’);
//test to fail
if($u->checkPassword(‘bad_password’) === false){
echo ‘successfully rejected’;
}
//test to succeed
if($u->checkPassword(‘s3kr3t_p@sswd’) === true){
echo ‘successfully accepted’;
}

What do we do with this
information?

information?
We delete it!!!

information?
We delete it!!!
(or, at best, we comment it out)

PHPUnit
• a framework for unit testing PHP
• excellent documentation at http://phpunit.de
• easy to setup

Installing PHPUnit
• Pear
• Composer (preferred method)

Installing PHPUnit
pear config-set audto_discover 1
pear install pear.phpunit.de/PHPUnit

Installing PHPUnit
Composer can be used to download and install
“dependencies”(other libraries and such).
download composer:
curl -s http://getcomposer.org/installer | php

Installing PHPUnit
create a file named composer.json containing:
{
“require-dev”: {
“phpunit/phpunit”: “3.7.4”
}
}

Installing PHPUnit
run:
./composer.phar update
(a .phar file is a “PHP Archive” file.)

Installing PHPUnit
create a file named phpunit.xml containing:
<?xml version="1.0" encoding="UTF-8"?><phpunit
colors="true">
<testsuites>
<testsuite name="Application Test Suite">
<directory>./phpUnitTutorial/Test/</directory>
</testsuite>
</testsuites></phpunit>

Running PHPUnit
./vendor/bin/phpunit

class myTest extends PHPUnitTest_Framework_TestCase {
}

public function someSimpleTest(){
}
}

$myVar = true;
$this->assertTrue($myVar);
}
}

$myVar = true;
$this->assertTrue($myVar);
}
public function anotherSimpleTest(){
$myVar = false;
$this->assertTrue($myvar); //fails
}

PHPUnit offers:
assertTrue();
assertFalse();
assertEquals();
assertArrayHasKey();
assertStringEndsWith();
...and many more!

The next few examples are
from Juan Treminio’s tutorial:
https://jtreminio.com/2013/03

The phrase “slugify” means to change
something like this:
The quick BROWN fox @ noon
into this:
the-quick-brown-fox-noon

<?phpclass URL
{
public function sluggify($string, $separator = '-', $maxLength = 96)
{
$title = iconv('UTF-8', 'ASCII//TRANSLIT', $string);
$title = preg_replace("%[^-/+|w ]%", '', $title);
$title = strtolower(trim(substr($title, 0, $maxLength), '-'));
$title = preg_replace("/[/_|+ -]+/", $separator, $title);
return $title;
}
}

namespace phpUnitTutorialTest;use phpUnitTutorialURL;class
URLTest extends PHPUnit_Framework_TestCase
{
}

{
public function testSluggifyReturnsSluggifiedString()
{
$originalString = 'This string will be sluggified';
$expectedResult = 'this-string-will-be-sluggified';
}
}

{
{
$url = new URL();
$result = $url->sluggify($originalString);
}
}

{
{
$url = new URL();
$this->assertEquals($expectedResult, $result);
}
}

Other tests we can add
public function testSluggifyReturnsExpectedForStringsContainingNumbers() {
$originalString = 'This1 string2 will3 be 44 sluggified10';
$expectedResult = 'this1-string2-will3-be-44-sluggified10';
$url = new URL();
}

public function testSluggifyReturnsExpectedForStringsContainingSpecialCharacters() {
$originalString = 'This! @string#$ %$will ()be "sluggified';
$url = new URL();
}

public function testSluggifyReturnsExpectedForStringsContainingNonEnglishCharacters() {
$originalString = "Tänk efter nu – förr'n vi föser dig bort";
$expectedResult = 'tank-efter-nu-forrn-vi-foser-dig-bort';
$url = new URL();
}

public function testSluggifyReturnsExpectedForEmptyStrings() {
$originalString = '';
$expectedResult = '';
$url = new URL();
}

That’s neat, but it seems we are writing the
same code over and over.

We can use the “dataProvider annotation.”

We can use the “dataProvider annotation.”
Annotations are described in docblocks
(comments) of methods.

class URLTest extends PHPUnit_Framework_TestCase
{
/**
* @dataProvider providerTestSluggifyReturnsSluggifiedString
*/
public function testSluggifyReturnsSluggifiedString($originalString, $expectedResult)
{
//do our assertion here
}
public function providerTestSluggifyReturnsSluggifiedString()
{
//return an array of arrays which contains our data
}
}

class URLTest extends PHPUnit_Framework_TestCase
{
/**
* @dataProvider providerTestSluggifyReturnsSluggifiedString
*/
public function testSluggifyReturnsSluggifiedString($originalString, $expectedResult)
{
$url = new URL();
}
public function providerTestSluggifyReturnsSluggifiedString()
{
return array(
array('This string will be sluggified', 'this-string-will-be-sluggified'),
array('THIS STRING WILL BE SLUGGIFIED', 'this-string-will-be-sluggified'),
array('This1 string2 will3 be 44 sluggified10', 'this1-string2-will3-be-44-sluggified10'),
array('This! @string#$ %$will ()be "sluggified', 'this-string-will-be-sluggified'),
array("Tänk efter nu – förr'n vi föser dig bort", 'tank-efter-nu-forrn-vi-foser-dig-bort'),
array('', ''),
);
}
}

I haven’t been honest here
URL::Sluggify() was deceptively simple it; had
no dependencies.

When you're doing testing like this, you're focusing on one
element of the software at a time -hence the common
term unit testing. The problem is that to make a single
unit work, you often need other units...
- Martin Fowler
http://martinfowler.com/articles/mocksArentStubs.html

What happens when we depend on other stuff
(databases, other objects, etc.)?

setUp() and tearDown()
class FoobarTest extends PHPUnit_Framework_Testcase{
public function setUp(){
//do things before these tests run
// copy a production database into a test db
// instantiate objects
// define constants
}
public function tearDown(){
//do things after the tests run
// delete test db
}
}

But we still have problems
Databases can go down which could cause our
tests to fail.
Instantiating objects can be slow which could
make testing take forever (we want to be able
to test often).
...and we want isolation!

“Mocks and stubs” to the rescue!

We may have to jump through some hoops, but
we’ll get there!

Stubs
//a method with stuff (implementation details irrelevant)
public function doSomething($param1, $param2){
mysql_connect("your.hostaddress.com", $param1, $param2) or
die(mysql_error());
mysql_select_db("address") or die(mysql_error());
!(isset($pagenum)) ? $pagenum = 1 : $pagenum=0;
$data = mysql_query("SELECT * FROM topsites") or die(mysql_error());
$rows = mysql_num_rows($data);
$page_rows = 4;
$last = ceil($rows/$page_rows);
$pagenum < 1 ? $pagenum=1 : $pagenum = $last;
$max = 'limit ' .($pagenum - 1) * $page_rows .',' .$page_rows;
return $max;
}

Stubs
//a method with stuff (implementation details irrelevant)
public function StubDoSomething($param1, $param2){
return null;
}

Mock objects
Mock Objects: objects pre-programmed with
expectations which form a specification of the
calls they are expected to receive.

Mock objects
Let’s look at an example.

Mock objects
class User{
public function __construct($id){
$this-> id = $id;
}
public function verifyUser(){
//validate against an LDAP server
}
public function getName(){
//get user name from the LDAP server
}

Mock objects
class ForumPost{
public function deletePostsByUser($user){
$user_id = $user->getUserID();
$query = “delete from posts where userID = ? ”;
….//do stuff
}
//...other methods
}

require_once ‘User.php’;
require_once ‘ForumPost.php’;
class testForum extends PHPUnitTest_Framework_TestCase {
public function testUserPostDelete(){
$user = new User(7);
$userName = $user->getName();
$post = new ForumPost();
$rowsDeleted = $post->deletePostsByUser($user);
$message = “$rowsDeleted posts removed for $userName”;
$expectedMessage = “5 posts removed for David Haskins”;
$this->assertEquals($message,$expectedMessage);
}
}

$user = new User(7); //fails when LDAP server is down!
}
}

$user = $this->getMockBuilder(‘User’)
->setConstructorArgs(array(7))
->getMock();
$user->expects($this->once())
->method(‘getName’)
->will($this->returnValue(‘David Haskins’);
}

TDD
Test Driven Development is a method of
developing code by writing the tests FIRST!

Git and unit tests
You can add client or server side “hooks” to git
to run your unit tests and reject submissions
that fail the unit tests.
http://www.masnun.com/2012/03/18/running-phpunit-on-git-hook.html

Coverage report tool
./vendor/bin/phpunit --coverage-html coverage

Other Texts to Consider
https://jtreminio.com/2013/03
http://phpunit.de

Unit Testing Made Simple

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (6)

Similaire à Unit Testing Made Simple

Similaire à Unit Testing Made Simple (20)

Dernier

Dernier (20)

Unit Testing Made Simple

Notes de l'éditeur