Il testing con zend framework

Il testing con Zend
Framework
Enrico Zimuel
Senior Consultant & Architect
Zend Technologies

© All rights reserved. Zend Technologies, Inc.

Sommario
● Introduzione allo Unit Testing in PHP
● Le funzionalità di base di test con ZF
● Alcuni scenari avanzati di testing con ZF


Perchè testare il codice?


Semplificare la manutenzione
● Il testing definisce le aspettative
● Il testing descrive i comportamenti
dell'applicazione
● Il testing identifica i cambiamenti nel
codice sorgente che violano
(“rompono”) i comportamenti attesi del
software


Quantificare la qualità del codice
● Copertura del codice (code coverage)
effettuata dagli strumenti di testing
● I metodi di test documentano i
comportamenti attesi del software


Benefici psicologici per gli sviluppatori

Quando il test è ok, gli sviluppatori sono più
confidenti e motivati!

6 © All rights reserved. Zend Technologies, Inc.

Testing non è … ricaricare una pagina


Testing non è … var_dump()


Testing è … riproducibile


Testing è … automatizzabile


In un buon testing …
● Si definiscono i comportamenti
● Si forniscono esempi su scenari d'utilizzo
● Si definiscono le aspettative


PHP testing frameworks
● PHPT
▶ Utilizzato da PHP, da PEAR e da alcune
librerie indipendenti
● SimpleTest
▶ Un framework di testing in stile JUnit
● PHPUnit
▶ Un framework di testing in stile JUnit
▶ De facto lo standard di testing in PHP


Le basi del testing


Scrivere unit test
● Creare una classe di test
● Creare uno o più metodi che definiscono dei
comportamenti
▶ Descrivere il comportamento in un
linguaggio naturale
● Scrivere codice che definisce il comportamento
▶ Scrivere codice utilizzando l'API
● Scrivere le asserzioni per definire il
comportamento atteso


Creare una classe di test
● Solitamente il nome termina per Test

class EntryTest
class EntryTest
extends PHPUnit_Framework_TestCase
{{
}}


Scrivere un metodo che definisce il
comportamento
● prefisso “test”

class EntryTest
class EntryTest
{{
public function testMaySetTimestampWithString()
{{
}}
}}


Scrivere il codice per il comportamento

class EntryTest
class EntryTest
{{
{{
$string = 'Fri, 7 May 2010 09:26:03 -0700';
$string = 'Fri, 7 May 2010 09:26:03 -0700';
$ts
$ts = strtotime($string);
= strtotime($string);
$this->entry->setTimestamp($string);
$setValue = $this->entry->getTimestamp();
}}
}}


Scrivere asserzioni per un
comportamento atteso

class EntryTest
class EntryTest
{{
{{
$string = 'Fri, 7 May 2010 09:26:03 -0700';
$string = 'Fri, 7 May 2010 09:26:03 -0700';
$ts
$ts = strtotime($string);
= strtotime($string);
$this->assertSame($ts, $setValue);
$this->assertSame($ts, $setValue);
}}
}}


Eseguire il test
● Fallimento?
▶ Verifica il test e le asserzioni per eventuali
errori di battitura o casi d'uso
▶ Verifica la classe che si stà testando
▶ Eseguire le correzioni e rilanciare il test
● Successo?
▶ Creare il prossimo test di comportamento
o continuare con le modifiche sul codice
del software


Alcuni termini del testing


Test scaffolding
● Essere sicuri che l'ambiente di testing sia
libero da pre-requisiti
● Inizializzare le dipendenze necessarie per
eseguire il test
● Di solito l'inizializzazione dell'ambiente di
test avviene nel metodo setUp()


Test doubles
● Stubs
Sostituire un oggetto con un altro per
continuare il test
● Mock Objects
Sostituire un oggetto con un altro
forzandone le aspettative (restituendo
valori prestabiliti per i metodi)


Alcune tipologie di test
● Testing condizionali
Testing solo al verificarsi di alcune
condizioni d'ambiente
● Testing funzionali e d'integrazione
Testing del sistema per verificare i
comportamenti attesi; testing delle unità
e delle loro interazioni


Testing semi-funzionale
in Zend Framework


Fasi principali
● Setup dell'ambiente phpUnit
● Creare uno scenario di test (TestCase)
basato su un Controller
(ControllerTestCase)
● Bootstrap dell'applicazione
● Creazione di una richiesta e dispatch
● Eseguire asserzioni sulle risposte


L'ambiente PHPUnit
● Struttura delle directory

tests
tests
|-- application
|-- application
|| `-- controllers
`-- controllers
|-- Bootstrap.php
|-- Bootstrap.php
|-- library
|-- library
|| `-- Custom
`-- Custom
`-- phpunit.xml
`-- phpunit.xml
4 directories, 2 files
4 directories, 2 files


