TEST YOUR LARAVEL 4
APPLICATIONS
Presented by Milan Popovi / @komita1981
ME
PHP developer
7 years in PHP development
Work for 12 Mnkys
I like to learn and share knowledge
Active member of PHP Srbija
YOU?
Who are you?
What's your experience in programming?
What's your experience in testing?
What are your expectations?
WHAT IS TESTING?
Testing is the activity of finding out whether a piece of code
produces the intended behavior
WHAT DO PEOPLE THINK ABOUT
TESTING?
Who has time to write tests???
Testing is hard
Steep learning curve
Time consuming
Dont make anybody any money.
Prove you've done your work
Help you check much faster if you're work is done
Protect you from breaking things - regression bugs
Help you make better code design - easier to maintain
Let you apply changes with less worries - refactoring will
improve things without breaking anything
Ensures stable, long lasting application
Enhance security
Free documentation
IBM & Microsoft - TDD - 20-40% longer to complete but 4090% fewer bugs in production
By 2022 it will be not be possible to get a professional
programming job if you do not practice TDD routinely
TEST TYPES
Acceptance (end-to-end)
Test as if end user would use the whole system/feature
Integration
Test how different parts of system work together
Unit
Test single unit of code - mock all dependencies
WHAT WE NEED TO DEFINE
What is unit testing?
What is to be tested?
What does not need to be tested?
Unit testing FIRST principles
Writing unit testing before or after code
WHAT IS UNIT TESTING?
A software testing method to test individual unit of source
code - a method in class or a piece of code
What is to be tested?
EVERYTHING
WHAT DOES NOT NEED TO BE
TESTED?
Getters/Setters
Framework
Third party packages
UNIT TESTING FIRST PRINCIPLES
Fast - Be fast or be dead
Isolation - Run without dependency
Repeatable - Should be idempotent
Self-verifyng - Just pass or fail
Timely - Code change requires new test
WRITE UNIT TESTS BEFORE OR
AFTER CODE?
After - You test what you code - Test Last - DDT
Before - You code what you test - Test First - TDD
PHPUNIT
Member of xUnit family
Created by Sebastian Bergmann
Integrated/Supported by all modern frameworks
Integrated in most IDE (PHPStorm, Netbeans, Eclipse, Zend
Studio)
Written for PHP 5.x
Install using composer or phar
"require-dev": {
"phpunit/phpunit": "4.2.*"
},
PEAR install - not supported from 1.1.2015
PHPUNIT'S TEST GOALS
Easy to learn to write
Easy to write
Easy to read
Easy to execute
Quick to execute
Isolated
Composable
TEST CONFIG & STRUCTURE
Configured in phpunit.xml file
The tests for a class Class go into a class ClassTest
ClassTest inherits (most of the time) from
PHPUnit_Framework_TestCase
The tests are public methods that are named test*
Inside the test methods assertion methods are used - assert*
<phpunit backupglobals="false" backupstaticattributes="false" bootstrap="boot
<testsuites>
<testsuite name="Libraries">
<directory>./app/tests/Unit/Libraries/</directory>
</testsuite>
<testsuite name="Unit">
<directory>./app/tests/Unit/</directory>
</testsuite>
<testsuite name="Integration">
<directory>./app/tests/Integration/</directory>
</testsuite>
<testsuite name="RunAll">
<directory>./app/tests/</directory>
</testsuite>
</testsuites>
</phpunit>
ASSERTION METHODS EXAMPLES
AssertTrue - Check the input to verify it equals true
AssertFalse - Check the input to verify it equals false
AssertEquals - Check the result against another input for a
match
AssertContains - Check that the input contains a certain
value
Many more asserts - official documentation...
class Calculator
{
public function add($a, $b)
{
return $a + $b;
}
}
class CalculatorTest extends PHPUnit_Framework_TestCase
{
protected $calculator;
public function setUp()
{
$this->calculator = new Calculator();
parent::setUp();
}
public function testSuccessfulAdd()
{
$this->assertEquals(9, $this->calculator->add(3, 6));
}
public function tearDown()
{
parent::tearDown();
}
}
/**
* @dataProvider getSuccessfulAddData
*/
public function testSuccessfulAdd($data)
{
$this->assertEquals($data['result'],
$this->calculator->add($data['a'], $data['b']));
}
public function getSuccessfulAddData()
{
return array(
array(
array('a' => 1, 'b' => 2, 'result' => 3),
array('a' => 2, 'b' => 1, 'result' => 3),
array('a' => 0, 'b' => 1, 'result' => 1),
array('a' => 1, 'b' => 0, 'result' => 1),
)
);
}
/**
* @dataProvider getUnsuccessfulAddData
*/
public function testUnsuccessfulAdd($data)
{
$this->setExpectedException($data['expectedException']);
$this->calculator->add($data['a'], $data['b']);
}
public function getUnsuccessfulAddData()
{
return array(
array(
array('a' => 'string', 'b' => 2, 'result' => 2, 'expectedExceptio
array('a' => 2, 'b' => 'string', 'expectedException' => 'Exceptio
array('a' => 'string', 'b' => 'string', 'expectedException' => 'E
)
);
}
class Calculator
{
public function add($a, $b)
{
if (! is_int($a) or ! is_int($b)){
throw new Exception('Only integers allowed');
}
return $a + $b;
}
}
class ScientificCalculator
{
public function complex($a)
{
return "Too complex $a";
}
}
class Calculator
{
public function complex($a)
{
$scientificCalculator = new ScientificCalculator();
return $scientificCalculator->complex($a);
}
}
class ScientificCalculator
{
public function complex($a)
{
return "Too complex $a";
}
}
class Calculator
{
protected $scientificCalculator;
public function __construct(ScientificCalculator $scientificCalculator)
{
$this->scientificCalculator = $scientificCalculator;
}
public function complex($a)
{
return $this->scientificCalculator->complex($a);
}
}
class CalculatorTest extends PHPUnit_Framework_TestCase
{
protected $calculator;
public function setUp()
{
$this->calculator = new Calculator(new ScientificCalculator());
parent::setUp();
}
...
class CalculatorTest extends PHPUnit_Framework_TestCase
{
protected $calculator;
protected $scientificCalculatorMock;
public function setUp()
{
$this->scientificCalculatorMock = $this->getMockBuilder('ScientificCa
$this->calculator = new Calculator($this->scientificCalculatorMock);
parent::setUp();
}
public function testSuccessfulComplex()
{
$a = 1;
$returnValue = "Something";
$this->scientificCalculatorMock
->expects($this->once())
->method('complex')
->with($this->equalTo($a))
MOCKERY
Simple, powerful framework for creating Mock Objects
Install through Composer
"require-dev": {
"mockery/mockery": "0.9.*@dev"
},
MOCK METHOD
$mockedObject = Mockery::mock('\Show\ExampleClass');
Partial mocks
$mockedObject = Mockery::mock('\Show\ExampleClass[save, send]');
$mockedObject = Mockery::mock('\Show\ExampleClass')->makePartial();
SHOULD RECEIVE
$this->mock->shouldReceive('methodName');
ONCE, TWICE, TIMES(N), NEVER
$this->mock
->shouldReceive('methodName')
->once();
$this->mock
->shouldReceive('methodName')
->never();
WITH
$this->mock
->shouldReceive('methodName')
->once()
->with($params);
AND RETURN
$mockedObject = Mockery::mock('\Show\ExampleClass');
$mockedObject
->shouldReceive('all')
->once()
->with($param)
->andReturn('foo');
TESTING IN LARAVEL 4
Built with unit testing in mind
Utilizes the Symfony HttpKernel, DomCrawler, and
BrowserKit components
All tests inherit app/tests/TestCase.php file
class TestCase extends Illuminate\Foundation\Testing\TestCase {
/**
* Creates the application.
*
* @return \Symfony\Component\HttpKernel\HttpKernelInterface
*/
public function createApplication()
{
$unitTesting = true;
$testEnvironment = 'testing';
return require __DIR__.'/../../bootstrap/start.php';
}
}
abstract class TestCase extends \PHPUnit_Framework_TestCase {
use ApplicationTrait, AssertionsTrait;
...
ApplicationTrait
cal(...) - Call the given URI and return the Response
action(...) - Call a controller action and return the Response
route(...) - Call a named route and return the Response
seed($class = 'DatabaseSeeder') - Seed a given database
connection
be(...) - Set the currently logged in user for the application
AssertionsTrait
assertResponseOk() - Assert that the client response has an
OK status code
assertResponseStatus($code) - Assert that the client
response has a given code
assertViewHas($key, $value = null) - Assert that the response
view has a given piece of bound data
assertRedirectedTo($uri, $with = array()) - Assert whether
the client was redirected to a given URI
MOCKING FACADES
public function crypt()
{
Crypt::setKey('someKey');
}
public function testCrypt()
{
Crypt::shouldReceive('setKey')->once()->with($key);
}
shouldReceive method called on the facade return an
instance of a Mockery mock
public function __construct(User $userModel)
{
$this->userModel = $userModel;
}
public function store()
{
$userData = Input::all();
if(! $this->userModel->validate($userData)){
throw new StoreResourceFailedException($this->userModel->getErrors())
}
try{
$userModel = $this->userModel->create($userData);
if (! $userModel instanceof User){
throw new StoreResourceFailedException();
}
return $userModel;
}catch (Exception $e){
throw new StoreResourceFailedException('Failed');
use Mockery as m;
class UserControllerTest extends TestCase
{
public function setUp()
{
parent::setUp();
$this->userModel = m::mock('Eloquent', 'Api\Models\User');
}
public function tearDown()
{
parent::tearDown();
m::close();
}
...
public function testSuccessfulStore()
{
$data = ['first_name' => 'John', 'last_name' => 'Doe', 'email' => 'john@j
$this->userModel
->shouldReceive('validate')
->once()
->with($data)
->andReturn(true);
$mockedUserModel = m::mock('Eloquent', 'Api\Models\User');
$this->userModel
->shouldReceive('create')
->once()
->andReturn($mockedUserModel);
$this->app->instance('Models\User', $this->userModel);
$response = $this->call('POST', $this->createUri('users'));
$this->assertResponseOk();
public function testUnsuccessfulStore()
{
$data = ['first_name' => 'John', 'last_name' => 'Doe'];
$errorMessage = 'Error';
$this->userModel
->shouldReceive('validate')
->once()
->with($data)
->andReturn(false);
$this->userModel
->shouldReceive('getErrors')
->once()
->andReturn($errorMessage);
$this->userModel
->shouldReceive('create')
->never();
$this->app->instance('Models\User', $this->userModel);
PROGRAMMING SINS
New Operators - new ClassName()
Using statics - SomeClass::someMethod()
Endless "anding" - Break SRP
PROGRAMMING SINS
Logic in constructor - only assign variables
Using switch-case often - use design patterns instead
Too many dependencies - max 4 dependencies
ADVICES
Try with writing tests after writing the code
Do not make tests complex
Do not duplicate test code
Treat test like your code
When you get confidence try to write tests before the code
ADVICES
Run tests often - after every change and before any commit
Test before refactoring
Use continuous integration server
http://images.sodahead.com/polls/001599249/4445136897_Q
https://lh4.ggpht.com/W3DVtNTVIAvZfJ99kDT2hP5cxklxZfLMG
http://www.redbubble.com/people/fitbys/works/10613559-re
http://www.slideshare.net/damiansromek/php-tests-tips
http://www.slideshare.net/ChonlasithJucksripor/unit-test-39
http://blog.typemock.com/2009/03/the-cost-of-test-driven-de
http://lh3.ggpht.com/-X8LPVvE5BYE/UHaLknLmMmI/AAAAAA
http://lh5.ggpht.com/-jDpF-eS-6TE/UQo_mozEkkI/AAAAAAAA
imgmax=800
THANK YOU
QUESTIONS?
