Chapitre 8. Doublure de test

<?php
class UneClasse
{
    public function faireQuelquechose()
    {
        // Faire quelque chose.
    }
}
?>

<?php
require_once 'UneClasse.php';

class BouchonTest extends PHPUnit_Framework_TestCase
{
    public function testBouchon()
    {
        // Créer un bouchon pour la classe UneClasse.
        $bouchon = $this->getMock('UneClasse');

        // Configurer le bouchon.
        $bouchon->expects($this->any())
             ->method('faireQuelquechose')
             ->will($this->returnValue('foo'));

        // Appeler $bouchon->faireQuelquechose() va maintenant retourner
        // 'foo'.
        $this->assertEquals('foo', $bouchon->faireQuelquechose());
    }
}
?>

<?php
require_once 'UneClasse.php';

class BouchonTest extends PHPUnit_Framework_TestCase
{
    public function testBouchon()
    {
        // Créer un bouchon pour la classe UneClasse.
        $bouchon = $this->getMockBuilder('UneClasse')
                     ->disableOriginalConstructor()
                     ->getMock();

        // Configure le bouchon.
        $bouchon->expects($this->any())
             ->method('faireQuelquechose')
             ->will($this->returnValue('foo'));

        // Appeler $bouchon->faireQuelquechose() retournera maintenant
        // 'foo'.
        $this->assertEquals('foo', $bouchon->faireQuelquechose());
    }
}
?>

<?php
require_once 'UneClasse.php';

class BouchonTest extends PHPUnit_Framework_TestCase
{
    public function testReturnArgumentBouchon()
    {
        // Créer un bouchon pour la classe UneClasse.
        $bouchon = $this->getMock('UneClasse');

        // Configurer le bouchon.
        $bouchon->expects($this->any())
             ->method('faireQuelquechose')
             ->will($this->returnArgument(0));

        // $bouchon->faireQuelquechose('foo') retourne 'foo'
        $this->assertEquals('foo', $bouchon->faireQuelquechose('foo'));

        // $bouchon->faireQuelquechose('bar') retourne 'bar'
        $this->assertEquals('bar', $bouchon->faireQuelquechose('bar'));
    }
}
?>

<?php
require_once 'UneClasse.php';

class BouchonTest extends PHPUnit_Framework_TestCase
{
    public function testReturnSelf()
    {
        // Créer un bouchon pour la classe UneClasse.
        $bouchon = $this->getMock('UneClasse');

        // Configurer le bouchon.
        $bouchon->expects($this->any())
             ->method('faireQuelquechose')
             ->will($this->returnSelf());

        // $bouchon->faireQuelquechose() retourne $bouchon
        $this->assertSame($bouchon, $bouchon->faireQuelquechose());
    }
}
?>

<?php
require_once 'UneClasse.php';

class BouchonTest extends PHPUnit_Framework_TestCase
{
    public function testReturnValueMapBouchon()
    {
        // Créer un bouchon pour la classe UneClasse.
        $bouchon = $this->getMock('UneClasse');

        // Créer un mappage des arguments 
        // et des valeurs de retour.
        $map = array(
          array('a', 'b', 'c', 'd'),
          array('e', 'f', 'g', 'h')
        );

        // Configurer le bouchon.
        $bouchon->expects($this->any())
             ->method('faireQuelquechose')
             ->will($this->returnValueMap($map));

        // $bouchon->faireQuelquechose() retourne 
        // différentes valeurs selon les paramètres
        // fournis.
        $this->assertEquals('d', $bouchon->faireQuelquechose('a', 'b', 'c'));
        $this->assertEquals('h', $bouchon->faireQuelquechose('e', 'f', 'g'));
    }
}
?>

<?php
require_once 'UneClasse.php';

class BouchonTest extends PHPUnit_Framework_TestCase
{
    public function testReturnCallbackBouchon()
    {
        // Créer un bouchon pour la classe UneClasse.
        $bouchon = $this->getMock('UneClasse');

        // Configurer le bouchon.
        $bouchon->expects($this->any())
             ->method('faireQuelquechose')
             ->will($this->returnCallback('str_rot13'));

        // $bouchon->faireQuelquechose($argument) retourne str_rot13($argument)
        $this->assertEquals('fbzrguvat', $bouchon->faireQuelquechose('quelqueChose'));
    }
}
?>

