Consideremos una tarea estándar para un sitio web: autenticar y registrar usuarios. En nuestro ejemplo, definiremos un UserController para manejar esto, y tendremos los siguientes requisitos:

Podríamos, y deberíamos, definir más pruebas, pero estas servirán por ahora.

Para nuestra aplicación, definiremos un plugin, "Initialize", que se ejecuta en routeStartup(). Esto nos permite encapsular nuestro bootstrap en una interfaz OOP, que también proporciona una manera fácil de proporcionar un callback. Veamos primero los aspectos básicos de esta clase:

class Bugapp_Plugin_Initialize extends Zend_Controller_Plugin_Abstract
{
    /**
     * @var Zend_Config
     */
    protected static $_config;

    /**
     * @var string Current environment
     */
    protected $_env;

    /**
     * @var Zend_Controller_Front
     */
    protected $_front;

    /**
     * @var string Path to application root
     */
    protected $_root;

    /**
     * Constructor
     *
     * Initialize environment, root path, and configuration.
     *
     * @param  string $env
     * @param  string|null $root
     * @return void
     */
    public function __construct($env, $root = null)
    {
        $this->_setEnv($env);
        if (null === $root) {
            $root = realpath(dirname(__FILE__) . '/../../../');
        }
        $this->_root = $root;

        $this->initPhpConfig();

        $this->_front = Zend_Controller_Front::getInstance();
    }

    /**
     * Route startup
     *
     * @return void
     */
    public function routeStartup(Zend_Controller_Request_Abstract $request)
    {
        $this->initDb();
        $this->initHelpers();
        $this->initView();
        $this->initPlugins();
        $this->initRoutes();
        $this->initControllers();
    }

    // definition of methods would follow...
}

Esto nos permite crear un callback de bootstrap como el siguiente:

class UserControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
{
    public function appBootstrap()
    {
        $controller = $this->getFrontController();
        $controller->registerPlugin(
            new Bugapp_Plugin_Initialize('development')
        );
    }

    public function setUp()
    {
        $this->bootstrap = array($this, 'appBootstrap');
        parent::setUp();
    }

    // ...
}

Una vez que tengamos eso en su lugar, podemos escribir nuestras pruebas. Sin embargo, ¿qué pasa con esas pruebas que requieren que un usuario esté conectado? La solución fácil es usar nuestra lógica de aplicación para hacerlo... y hacer un pequeño ajuste usando los métodos resetRequest() y resetResponse(), que nos permitirán despachar otra solicitud.

class UserControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
{
    // ...

    public function loginUser($user, $password)
    {
        $this->request->setMethod('POST')
                      ->setPost(array(
                          'username' => $user,
                          'password' => $password,
                      ));
        $this->dispatch('/user/login');
        $this->assertRedirectTo('/user/view');

        $this->resetRequest()
             ->resetResponse();

        $this->request->setPost(array());

        // ...
    }

    // ...
}

Ahora escribamos las pruebas:

class UserControllerTest extends Zend_Test_PHPUnit_ControllerTestCase
{
    // ...

    public function testCallWithoutActionShouldPullFromIndexAction()
    {
        $this->dispatch('/user');
        $this->assertController('user');
        $this->assertAction('index');
    }

    public function testLoginFormShouldContainLoginAndRegistrationForms()
    {
        $this->dispatch('/user');
        $this->assertQueryCount('form', 2);
    }

    public function testInvalidCredentialsShouldResultInRedisplayOfLoginForm()
    {
        $request = $this->getRequest();
        $request->setMethod('POST')
                ->setPost(array(
                    'username' => 'bogus',
                    'password' => 'reallyReallyBogus',
                ));
        $this->dispatch('/user/login');
        $this->assertNotRedirect();
        $this->assertQuery('form');
    }

    public function testValidLoginShouldRedirectToProfilePage()
    {
        $this->loginUser('foobar', 'foobar');
    }

    public function testAuthenticatedUserShouldHaveCustomizedProfilePage()
    {
        $this->loginUser('foobar', 'foobar');
        $this->request->setMethod('GET');
        $this->dispatch('/user/view');
        $this->assertNotRedirect();
        $this->assertQueryContentContains('h2', 'foobar');
    }

    public function
        testAuthenticatedUsersShouldBeRedirectedToProfileWhenVisitingLogin()
    {
        $this->loginUser('foobar', 'foobar');
        $this->request->setMethod('GET');
        $this->dispatch('/user');
        $this->assertRedirectTo('/user/view');
    }

    public function testUserShouldRedirectToLoginPageOnLogout()
    {
        $this->loginUser('foobar', 'foobar');
        $this->request->setMethod('GET');
        $this->dispatch('/user/logout');
        $this->assertRedirectTo('/user');
    }

    public function testRegistrationShouldFailWithInvalidData()
    {
        $data = array(
            'username' => 'This will not work',
            'email'    => 'this is an invalid email',
            'password' => 'Th1s!s!nv@l1d',
            'passwordVerification' => 'wrong!',
        );
        $request = $this->getRequest();
        $request->setMethod('POST')
                ->setPost($data);
        $this->dispatch('/user/register');
        $this->assertNotRedirect();
        $this->assertQuery('form .errors');
    }
}

Observe que estas son concisas, y, en su mayor parte, no buscan contenido real. En cambio, buscan artefactos dentro de la respuesta -- códigos de respuesta y cabeceras, y nodos DOM. Esto le permite verificar que la estructura sea la esperada -- evitando que sus pruebas fallen cada vez que se agrega contenido nuevo al sitio.

Observe también que utilizamos la estructura del documento en nuestras pruebas. Por ejemplo, en la prueba final, buscamos un formulario que tenga un nodo con la clase "errors"; esto nos permite probar simplemente la presencia de errores de validación del formulario, sin preocuparnos por cuáles errores específicos podrían haberse producido.

Esta aplicación puede utilizar una base de datos. Si es así, probablemente necesitará algo de andamiaje para asegurarse de que la base de datos esté en una configuración prístina y comprobable al comienzo de cada prueba. PHPUnit ya proporciona funcionalidad para hacerlo; lea sobre ello en la documentación de PHPUnit. Recomendamos usar una base de datos separada para pruebas frente a producción, y en particular recomendamos usar un archivo SQLite o una base de datos en memoria, ya que ambas opciones funcionan muy bien, no requieren un servidor separado, y pueden utilizar la mayoría de la sintaxis SQL.