L'ambiente PHPUnit (2)
● phpunit.xml
<phpunit bootstrap="./Bootstrap.php">
<phpunit bootstrap="./Bootstrap.php">
<testsuite name="Test Suite">
<testsuite name="Test Suite">
<directory>./</directory>
<directory>./</directory>
</testsuite>
</testsuite>
<filter>
<filter>
<whitelist>
<whitelist>
<directory
<directory
suffix=".php">../library/</directory>
suffix=".php">../library/</directory>
<directory
<directory
suffix=".php">../application/</directory>
suffix=".php">../application/</directory>
<exclude>
<exclude>
<directory
<directory
suffix=".phtml">../application/</directory>
suffix=".phtml">../application/</directory>
</exclude>
</exclude>
</whitelist>
</whitelist>
</filter>
</filter>
</phpunit>
</phpunit>


L'ambiente PHPUnit (3)
● Bootstrap.php
$rootPath == realpath(dirname(__DIR__));
$rootPath realpath(dirname(__DIR__));
if (!defined('APPLICATION_PATH')) {{
if (!defined('APPLICATION_PATH'))
define('APPLICATION_PATH',
define('APPLICATION_PATH',
$rootPath .. '/application');
$rootPath '/application');
}}
if (!defined('APPLICATION_ENV')) {{
if (!defined('APPLICATION_ENV'))
define('APPLICATION_ENV', 'testing');
define('APPLICATION_ENV', 'testing');
}}
set_include_path(implode(PATH_SEPARATOR, array(
set_include_path(implode(PATH_SEPARATOR, array(
'.',
'.',
$rootPath .. '/library',
$rootPath '/library',
get_include_path(),
get_include_path(),
)));
)));
require_once 'Zend/Loader/Autoloader.php';
require_once 'Zend/Loader/Autoloader.php';
$loader == Zend_Loader_Autoloader::getInstance();
$loader Zend_Loader_Autoloader::getInstance();
$loader->registerNamespace('Custom_');
$loader->registerNamespace('Custom_');


Creare una classe di test
● Estendere la Zend_Test_PHPUnit_ControllerTestCase

class ExampleControllerTest
extends Zend_Test_PHPUnit_ControllerTestCase
{{
}}


Bootstrap dell'applicazione
● Creare un'istanza di Zend_Application e
referenziarla nel setUp()
{{
public function setUp()
{{
$this->bootstrap = new Zend_Application(
APPLICATION_ENV,
APPLICATION_ENV,
APPLICATION_PATH
APPLICATION_PATH
. '/configs/application.ini'
);
);
parent::setUp();
parent::setUp();
}}
}}


Creazione e dispatch di una richiesta
● Metodo semplice: dispatch di una “url”
{{
// ...
// ...
public function testStaticPageHasGoodStructure()
public function testStaticPageHasGoodStructure()
{{
$this->dispatch('/example/page');
// ...
// ...
}}
}}


Creazione e dispatch di una richiesta (2)
● Avanzato: personalizzare l'oggetto della
richiesta prima di eseguire il dispatch
{{
// ...
// ...
public function testXhrRequestReturnsJson()
{{
$this->getRequest()
$this->getRequest()
->setHeader('X-Requested-With',
->setHeader('X-Requested-With',
'XMLHttpRequest')
'XMLHttpRequest')
->setQuery('format', 'json');
->setQuery('format', 'json');
$this->dispatch('/example/xhr-endpoint');
$this->dispatch('/example/xhr-endpoint');
// ...
// ...
}}
}}

Creare asserzioni
● Tipiche asserzioni:
▶ Verifica della struttura della risposta e dei
markup
Utilizzando selettori CSS o query XPath
▶ Verificare il codice della risposta HTTP o
l'header di pagina
▶ Verificare artefatti sulla richiesta e sulla
risposta


Asserzioni con selettori CSS
● assertQuery($path, $message = '')
● assertQueryContentContains(
$path, $match, $message = '')
● assertQueryContentRegex(
$path, $pattern, $message = '')
● assertQueryCount($path, $count, $message = '')
● assertQueryCountMin($path, $count, $message = '')
● assertQueryCountMax($path, $count, $message = '')
● ognuna ha una variante "Not"


Asserzioni con selettori XPath
● assertXpath($path, $message = '')
● assertXpathContentContains(
$path, $match, $message = '')
● assertXpathContentRegex(
$path, $pattern, $message = '')
● assertXpathCount($path, $count, $message = '')
● assertXpathCountMin($path, $count, $message = '')
● assertXpathCountMax($path, $count, $message = '')


