TDD in PHP

PHP

Variablen und Typen

// string
$foo = 'bar';

// integer
$foo = 3;

// float
$foo = 3.4;

// array
$foo = [1,2,3];

// assoziatives array
$foo = ['title' => 'Hello', 'size' => 5];

// array < PHP 5.4
$foo = array(1,2,3);

// object
$foo = new MyClass();

// function
$foo = function() { ... };

Strings

// raw
$msg = 'Hello World\r\nHow are you?';

// escaped
$msg = "Hello World\r\nHow are you?";

// escaped mit Variablen
$msg = "Hello $place"; // $place wird ersetzt

// Heredoc 
$msg = <<<EOM
I behave like a double quoted string,
but I can be formatted a lot better.
Even with $variables to be replaced.
EOM;

// Nowdoc
$msg = <<<'EOM'
I behave like a single quoted string.
I can contain reserved steering chars,
like \r or \t without escaping.
$variables are not interpreted.
EOM;

// concat
$msg = 'Hello ' . 'World';

Conditions

// if
if (1 === '1') {
    return 'should never happen';
}

// if else
if (true === false) {
    return 'you\'re drunk!';
}
else {
    return 'do something!';
}

// elseif
if ($color === 'red') {
    //...
}
elseif ($color === 'green') {
    // ...
}
else {
    // ...
}

Switch

$name = 'Bob';
$greeting = null;

switch ($name) {
    case 'Rita':
        $greeting = 'Mrs';
        break;
    case 'Bob':
        $greeting = 'Mr';
        break;
    default:
        $greeting = 'Hi';
}

echo $greeting . ' ' . $name;

Loops

// while
$i = 0;
while ($i < 10) {
    echo $i;
    $i++;
}

// for 
for ($i = 0; $i < 10; $i++) {
    echo $i;
}

// foreach
$arr = [1,2,3];
foreach ($arr as $item) {
    echo $item;
}

// foreach mit keys
$arr = ['foo' => 'bar', 'bar' => 'baz'];
foreach ($arr as $key => $value) {
    echo $key . ' has value: ' . $value;
}