<?php
require_once 'UneClasse.php';

class BouchonTest extends PHPUnit_Framework_TestCase
{
    public function testOnConsecutiveCallsBouchon()
    {
        // Créer un bouchon pour la classe UneClasse.
        $bouchon = $this->getMock('UneClasse');

        // Configurer le bouchon.
        $bouchon->expects($this->any())
             ->method('faireQuelquechose')
             ->will($this->onConsecutiveCalls(2, 3, 5, 7));

        // $bouchon->faireQuelquechose() retourne une valeur différente à chaque fois
        $this->assertEquals(2, $bouchon->faireQuelquechose());
        $this->assertEquals(3, $bouchon->faireQuelquechose());
        $this->assertEquals(5, $bouchon->faireQuelquechose());
    }
}
?>

<?php
require_once 'UneClasse.php';

class BouchonTest extends PHPUnit_Framework_TestCase
{
    public function testThrowExceptionBouchon()
    {
        // Créer un bouchon pour la classe UneClasse.
        $bouchon = $this->getMock('UneClasse');

        // Configurer le bouchon.
        $bouchon->expects($this->any())
             ->method('faireQuelquechose')
             ->will($this->throwException(new Exception));

        // $bouchon->faireQuelquechose() lance l'Exception
        $bouchon->faireQuelquechose();
    }
}
?>

<?php
class Sujet
{
    protected $observateurs = array();

    public function attache(Observateur $observateur)
    {
        $this->observateurs[] = $observateur;
    }

    public function faireQuelquechose()
    {
        // Faire quelque chose.
        // ...

        // Avertir les observateurs que nous faisons quelque chose.
        $this->notify('quelque chose');
    }

    public function faireQuelquechoseMal()
    {
        foreach ($this->observateurs as $observateur) {
            $observateur->reportError(42, 'Quelque chose de mal est arrivé', $this);
        }
    }

    protected function notify($paramètre)
    {
        foreach ($this->observateurs as $observateur) {
            $observateur->update($paramètre);
        }
    }

    // Autres méthodes.
}

class Observateur
{
    public function update($paramètre)
    {
        // Faire quelque chose.
    }

    public function reportError($codeErreur, $messageErreur, Sujet $sujet)
    {
        // Faire quelque chose
    }

    // Autres méthodes.
}
?>

<?php

require_once 'Sujet.php';

class SujetTest extends PHPUnit_Framework_TestCase
{
    public function testLesObservateursSontMisAJour()
    {
        // Créer un simulacre pour la classe Observateur,
        // ne touchant que la méthode update().
        $observateur = $this->getMock('Observateur', array('update'));

        // Configurer l'attente de la méthode update()
        // d'être appelée une seule fois et avec la chaîne 'quelquechose'
        // comme paramètre.
        $observateur->expects($this->once())
                 ->method('update')
                 ->with($this->equalTo('quelque chose'));

        // Créer un objet Sujet et y attacher l'objet Observateur
        // simulé
        $sujet = new Sujet;
        $sujet->attache($observateur);

        // Appeler la méthode faireQuelquechose() sur l'objet $sujet
        // que nous attendons voir appeler la méthode update() de l'objet
        // simulé Observateur avec la chaîne 'quelqueChose'.
        $sujet->faireQuelquechose();
    }
}
?>

<?php
class SubjectTest extends PHPUnit_Framework_TestCase
{
    public function testRapportErreur()
    {
        // Créer un simulacre pour la classe Observateur, en simulant
        // la méthode rapportErreur()
        $observateur = $this->getMock('Observateur', array('rapportErreur'));

        $observateur->expects($this->once())
                 ->method('rapportErreur')
                 ->with($this->greaterThan(0),
                        $this->stringContains('Quelquechose'),
                        $this->anything());

        $sujet = new Subject;
        $sujet->attach($observateur);

        // La méthode faireQuelquechoseDeMal doit rapporter une erreur à l'observateur
        // via la méthode rapportErreur()
        $sujet->faireQuelquechoseDeMal();
    }
}
?>

