Mocking dell'oggetto PDO utilizzando PHPUnit

Question

Ho difficoltà a deridere l'oggetto PDO con PHPUnit.

non sembra essere molto informazioni sul web circa il mio problema, ma da quello che ho potuto capire:

1. DOP ha 'finale' __wakeup e metodi __sleep che impediscono che venga serializzato.
2. L'implementazione di oggetti fittizi di PHP serializza l'oggetto a un certo punto.
3. I test delle unità falliscono quindi con un errore PHP generato da PDO quando si verifica ciò.

C'è una funzione destinata a impedire questo comportamento, aggiungendo la seguente riga al test di unità:

class MyTest extends PHPUnit_Framework_TestCase 

{  
    protected $backupGlobals = FALSE; 
    // ... 

} 

Fonte: http://sebastian-bergmann.de/archives/797-Global-Variables-and-PHPUnit.html

questo non è lavoro per me, la mia prova produce ancora un errore.

codice di prova completa:

class MyTest extends PHPUnit_Framework_TestCase 
{ 

    /** 
    * @var MyTest 
    */ 
    private $MyTestr; 

    protected $backupGlobals = FALSE; 

    /** 
    * Prepares the environment before running a test. 
    */ 
    protected function setUp() 
    { 
     parent::setUp(); 

    } 

    /** 
    * Cleans up the environment after running a test. 
    */ 
    protected function tearDown() 
    { 

     parent::tearDown(); 
    } 

    public function __construct() 
    { 

     $this->backupGlobals = false; 
     parent::__construct(); 

    } 


    /** 
    * Tests MyTest->__construct() 
    */ 
    public function test__construct() 
    { 

     $pdoMock = $this->getMock('PDO', array('prepare'), array(), '', false); 

     $classToTest = new MyTest($pdoMock); 

     // Assert stuff here! 


    } 

    // More test code....... 

Qualsiasi PHPUnit pro me di dare una mano?

Grazie,

Ben

Answer 1

$ backupGlobals non ti aiuta, perché questo errore viene da altrove. PHPUnit 3.5.2 (versioni precedenti eventualmente pure) ha il seguente codice nel PHPUnit/quadro/MockObject/Generator.php

if ($callOriginalConstructor && 
     !interface_exists($originalClassName, $callAutoload)) { 
     if (count($arguments) == 0) { 
      $mockObject = new $mock['mockClassName']; 
     } else { 
      $mockClass = new ReflectionClass($mock['mockClassName']); 
      $mockObject = $mockClass->newInstanceArgs($arguments); 
     } 
    } else { 
     // Use a trick to create a new object of a class 
     // without invoking its constructor. 
     $mockObject = unserialize(
      sprintf(
      'O:%d:"%s":0:{}', 
      strlen($mock['mockClassName']), $mock['mockClassName'] 
     ) 
     ); 
    } 

Questo "trucco" con unserialize viene utilizzato quando si chiede getMock di non eseguire il costruttore originale e prontamente fallirà con DOP.

Quindi, come aggirare?

Una possibilità è quella di creare un aiuto test come questo

class mockPDO extends PDO 
{ 
    public function __construct() 
    {} 

} 

L'obiettivo qui è quello di sbarazzarsi del costruttore originale DOP, che non è necessario. Quindi, modificare il codice di prova per questo:

$pdoMock = $this->getMock('mockPDO', array('prepare')); 

Creazione finto come questo sarà eseguire costruttore originale, ma dal momento che è ormai innocui grazie a mockPDO test di aiuto, è possibile continuare il test.

Answer 2

Il meglio che posso pensare è quello di utilizzare runkit e ridefinire i due metodi finali come protetti utilizzando runkit_function_redefine.

Non abilitare l'impostazione runkit.internal_override in php.ini.

E come sempre, come con eval, se runkit sembra la risposta, la domanda è probabilmente sbagliato :)

Answer 3

Stai istanziando il tuo caso di test nel tuo caso di test?

$classToTest = new MyTest($pdoMock); 

In questo momento, si sta essenzialmente testando il proprio caso di test. Dovrebbe essere più qualcosa di simile:

$classToTest = new My($pdoMock);