// do while
$i = 0;
do {
    echo $i++;
while ($i < 10);

Superglobals

// enthält Daten aus dem Query String, 
// z.B. http://my.app?foo=bar&bar=1
$_GET['foo'] === 'bar';
$_GET['bar'] === '1'; // STRING!

// enthält Daten aus dem POST Body
$_POST['foo'] === 'bar';

// enthält Infos über den Server, z.B.
$_SERVER['SERVER_NAME'] === 'localhost';
$_SERVER['REQUEST_METHOD'] === 'POST';
$_SERVER['REMOTE_ADDR'] === '<IP Adresse des Besuchers>';

// enthält Dateien, die über multipart/form-data hochgeladen wurden
$_FILES['avatar'] === [
    'name' => 'my-avatar.png',
    'type' => 'image/png',
    'size' => 1234567,
    'tmp_name' => '/tmp/fcajsda.tmp',
    'error' => UPLOAD_ERR_OK,
];

Superglobals

// kann zum speichern von Session Daten verwendet werden.
// Session Daten werden auf dem Server gespeichert.
session_start();
$_SESSION['username'] = 'mario';

// Umgebungsvariablen nutzen...
$_ENV['USER'] === 'www-data';

// Kekse?!
// Cookies werden zum Client geschickt.
$_COOKIE['username'] = 'mario';

// Enthält Daten aus $_GET, $_POST und $_COOKIE
// $_GET < $_POST < $_COOKIE
$_REQUEST['username'] = 'mario';

Klassen

<?php

class Car {
    private $brand; // Wert => null
    protected $type;
    public $nickname = 'unknown';

    public function __construct($brand) {
        $this->brand = $brand;
    }
    
    public function getBrand() {
        return $this->brand;
    }
}

class Bmw extends Car {
    public function __construct() {
        parent::__contruct('BMW');
    }
}

Interfaces

<?php

interface BrandAware {
    public function getBrand();
}

interface GasFillable {
    public function fillGas($liters);
}

class Car implements BrandAware, GasFillable  {
    // ...
    public function getBrand() {
        return 'VW';
    }

    public function fillGas($liters) {
        // ...
    }
}

Konstanten & Enums

<?php

// global möglich...
const NOT_FOUND = 404;

// besser in Klassen
class Human  {
    const NUM_EYES = 2;
    const NUM_HEART = 1;

    // ...
}

// PHP kennt keine Enums, daher...
interface AppState {
    const ACTIVE = 'active',
    const MAINTENANCE = 'maintenance';
    // ...
}

// Benutzung
$myApp->setState(AppState::ACTIVE); // Parametertyp => string

Namespaces

// src/HsBremen/Car/Factory.php
<?php

namespace HsBremen\Car;

class Factory {
    // do something
}

// src/HsBremen/Toy/Factory.php
<?php 

namespace HsBremen\Toy;

class Factory {
    // do something
}

// Benutzung
$carFactory = new \HsBremen\Car\Factory();
$toyFactory = new \HsBremen\Toy\Factory();

// oder
<?php

use HsBremen\Car\Factory;
use HsBremen\Toy\Factory as ToyFactory;

$carFactory = new Factory();
$toyFactory = new ToyFactory();

Exceptions

<?php

class Calculator {
    // ...
    public function divide($a, $b) {
        if ($b === 0) {
            throw new \Exception("You mustn't divide through zero!");
        }
        return $a / $b;
    }
}

// Benutzung
try {
    $calculator = new Calculator();
    $result = $calculator->divide(2, 0);
    echo $result;
}
catch (\Exception $ex) {
    echo $ex->getMessage();
}

Spezielle Exceptions

<?php

class Calculator {
    // ...
    public function divide($a, $b) {
        if (!in_numeric($a) && !is_numeric($b)) {
            throw new \RuntimeException('Operands must be numbers!');
        }
    
        if ($b === 0) {
            throw new \Exception("You mustn't divide by zero!");
        }
        return $a / $b;
    }
}

// Benutzung
try {
    $calculator = new Calculator();
    $result = $calculator->divide(2, 0);
    echo $result;
}
catch (\RuntimeException $ex) {
    echo 'No numbers, try again!';
}
catch (\Exception $ex) {
    echo $ex->getMessage();
}

Eigene Exceptions

<?php

class DivisionByZeroException extends \Exception {
}

class Calculator {
    // ...
    public function divide($a, $b) {    
        if ($b === 0) {
            throw new DivisionByZeroException();
        }
        return $a / $b;
    }
}

// Benutzung
try {
    $calculator = new Calculator();
    $result = $calculator->divide(2, 0);
    echo $result;
}
catch (DivisionByZeroException $ex) {
    echo "You mustn't divide by zero!";
}

Standard PHP Library (SPL)

DateTime
SplFileInfo
SplStack
SplQueue
SqlFixedArray
Exeptions
- InvalidArgumentException
- RuntimeException
stdClass
uvm.

Typisierung

<?php
// Parameter ohne Typ => mixed
public function add($a, $b);

// parameter mit Typ => strict (wie bei Java oder C#)
public function setCreatedAt(\DateTime $date);

// array ist einziger Core-Datentyp (< PHP7) 
public function setMessages(array $messages);

Typisierung in PHP7

<?php
// Parameter mit scalaren Typen (int, bool, string, float)
public function add(int $a, int $b);
public function setDescription(string $desc);

// Rückgabetyp einer Methode definieren
public function getStartDate() : \DateTime;
public function getCount() : int;

// void gibt es weiterhin nicht
public function doSomething(); // nix ": void"!

Wichtige Core Funktionen

<?php

// zähle etwas
count(['foo']);

// leer? 
empty($foo);

// exisitiert und != null
isset($arr['foo']);

// Wert in array (keys werden ignoriert)
in_array($arr);

// Key in array?
array_key_exists('foo', $arr);

Übersicht Variablenbehandlung | Array Funktionen

Test Driven Development

Test First

erst den Test
dann die Implementierung
schreibe den Test als würde der Code schon existieren

TDD Lifecycle

Rot

Bevor man neuen Produktivcode schreibst, schreibt man einen fehlschlagenden UnitTest der zeigt, was der neue Code leisten soll.

Grün

Unternehme alles Mögliche um den Test grün laufen zu lassen. Wenn du auf Anhieb die komplette Lösung siehst, implementiere sie, wenn nicht, reicht es erstmal den Test grün zu machen.

Refaktor

Überarbeite den Code, Räume auf, finde schöne Möglichkeiten zur Implementierung, Implementiere Logik, etc.

Warum das?

Man schreibt nur, was man benötigt
Das führt zu einfachem Code
Über die Zeit entsteht ein Testgerüst
Man hat Sicherheit

Zwei Daumenregeln

Schreibe keinen neuen Produktivcode, bevor du nicht einen neuen, fehlschlagenden Test hast.
Teste alles, was "möglicherweise" Fehlschlagen könnte.

Dauert das nicht viel zu lange?

Muss ich mich stoisch daran halten?

Testtypen

Unit Tests
Akzeptanz Tests
Performance Tests
uvm.

Warum Unit Tests?

Klein
Schnell
Automatisierbar

PhpUnit

Unit Tests in PHP

wird per Composer installiert

Code

<?php
class Money
{
    private $amount;

    public function __construct($amount)
    {
        $this->amount = $amount;
    }

    public function getAmount()
    {
        return $this->amount;
    }

    public function negate()
    {
        return new Money(-1 * $this->amount);
    }

    // ...
}

Test Code

<?php
class MoneyTest extends PHPUnit_Framework_TestCase
{
    // ...

    public function testCanBeNegated()
    {
        // Arrange
        $a = new Money(1);

        // Act
        $b = $a->negate();

        // Assert
        $this->assertEquals(-1, $b->getAmount());
    }

    // ...
}

Klassenname endet auf *Test
Erbt von PHPUnit_Framework_TestCase
Tests beginnen mit test* oder haben eine @test Annotation
$this->assert* stellt Behauptungen auf.

Tests Ausführen

// eine spezifische Datei
php vendor/bin/phpunit --bootstrap vendor/autoload.php tests/MoneyTest

// unser ganzes Projekt
php vendor/bin/phpunit -c phpunit.xml.dist

Assertions

// Boolsche Aussagen
$this->assertTrue(true);
$this->assertFalse(false);

// Gleichheit (entspricht ===) 
$this->assertEquals(1, 0);
// Gleichheit (an Speicheradresse)
$this->assertSame(new stdClass, new stdClass);

// Leer?
$this->assertEmpty(array('foo'));

// funktioniert mit arrays und strings
$this->assertContains(4, array(1, 2, 3));

// spart die count() Funktion
$this->assertCount(0, array('foo'));

// größer, kleiner
$this->assertGreaterThan(2, 1);
$this->assertGreaterThanOrEqual(2, 1);
$this->assertLessThan(1, 2);
$this->assertLessThanOrEqual(1, 2);

Assertions II

// Key im array?
$this->assertArrayHasKey('foo', array('bar' => 'baz'));

// Typ?
this->assertInstanceOf('RuntimeException', new Exception);

// Null?
$this->assertNull('foo');

Exceptions Testen

<?php

class DivisionByZeroException extends \Exception {}

class Calculator {
    public function divide($a, $b) {    
        if ($b === 0) {
            throw new DivisionByZeroException();
        }
        return $a / $b;
    }
}

class CalculatorTest extends PHPUnit_Framework_TestCase {
    public function testDivisionByZero() {
        // ::class ab PHP 5.5
        $this->expectException(DivisionByZeroException::class); 
        $calc = new Calculator();
        $calc->divide(1,0);
    }

    /**
     * @expectedException DivisionByZeroException
     */
    public function testDivisionByZeroAnnoation() {
        $calc = new Calculator();
        $calc->divide(1,0);
    }
}

SetUp und TearDown

<?php

class CalculatorTest extends PHPUnit_Framework_TestCase {

    /** @var Calculator */
    private $calculator;

    protected function setUp() {
        $this->calculator = new Calculator();
    }

    protected function tearDown() {
        $this->calculator->clearMemory();
    }

    public function testDivision() {
        $this->assertEquals(2, $this->caclulator->divide(10, 5);
    }
}

Data Provider

<?php

class CalculatorTest extends PHPUnit_Framework_TestCase {

    /**
     * @dataProvider provideDataForDivision
     */
    public function testDivision($expected, $a, $b) {
        $this->assertEquals($expected, $this->caclulator->divide($a, $b);
    }

    public function provideDataForDivision() {
        return [
            'first' => [2, 10, 5],
            'next'  => [3, 9, 3],
        ];
    }
}

Mocking

Stubs

<?php

class CalculatorStubTest extends PHPUnit_Framework_TestCase {

    public function testCalculation() {
        $calculator = $this->getMockBuilder(Calculator::class)
                        ->getMock();
        
        $calculator->expects($this->any())
                    ->method('divide')
                    ->willReturn(5);
        
        $this->assertEquals(5, $calculator->divide(1, 2);
    }
}

Dummies
Fake Rückgabewerte

Mocks

<?php

class CalculatorMockTest extends PHPUnit_Framework_TestCase {

    public function testCalculation() {
        $calculator = $this->getMockBuilder(Calculator::class)
                        ->getMock();
        
        $calculator->expects($this->once())
                    ->method('divide')
                    ->with(10, 5)
                    ->willReturn(2);
        
        $this->assertEquals(2, $calculator->divide(10, 5);
    }
}

explizite Methodenaufrufe
explizite Parameterwerte

Abhängigkeiten Mocken

<?php

class CalculationTest extends PHPUnit_Framework_TestCase {

    public function testCalculation() {
        $calculator = $this->getMockBuilder(Calculator::class)
                        ->disableOriginalConstructor()
                        ->getMock();

        $calculator->expects($this->once())
                    ->method('divide')
                    ->with(10, 5)
                    ->willReturn(2);

        $math = new Math($calculator);
        
        $this->assertEquals(2, $math->calc("10 / 5");
    }
}

phpunit.xml

<?xml version="1.0" encoding="UTF-8"?>
<phpunit backupGlobals="false"
         backupStaticAttributes="false"
         colors="false"
         convertErrorsToExceptions="true"
         convertNoticesToExceptions="true"
         convertWarningsToExceptions="true"
         processIsolation="false"
         stopOnFailure="false"
         syntaxCheck="false"
         bootstrap="vendor/autoload.php"
        >

    <testsuites>
        <testsuite name="Web-API Test Suite">
            <directory>./tests</directory>
        </testsuite>
    </testsuites>

    <filter>
        <whitelist>
            <directory>./src</directory>
        </whitelist>
    </filter>

    <logging>
        <log type="coverage-html" target="../coverage" charset="UTF-8" highlight="false" 
            lowUpperBound="35" highLowerBound="70"/>
    </logging>
</phpunit>

TDD in PHP

PHP

Variablen und Typen

Strings

Conditions

Switch

Loops

Superglobals

Superglobals

Klassen

Interfaces

Konstanten & Enums

Namespaces

Exceptions

Spezielle Exceptions

Eigene Exceptions

Standard PHP Library (SPL)

Typisierung

Typisierung in PHP7

Wichtige Core Funktionen

Test Driven Development

Test First

TDD Lifecycle

Rot

Grün

Refaktor

Warum das?

Zwei Daumenregeln

Dauert das nicht viel zu lange?

Muss ich mich stoisch daran halten?

Testtypen

Warum Unit Tests?

PhpUnit

Unit Tests in PHP

wird per Composer installiert

Code

Test Code

Tests Ausführen

Assertions

Assertions II

Exceptions Testen

SetUp und TearDown

Data Provider

Mocking

Stubs

Mocks

Abhängigkeiten Mocken

phpunit.xml

Start Testing!