<?php
abstract class ClasseAbstraite
{
    public function methodeConcrete()
    {
        return $this->methodeAbstraite();
    }

    public abstract function methodeAbstraite();
}

class ClasseAbstraiteTest extends PHPUnit_Framework_TestCase
{
    public function testConcreteMethod()
    {
        $stub = $this->getMockForAbstractClass('ClasseAbstraite');
        $stub->expects($this->any())
             ->method('methodeAbstraite')
             ->will($this->returnValue(TRUE));

        $this->assertTrue($stub->methodeConcrete());
    }
}
?>

<?php
class GoogleTest extends PHPUnit_Framework_TestCase
{
    public function testSearch()
    {
        $googleSearch = $this->getMockFromWsdl(
          'GoogleSearch.wsdl', 'GoogleSearch'
        );

        $directoryCategory = new StdClass;
        $directoryCategory->fullViewableName = '';
        $directoryCategory->specialEncoding = '';

        $element = new StdClass;
        $element->summary = '';
        $element->URL = 'http://www.phpunit.de/';
        $element->snippet = '...';
        $element->title = '<b>PHPUnit</b>';
        $element->cachedSize = '11k';
        $element->relatedInformationPresent = TRUE;
        $element->hostName = 'www.phpunit.de';
        $element->directoryCategory = $directoryCategory;
        $element->directoryTitle = '';

        $result = new StdClass;
        $result->documentFiltering = FALSE;
        $result->searchComments = '';
        $result->estimatedTotalResultsCount = 3.9000;
        $result->estimateIsExact = FALSE;
        $result->resultElements = array($element);
        $result->searchQuery = 'PHPUnit';
        $result->startIndex = 1;
        $result->endIndex = 1;
        $result->searchTips = '';
        $result->directoryCategories = array();
        $result->searchTime = 0.248822;

        $googleSearch->expects($this->any())
                     ->method('doGoogleSearch')
                     ->will($this->returnValue($result));

        /**
         * $googleSearch->doGoogleSearch() va maintenant retourner un result bouchon et
         * la méthode doGoogleSearch() du web service ne sera pas invoquée.
         */
        $this->assertEquals(
          $result,
          $googleSearch->doGoogleSearch(
            '00000000000000000000000000000000',
            'PHPUnit',
            0,
            1,
            FALSE,
            '',
            FALSE,
            '',
            '',
            ''
          )
        );
    }
}
?>

<?php
class Exemple
{
    protected $id;
    protected $repertoire;

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

    public function setRepertoire($repertoire)
    {
        $this->repertoire = $repertoire . DIRECTORY_SEPARATOR . $this->id;

        if (!file_exists($this->repertoire)) {
            mkdir($this->repertoire, 0700, TRUE);
        }
    }
}?>

<?php
require_once 'Exemple.php';

class ExempleTest extends PHPUnit_Framework_TestCase
{
    protected function setUp()
    {
        if (file_exists(dirname(__FILE__) . '/id')) {
            rmdir(dirname(__FILE__) . '/id');
        }
    }

    public function testReprtoireEstCree()
    {
        $example = new Exemple('id');
        $this->assertFalse(file_exists(dirname(__FILE__) . '/id'));

        $example->setRepertoire(dirname(__FILE__));
        $this->assertTrue(file_exists(dirname(__FILE__) . '/id'));
    }

    protected function tearDown()
    {
        if (file_exists(dirname(__FILE__) . '/id')) {
            rmdir(dirname(__FILE__) . '/id');
        }
    }
}
?>

<?php
require_once 'vfsStream/vfsStream.php';
require_once 'Exemple.php';

class ExempleTest extends PHPUnit_Framework_TestCase
{
    public function setUp()
    {
        vfsStreamWrapper::register();
        vfsStreamWrapper::setRoot(new vfsStreamDirectory('exempleRepertoire'));
    }

    public function testRepertoireEstCree()
    {
        $exemple = new Exemple('id');
        $this->assertFalse(vfsStreamWrapper::getRoot()->hasChild('id'));

        $exemple->setRepertoire(vfsStream::url('exempleRepertoire'));
        $this->assertTrue(vfsStreamWrapper::getRoot()->hasChild('id'));
    }
}
?>