Asserzioni su Redirect
● assertRedirect($message = '')
● assertRedirectTo($url, $message = '')
● assertRedirectRegex($pattern, $message = '')


Asserzioni sulle risposte
● assertResponseCode($code, $message = '')
● assertHeader($header, $message = '')
● assertHeaderContains($header, $match,
$message = '')
● assertHeaderRegex($header, $pattern,
$message = '')


Asserzioni sulle richieste
● assertModule($module, $message = '')
● assertController($controller, $message = '')
● assertAction($action, $message = '')
● assertRoute($route, $message = '')


Esempi di asserzioni

public function testSomeStaticPageHasGoodStructure()
public function testSomeStaticPageHasGoodStructure()
{{
$this->assertResponseCode(200);
$this->assertResponseCode(200);
$this->assertQuery('div#content p');
$this->assertQuery('div#content p');
$this->assertQueryCount('div#sidebar ul li', 3);
$this->assertQueryCount('div#sidebar ul li', 3);
}}


Esempi di asserzioni (2)

{{
// ...
// ...
$this->assertNotRedirect();
$this->assertNotRedirect();
$this->assertHeaderContains(
$this->assertHeaderContains(
'Content-Type', 'application/json');
'Content-Type', 'application/json');
}}


Alcuni casi avanzati di testing


Testing di modelli e risorse
● Problema:
Queste classi non vengono caricate con il
sistema di autoloading
● Soluzione:
Utilizzare il bootstrap di Zend_Application
per caricare manualmente le risorse
durante il setUp()


Esempio
class Blog_Model_EntryTest
class Blog_Model_EntryTest
{{
{{
APPLICATION_ENV,
APPLICATION_ENV,
APPLICATION_PATH
APPLICATION_PATH
);
);
$this->bootstrap->bootstrap('modules');
$this->bootstrap->bootstrap('modules');
$this->model = new Blog_Model_Entry();
$this->model = new Blog_Model_Entry();
}}
}}


Testing con autenticazione
● Problema:
Alcune azioni possono richiedere
un'autenticazione utente, come emularla
in fase di testing?
● Soluzione:
Eseguire un'autenticazione manuale
utilizzando Zend_Auth prima di eseguire il
dispatch()


Esempio

{{
// ...
// ...
public function loginUser($user)
public function loginUser($user)
{{
$params = array('user' => $user);
$params = array('user' => $user);
$adapter = new Custom_Auth_TestAdapter(
$adapter = new Custom_Auth_TestAdapter(
$params);
$params);
$auth
$auth = Zend_Auth::getInstance();
= Zend_Auth::getInstance();
$auth->authenticate($adapter);
$auth->authenticate($adapter);
$this->assertTrue($auth->hasIdentity());
$this->assertTrue($auth->hasIdentity());
}}
}}


Esempio (2)

{{
// ...
// ...
public function testAdminUserCanAccessAdmin()
public function testAdminUserCanAccessAdmin()
{{
$this->loginUser('admin');
$this->loginUser('admin');
$this->dispatch('/example/admin');
$this->dispatch('/example/admin');
$this->assertQuery('div#content.admin');
$this->assertQuery('div#content.admin');
}}


Testing di pagine che dipendono da
altre azioni
● Problema:
Alcune azioni possono dipendere
dall'esito di altre, ad esempio una pagina
che evidenzia I risultati di un'operazione
di ricerca
● Soluzione:
Eseguire un doppio dispatch, resettando
la richiesta tra una chiamata e l'altra


Esempio
{{
// ...
// ...
public function testHighlightedTextAfterSearch()
public function testHighlightedTextAfterSearch()
{{
$this->getRequest()->setQuery(
$this->getRequest()->setQuery(
'search', 'foobar');
'search', 'foobar');
$this->dispatch('/search');
$this->dispatch('/search');
$this->resetRequest();
$this->resetRequest();
$this->resetResponse();
$this->resetResponse();
$this->assertQueryContains(
$this->assertQueryContains(
'span.highlight', 'foobar');
'span.highlight', 'foobar');
}}

Conclusioni


Eseguire sempre il test!
● Test dei modelli, dei livelli di servizio, etc
● Eseguire test funzionali e di accettazione
per il workflow dell'applicazione, per la
struttura delle pagine, etc
● Testing = Scrivere codice migliore, più
affidabile e di qualità


Grazie!

Per maggiori informazioni:
http://www.zend.com
http://framework.zend.com


Il testing con zend framework

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (8)

Andere mochten auch

Andere mochten auch (6)

Ähnlich wie Il testing con zend framework

Ähnlich wie Il testing con zend framework (20)

Mehr von Zend by Rogue Wave Software

Mehr von Zend by Rogue Wave Software (20)

Il testing con zend framework