Test-Driven Design and Unit Testing with phpUnit

Jussi Pohjolainen

Tampere University of Applied Sciences » Computer Science

Test-Driven Design

• Basic idea: write tests firsts, then functional code.
• Every functional code should have a corresponding test code
• Benefits of TDD:
  • Good design
  • Honest testing
  • Milestones - when tests run successfully, your code is complete

Testing

• All code should be tested, always
• Testing should be taken to the project in early stages
• Problems with software engineering:
  • It's hard to find a bug in a large program
  • Dependencies between components
  • Systems setups are different
• => Unit Testing is a way to try to solve these problems

Unit Testing

• Unit = small section of code, usually function or class
• Unit testing = testing systematically every unit in your software
• Any time you make a change to your code base, run your tests
• Unit testing doesn't replace application testing

PHPUnit

• For unit testing we can use testing frameworks: PHPUnit (Php), JUnit (Java)
• PHPUnit can be found from http://pear.php.net/PHPUnit
• Installing: pear install phpunit

Writing a test units

• Unit test consists of a collection of test cases
• Test case should check the output of the functional code
• Usually we test functions and methods
• Test case is written in it's own class. This class should be a subclass of PHPUnit_Framework_TestCase:
  • class CalculatorTest extends PHPUnit_Framework_TestCase

Example class

class Calculator
{
    public function sum ($a, $b)
    {
        if( ( is_int($a)    and  is_int($b) )      or
            ( is_float($a)  and  is_float($b) ) )
        {
            return $a + $b;
        }
        else 
        {
            return false;
        }
    }
}

Test class

   class CalculatorTest extends PHPUnit_Framework_TestCase 
    {
        public function __construct ($name) 
        {
            parent::__construct($name);
        }

        function testSum () 
        {
            $calculator = new Calculator();
            $this->assertTrue( $calculator->sum(5, 5)       == 10 ) ;
            $this->assertTrue( $calculator->sum("5", 5)     == false );
            $this->assertTrue( $calculator->sum("moi", "t") == false );
            $this->assertTrue( $calculator->sum(5.5, 5.5)   == 11.0 )
            $this->assertTrue( $calculator->sum(5.5, 5)     == 11.5 );

        }
    }

Running the Test class

• Running 1:
  

  $suite = new PHPUnit_Framework_TestSuite();
  $suite->addTest(new CalculatorTest('testSum'));
  PHPUnit_TextUI_TestRunner::run($suite)
  

• Running 2:
  

  $suite = new PHPUnit_Framework_TestSuite("CalculatorTest");
  PHPUnit_TextUI_TestRunner::run($suite)
  

• Running 3:
  

  > phpunit CalculatorTest.php
         

Writing inline and out-of-line unit tests

• Two choices:
  • 1) Put test-code into same file where the functional code is (Inline)
  • 2) Put test-code into separate file (Outline)
• Inline:
  • + Tests are always visible when your refactor your code
  • + Structure is very clear
  • - You may have to remove test code when shipping your app
  • - Performance issues

Example of a inline-test

class Calculator { ... }

if(realpath($_SERVER['PHP_SELF']) == __FILE__) 
{
    require_once("PHPUnit/Framework/TestSuite.php");
    require_once("PHPUnit/TextUI/TestRunner.php");

    class CalculatorTest extends PHPUnit_Framework_TestCase 
    {
        ...
    }
    $suite = new PHPUnit_Framework_TestSuite();
    $suite->addTest(new CalculatorTest('testSum'));
    PHPUnit_TextUI_TestRunner::run($suite);
 }

Whole example: calculator.php

Running multiple tests

• Testing multiple units is easy:

  • $suite = new PHPUnit_Framework_TestSuite();
    $suite->addTestSuite('CalculatorTest');
    $suite->addTestSuite('directory/OtherTest');
    
    PHPUnit_TextUI_TestRunner::run($suite);
    

Example of Outline-test

• Calculator.php
• CalculatorTest.php
• CalculatorTestRun.php
• TestAll.php - should run all tests.
• Running in command line: phpunit CalculatorTest.php

Creating better error messages

• You can create a better error message by using the assert-method

• function testSum () 
  {
    $calculator = new Calculator();
    $this->assertTrue( $calculator->sum(5,5)        == 10,
                       "sum(5,5) != 10" );
  
    $this->assertTrue( $calculator->sum("5",5)      == false,
                       "sum(\"5\", 5) != false" );
  }
  

• See example: calculator2.php

Assert

• The assertTrue method expects true value on success.
• You can also use other assert-methods:
  • assertEquals(..)
  • assertNotNull(..)
  • assertNull(..)
  • assertSame(..)
  • assertFalse(..)
  • assertRegExp(..)
• See example: calculator3.php

Repetitive tests

• Many tests are repetitive. For example Calculator class could have a few number of methods. When testing these methods, you have to always create instance of Calculator class.
• Solution: use setUp() and tearDown() methods
• setUp() is called before the tests and tearDown() after the tests
• See example: calculator4.php