Comenzando con "Mejorar PHP"

Question

Estoy buscando incorporar un marco de prueba en un proyecto que estoy construyendo y encontré Enhance PHP que me gusta, pero estoy teniendo algunas dificultades para encontrar información relevante en línea ya que "mejorar php" es tal una frase de uso común.

¿Alguien ha trabajado con este marco que pueda orientarme hacia alguna guía útil? ¿Has trabajado con un marco de prueba de unidad que crees que es increíblemente mejor?

Gracias de antemano.

En respuesta a Gotzofter, esta es la clase a ensayar:

<?php 
include_once('EnhanceTestFramework.php'); 

class ExampleClass 
{ 
    private $OtherClass; 

    function __construct($mock = null) 
    { 
     if ($mock == null) 
      $this->OtherClass = new OtherExampleClass(); 
     else 
      $this->OtherClass = $mock; 
    } 

    public function doSomething() 
    { 
     return $this->OtherClass->getSomething(1, 'Arg2'); 
    } 
} 

class OtherExampleClass 
{ 
    public function getSomething() 
    { 
     return "Something"; 
    } 
} 

class ExampleClassTests extends \Enhance\TestFixture 
{ 
    public function setUp() 
    { 
    } 

    public function tearDown() 
    { 
    } 

    public function verifyWithAMock() 
    { 
     $mock = \Enhance\MockFactory::createMock('OtherExampleClass'); 
     $mock->addExpectation(
      \Enhance\Expect::method('getSomething') 
       ->with(1, 'Arg2') 
       ->returns('Something') 
       ->times(1) 
      ); 
     $target = new ExampleClass($mock); 
     $result = $target->doSomething(); 
     \Enhance\Assert::areIdentical("Something", $result); 

     $mock->verifyExpectations(); 
    } 
} 

\Enhance\Core::runTests(); 

vistazo a mi constructor para ExampleClass.

Dado que el ejemplo del sitio de enhance-php inyecta el objeto $ mock llamando al nuevo ExampleClass ($ mock), me veo forzado a cambiar mi constructor ExampleClass para manejar un $ mock como parámetro de entrada.

¿Debo manejar esto para todas las clases que deseo someter a pruebas unitarias con el marco?

Gracias.

Answer 1

Este:

function __construct() 
{ 
    $this->OtherClass = new OtherExampleClass; 
} 

debe ser:

function __construct($otherClass) 
{ 
    $this->OtherClass = $otherClass; 
} 

Su maqueta no se inyecta en este momento de su prueba:

$target = new ExampleClass($mock); 

Answer 2

Una cosa que recomendaría no importa qué El marco de prueba que está utilizando es una sugerencia de tipo en contra de la clase o interfaz esperada.

<?php 
class ExampleClass 
{ 
    private $OtherClass; // OtherClass instance 

    public function __construct(OtherClass $OtherClass=null) 
    { 
     // ... 
    } 
} 

No soy ningún experto di, pero no veo el problema en dejar que cada llamada clase nueva si no se proporciona una instancia para una dependencia en particular. También podría, por supuesto, tomar el enfoque donde usa métodos setter para configurar dependencias.

<?php 
class class ExampleClass 
{ 
    private $OtherClass; // OtherClass instance 

    public function setOtherClass(OtherClass $OtherClass) 
    { 
    $this->OtherClass = $OtherClass; 
    } 
} 

Es cojo que los ExampleClass en el código de ejemplo ni siquiera definen el método dedoSomething de los ExampleDependencyClassTests, pero si he entendido bien parece que Enhance PHP no está obligando a tomar un estilo particular de inyección de dependencia. Se puede escribir la clase de prueba que le apetezca, así que por ejemplo si se toma el enfoque método de selección que he mencionado anteriormente, se puede cambiar el código de ejemplo maqueta a

<?php 
class ExampleDependencyClassTests extends \Enhance\TestFixture 
{ 
    public function verifyWithAMock() 
    { 
     $mock = \Enhance\MockFactory::createMock('ExampleDependencyClass'); 
     $mock->addExpectation(
      \Enhance\Expect::method('getSomething') 
      ->with(1, 'Arg2') 
      ->returns('Something') 
      ->times(1) 
     ); 
     $target = new ExampleClass(); 
     $target->setExampleDependencyClass($mock); 
     $result = $target->doSomething(); 
     $mock->verifyExpectations(); 
    } 
} 

Por supuesto que sería probly sentido hacer la apropiada revisiones al ExampleClass!

<?php 
class ExampleClass 
{ 
    private $ExampleDependencyClass; 

    public function addTwoNumbers($a, $b) 
    { 
     return $a + $b; 
    } 

    public function setExampleDependencyClass(
     ExampleDependencyClass $ExampleDependecyClass 
    ) { 
     $this->ExampleDependecyClass = $ExampleDependecyClass; 
    } 

    public function doSomething($someArg) 
    { 
     return 'Something'; 
    } 
} 

He trabajado con PHPUnit un poco, y honestamente que tendrá que hacer frente a los mismos desafíos con Mocks allí. Mis 2 centavos, tratan de modelar sus pruebas sin Mocks si es posible;)

Answer 3

Hay un tutorial sobre Nettuts titulado Testing Your PHP Codebase With Enhance PHP, lo que sin duda le ayudará a empezar.

Y hay un Quick Start Guide on Enhance PHP.