Development Workshops

PHP Unit Testing @ Tagged 

“We enable anyone to meet and socialize with new people”

2011.10.26Erik Johannessen

PHP Unit Testing @ Tagged

Goal:- Gain familiarity with unit tests and unit testing here at Tagged- Gain familiarity with the testing framework currently in place- Learn to write (better) unit tests

Agenda

• General Unit Testing Attributes• Unit Tests in PHP @ Tagged

o Running Testso Assertionso Mocking Objectso Mocking Static Functionso Getting Real Objects

• Regression Testing with Hudson• A practical demo : Wink!• Effective Testing Strategies• Test-Driven Development

What is a Unit Test?

- A unit is the smallest testable part of an application. - Exercises a particular piece of code in isolation, ensuring correctness. - Good for regression testing.  Once we have a test that passes, the test should continue to pass on each successive change to the codebase.

Unit Test Attributes

- Each test should be independent of all other tests (including itself!) - The number of times/order in which they're run shouldn't matter. - This is achieved by beginning with a controlled state, and feeding in controlled inputs. - Controlled inputs should produce expected outputs. - State should change in predictable ways, given inputs. - External dependencies (DB, Cache, other external services) should be mocked out.

Unit Tests in PHP- All tests are found in the directory /cooltest/unit/tests/ - Each test file should end in *Test.php - Each test should be a public methods with name prefixed with “test”. - Tests are run in an unspecified order; do not depend on one test running before another. - Before each test is run, the setUp() method is invoked, if it exists. - After each test is run, the tearDown() method is invoked, if it exists.

myclassTest.php

Tests shared/class/tag/myclass.phpclass tag_myclassTest extends test_base {    public function setUp() {        parent::setUp();        // do setup stuff before every test    }        public function testMethodA() {        // call method a() on an instance of myclass        // assert some conditions    }        public function testMethodB() {        // call method b() on an instance of myclass        // assert some conditions    }

    public function tearDown() {        parent::tearDown();        // perform cleanup        // in most cases, don't need this, as test_base::tearDown() will        // take care of almost everything for you    }}

Running the tests using PHPUnit

> pwd/home/html/cooltest/unit/tests/shared/class/tag

# run all tests in this directory> phpunit .

# run all tests in myclassTest.php> phpunit myclassTest.php

# run testMethodA> phpunit –-filter testMethodA myclassTest.php

# run all tests that begin with testMethod*> phpunit –-filter testMethod myclassTest.php

Assertions

Testing framework comes with several built-in assertion functions.

If the optional $msgOnFailure is given, it will be included in the output when the test fails.  I highly recommend including descriptive failure messages, as that not only helps the debugger find out what failed, but also what the intention of the test author was.

public function test() {    $this->assertTrue($value, $msgOnFailure = '');    $this->assertFalse($value, $msgOnFailure = '');    $this->assertEquals($expected, $actual, $msgOnFailure = '');    $this->assertNotEquals($expected, $actual, $msgOnFailure = '');    $this->assertType($expected, $actual, $msgOnFailure = '');    $this->assertGreaterThan($expected, $actual, $msgOnFailure = '');}

Mocking Objects in PHP

- Almost all classes in our codebase have dependencies on other classes. - To eliminate those dependencies as a variable in a unit test, we replace those objects that we would normally fetch from the global loader ($_TAG) with mock objects. - Mock objects are just like the real objects they substitute for, except that we override the values of methods, properties and constants of that object to produce dependable, controlled results when the object is invoked.

Mocking Objects in PHP// in the API filepublic function getGoldBalance($params) {    $userId = $this->_requestUserId(true);    // here, $_TAG->gold[$userId] returns our mock object    $userGold = $_TAG->gold[$userId]->getGoldBalance(true);    $results = array(        'gold_bal' => $userGold,        'gold_bal_string' => number_format($userGold, 0)    );    return $this->generateResult($results);}// in the test file$userId = 9000;$balance = 500;$goldGlobalMock = GlobalMockFactory::getGlobalMock('tag_user_gold', 'gold', $userId);$goldGlobalMock->override_method('getGoldBalance', function($getFromDB=false) use ($balance) {    return $balance;});$goldGlobalMock->mock();

$result = tag_api::call('tagged.gold.getBalance', array(), $userId);

$this->assertEquals($balance, $result['gold_bal'], 'Wrong balance returned!');

Mocking Objects in PHP

$globalMock->override_property('myProp', 1000);$mockObj = $globalMock->mock();// prints 1000echo $mockObj->myProp;

$globalMock->override_constant('MY_CONST', 5);$mockObj = $globalMock->mock();// prints 5echo $mockObj::MY_CONST;

 Can also be used to add methods/properties to objects that don't already have them.

Mocking Static Functions in PHP

$commMock = new StaticMock('tag_privacy', 'can_communicate', true);

$userId = 9000;$otherUserId = 9001;// always returns true!$canCommunicate = tag_privacy::can_communicate($userId, $otherUserId);$this->assertTrue($canCommunicate, “Users can't communicate!”);

// a more dynamic example$goodUserId = 9002$badUserId = 9003;$boxedMock = new StaticMock('tag_user_auth', 'is_boxed_user', function ($userId) use ($badUserId) {    return $userId == $badUserId;});

$this->assertTrue(tag_user_auth::is_boxed_user($badUserId), 'Bad user not boxed!');$this->assertFalse(tag_user_auth::is_boxed_user($goodUserId), 'Good user boxed!');

Testing for Errors

- Not found often in our codebase, but we can test for and trap specific errors within the PHP. - Specify file and error level, then verify number of errors trapped by testErrorHandler.

$errorHandler = new testErrorHandler();$errorHandler->suppressError('shared/class/tag/user/invites.php', E_USER_NOTICE);

$result = $invites->removeOutgoingInvite($connId);

$this->assertEquals(1, $errorHandler->numErrorsSuppressed(), 'Notice not triggered.');$errorHandler->restorePreviousHandler();

Getting Real Objects in PHP

- Most times, we don't want a mock object for the object under test –- we want the real thing.- However, if we just go and get an object via our global system (i.e.  $_TAG->contacts[$userId]), our test will be dependent on whatever object might be found in memcache.- test_base::get_global_object() solves this by figuring out how to create an object directly, and returning a new one, with a mock loader to avoid touching memcache.

// assume this is a test class that inherits from test_base$userId = 9000;// returns a fresh instance of tag_user_contacts// but with a mock loader// normally accessed like $_TAG->contacts[$userId];$userContacts = self::get_global_object('contacts', $userId);

Framework LimitationsCan't pass use variables by reference to overridden methods.

Can't mock static functions that contain static variables.public static function is_school_supported($userId) {    static $country_supported = array('US', 'CA', 'GB', 'IE', 'NZ', 'AU');    $userObj = $_TAG->user[$userId];    if (empty($userObj) || !$userObj->isValidUser()) return false;    $countryCode = 'US';    $address = $userObj->getAddressObj();    if ($address){        $countryCode = $address->getCountryCode();    }    if (in_array($countryCode, $country_supported))        return true;    else        return false;}

$balance = 5000;$mock->override_method('credit', function($amt) use (&$balance) {    $balance += $amt;    return $balance;});

Hudson

- Our unit testing suite (currently >900 tests) is also very useful for regression testing. - Our continuous integration system, Hudson, runs every test after every SVN submission to web. - If any test fails, our codebase has regressed, and the commit author that broke the build is notified (as is proddev@tagged.com, so it's nice and public). - If you break the build, please respond promptly to fix it; we can't ship with a broken build.

http://webbuild.tag-dev.com/hudson/job/Web/

Let's do an example - Wink!class tag_apps_winkTest extends test_base {    public function setUp() {        parent::setUp();        $this->_userId = 9000;                $winkDaoGlobalMock = GlobalMockFactory::getGlobalMock('tag_dao_wink', 'dao', array('wink', $this->_userId));        $winkDaoGlobalMock->override_method('getWinks', function() {            return array(                0 => array(                    'other_user_id' => 9001,                    'time' => $_SERVER['REQUEST_TIME'],                    'type'  => 'R',                    'is_viewed' => 'N'                ),            );        });        $winkDaoGlobalMock->mock();        $this->_mockUser(9001);        $this->_wink = self::get_global_object('wink', $this->_userId);    }        public function testCountWink() {        $numWinks = $this->_wink->countWinks();        $this->assertEquals(1, $numWinks, "wrong number of winks!");    }}

Other Testing Strategies – Corner Cases

Call functions under test with corner case inputs    - 0    - null    - ''           (an empty string)    - array()      (an empty array)    - Big numbers  (both positive & negative)    - Long strings    - Other large inputs (esp. where constants like MAX_SIZE are defined)

Other Testing Strategies – Negative Testing

Bad/illegal inputs should throw exceptions, raise errors, or otherwise alert the programmer of bad input

// test that an exception is throwntry {    $result = tag_api::call('tagged.apps.gifts.getGiftRecipients', array('goldTxnId' => 0), $this->_userId);    $this->fail('getGiftRecipients did not throw an exception for invalid id');} catch (Exception $e) {    $this->assertEquals(107, $e->code(), 'Wrong exception code');}

// test that an error is triggered$errorHandler = new testErrorHandler();$errorHandler->suppressError('shared/class/tag/user/invites.php', E_USER_NOTICE);

$result = $invites->removeOutgoingInvite($connectionId);

$this->assertEquals(1,$errorHandler->numErrorsSuppressed(),'Notice not triggered');$errorHandler->restorePreviousHandler();

Other Testing Strategies – Differing Initial States

Set up tests to begin with differing initial states

// test that you can get a friend id from a user's friend listpublic function testGetRandomFriend() {    $friendList = array(34, 55, 88);    $friends = new Friends($friendList);    $randomFriend = $friends->getRandomFriend();    $this->assertTrue(in_array($randomFriend, $friendList), 'Got non-friend!');}

// test that you can't get a friend id when a user has no friendspublic function testGetRandomFriendWithNoFriends() {    $friendList = array();    $friends = new Friends($friendList);    $randomFriend = $friends->getRandomFriend();    $this->assertTrue(is_null($randomFriend), 'Got a friend from user with no friends!');}

Other Testing Strategies Tests should be as granular as possible -- each test should be its own function.

// BAD$this->assertEquals(10, $objUnderTest->resultsPerPage());

// BETTER$this->assertEquals($objUnderTest::RESULTS_PER_PAGE, $objUnderTest->resultsPerPage());

Test assertions should be implementation-agnostic.  Changing the internal implementation of a method should not break the test.

public function testAddAndRemoveFriend() {    $friendId = 54;     $friends = new Friends();    $friends->add($friendId);     $this->assertTrue($friends->isFriend($friendId));    // you should stop here, below this should be a separate test     $friends->remove($friendId);    $this->assertFalse($friends->isFriend($friendId));}

Test-Driven Development

Stub out the methods for your class first, then write unit tests for that class.- At first, all tests will fail.- Write your class methods.- When all tests pass, you're done! Also good for bug fixes. If you find a bug caused by unintended code behaviour,  write a test that asserts the correct behaviour.  When the test passes, the bug is fixed!

Writing Testable CodeTesting a unit code involves sealing off the “seams” with mock objects and canned results. Introduce seams in your code to help with testing:- Modularize methods- Use setters/getters- Pass objects to a class' constructor The following common coding practices make testing very difficult:- Creating monolithic functions that handle more than one responsibility- Using global variables- Creating objects within methods instead of asking for them

tag_email::send(new tag_email_options($userId, 'cafe_convertgold', $data));