Escuela de Computación ASEGURAMIENTO DE LA CALIDAD DEL SOFTWARE Investigación Pruebas unitarias PHPUnit – PHP y QUnit – Javascript Profesora Marlen Treviño Villalobos Responsables: Araya Gómez Jeimy Pamela 201158146 Pacheco Corella Uriel Isaac 201132743 Salas Aguilar Jean Carlos 2011 San Carlos, 29 de septiembre de 2014
56
Embed
Pruebas unitarias para los lenguajes de programación PHP y JavaScript con las herramientas PHPUnit y QUnit
El mantenimiento de la calidad del software impide el desarrollo de software de ritmo rápido así como muchos ciclos de prueba que son necesarios para garantizar productos de calidad. Existen pruebas unitarias para diferentes entornos, entre ellos se pueden incluir PHPUnit para PHP y QUnit para Javascript, de los cuales hablaremos en esta investigación, se explicará cómo trabajan, algunas características de estos y sus funcionalidades.
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Escuela de Computación
ASEGURAMIENTO DE LA CALIDAD DEL SOFTWARE
Investigación Pruebas unitarias
PHPUnit – PHP y QUnit – Javascript
Profesora Marlen Treviño Villalobos
Responsables: Araya Gómez Jeimy Pamela 201158146 Pacheco Corella Uriel Isaac 201132743
Salas Aguilar Jean Carlos 2011
San Carlos, 29 de septiembre de 2014
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript) Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 2
Tabla de contenidos
Índice de figuras .................................................................................................................................. 3
Índice de tablas ................................................................................................................................... 3
Índice de códigos ................................................................................................................................. 4
Guía de instalación y manual de uso de PHPUnit – PHP ............................................................. 28
Agregando PHP al PATH ............................................................................................................ 29
Instalación de PEAR ................................................................................................................... 34
Instalación de PHPUnit .............................................................................................................. 40
Manual De PHPUnit .................................................................................................................. 44
Guía de instalación y manual de uso de QUnit - Javascript ........................................................ 51
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript) Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 3
Índice de figuras
Figura 1: Logo PHP............................................................................................................................... 7
Figura 2: Logo PHPUnit ........................................................................................................................ 9
Figura 3: Logo JavaScript ................................................................................................................... 13
Figura 4: History of JavaScript ........................................................................................................... 14
Figura 5: Error .................................................................................................................................... 29
Figura 6: Configuración Avanzada del sistema.................................................................................. 29
Figura 7: Propiedades del sistema .................................................................................................... 30
Figura 8: Variables de entorno .......................................................................................................... 31
Figura 9: Editar la variable del sistema ............................................................................................. 32
Figura 10: Consola ............................................................................................................................. 32
Figura 11: Consola ............................................................................................................................. 33
Figura 12: Ruta PATH ......................................................................................................................... 34
Figura 13: Consola ............................................................................................................................. 35
Figura 14: Consola. ............................................................................................................................ 35
Figura 15: Consola ............................................................................................................................. 36
Figura 16: Consola ............................................................................................................................. 37
Figura 17: Consola ............................................................................................................................. 38
Figura 18: Consola ............................................................................................................................. 38
Figura 19: Ventana ............................................................................................................................ 39
Figura 20:Mensaje ............................................................................................................................. 39
Figura 21: Mensaje ............................................................................................................................ 39
Figura 22: Consola ............................................................................................................................. 40
Figura 23: Consola ............................................................................................................................. 40
Figura 24: Consola ............................................................................................................................. 41
Figura 25: Consola ............................................................................................................................. 42
Figura 26: Consola ............................................................................................................................. 42
Figura 27: Consola ............................................................................................................................. 43
Figura 28: Consola ............................................................................................................................. 47
Figura 29: Consola ............................................................................................................................. 49
Figura 30: Consola ............................................................................................................................. 50
Figura 31: QUnit:: A JavaScript Unit Testing framework ................................................................... 51
Figura 32: Guia de Qunit ................................................................................................................... 55
Figura 33: Error .................................................................................................................................. 56
Índice de tablas
Tabla 1: Funcionalidades comunes de pruebas unitarias ................................................................. 46
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript) Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 4
Índice de códigos Código 1: Resulting State Assertion .................................................................................................. 10
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript) Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 8
Prestashop (tiendas on-line para comercio electrónico), phpBB y SMF (sistemas de foros para
páginas web), Moodle (plataforma educativa para educación on-line), etc.
PHP también puede utilizar y presentar resultados en otros estándares de datos o lenguajes
propios de los desarrollos web, como XHTML y cualquier otro tipo de ficheros XML. PHP puede
autogenerar estos archivos y almacenarlos en el sistema de archivos en lugar de presentarlos en la
pantalla, utilizando estos ficheros para generar contenido dinámico. Es decir, el contenido dinámico
puede surgir de otros sitios además de desde bases de datos.
También se puede interactuar con otros servidores usando cualquier protocolo. Por último,
PHP puede enlazarse con otros lenguajes muy potentes como Java.
En resumen, PHP es un lenguaje potente, muy usado y de gran interés para los desarrollos
web.
Las primeras versiones de PHP
En 1995 se reconstruyó el analizador, se le incorporó un módulo (realizado por el propio
Rasmus) que interpretaba la información de los formularios de html y se le añadió una interfaz para
manejar bases de datos mSQL. Esta versión recibió el nombre de PHP/FI.
En 1997 pasó de ser un proyecto individual a ser un proyecto de equipo. Zeev Suraski y Andi
Gutmans reescribieron el analizador y muchas de las funciones de PHP/FI para obtener una nueva
versión.
Características de PHP
PHP es un lenguaje interpretado (script), pensado fundamentalmente para añadir
funcionalidad a los servidores de páginas web.
Sintáctica y gramaticalmente es una mezcla de C, Java y Perl, pero tiene la ventaja de ser un
lenguaje especialmente diseñado para la programación en un entorno web. Incorpora la mayoría de
las funciones que un programador web utiliza habitualmente y además da soporte a las bases de
datos más utilizadas (en entorno Unix/Linux sobre todo): Oracle, Sybase, mSQL, MySQL, dBase... y
ODBC para acceder a través de este interfaz a cualquier otro gestor de bases de datos.
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript) Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 9
Como ventajas de PHP destacan la facilidad de aprendizaje y utilización y, por supuesto, que es un
producto de libre distribución.
Al ejecutarse desde un navegador web el usuario trabaja en un entorno conocido y no tiene
que aprender nada nuevo para poder utilizar el programa.
Los programas PHP se ejecutan en la máquina del servidor (server side) como bloques
individuales o como scripts intercalados entre código HTML. Al estar guardados en el servidor el
código está protegido de la manipulación por parte de los usuarios y del ataque de virus.
¿Qué es PHPUnit?
Según Carlos Nacianceno, PHPUnit “es un
framework open source para el desarrollo, orientado
a pruebas ó TDD para cualquier código PHP. Es decir,
es un framework que nos ayuda a probar nuestro
código”.
Sebastian Bergmann (creador de PHPUnit)
dice “todos los programadores cometen errores,
pero la diferencia entre los buenos programadores y
los malos programadores es que los buenos programadores prueban su código
para encontrar esos errores lo más pronto posible“.
La propuesta de PHPUnit y otros frameworks para pruebas es crear pequeñas unidades que
revisen funcionalidades puntuales del código y probar que funcionen como debe, además de la
posibilidad de automatizar estas pruebas para ejecutarlas frecuentemente, tanto como el código
cambie.
La vía típica para instalar PHPUnit es a través de PEAR, aunque también algunos IDEs como
Zend Studio ya lo traen integrado. Una vez instalado hay que crear los tests, (métodos clases en
PHP), y ejecutarlos por línea de comando o desde el IDE; así se obtiene un resultado para cada test.
Para que una prueba sea exitosa, todos los tests unitarios deben pasar y obtener un alto porcentaje
en la cobertura de código.
Figura 2: Logo PHPUnit
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript) Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 10
Crear tests unitarios puede complicarse si nuestro código no es testeable, es decir, no se
presta mucho para hacerle pruebas, saber si un código es testeable o no, crear pruebas más
efectivas es algo que sólo con la práctica se logrará.
Patrones para realizar assert con PHPUnit
Veremos algunos patrones para escribir mejores tests, estos están representados mediante
pequeños ejemplos utilizando PHPUnit, pero podría ser aplicable a cualquier otro lenguaje, ya que
todo esto solo es un conjunto de buenas prácticas para hacer tests unitarios.
Un estado resultante(Resulting State Assertion)
La idea detrás de un assert es crear un objeto, ejecutar algunas funciones y después comprobar su
estado interno. Lo mejor es utilizar un ejemplo para ilustrarlo:
public function testSizeOfListItemsAddedToIt() { $list = array(); array_push($list,'something'); $this->assertEquals(1, sizeof($list)); }
Código 1: Resulting State Assertion
En este test se puede comprobar que cuando se crea un array y se le añade un elemento su tamaño
después de añadir el elemento es 1.
Validando hipótesis (guard assertion)
Otra opción a la hora de hacer testing es hacer explícitas las “hipótesis” antes de invocar al método
que queramos probar.
public function testListIsNoLongerEmptyAfterAddingAnItemToIt() { $list = array(); $this->assertTrue(empty($list)); //guard assertion array_push($list,'something'); $this->assertFalse(empty($list)); //state verification }
Código 2: guard assertion
Vemos cómo se puede verificar que la lista al ante de ejecutar el método array_push está
vacía y después de añadirle un elemento ya no lo está. Lo normal es combinar los 2 patrones
anteriores para lo tests, normalmente primero se confirma el estado del objeto antes de ejecutar el
método a probar y después se valida el resultado obtenido.
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript) Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 11
Triangulación (Delta assertion)
De vez en cuando ocurre que se tiene que trabajar con código del que no se tienen pruebas, se
pueden llamar a funciones que no se han, eso no es un problema, pero al final se está delegando la
responsabilidad de la prueba en otra función. Una solución común puede ser triangular, es decir
probar la diferencia que hay entre el antes y después de probar.
public function testSizeOfListReflectsItemsAddedToIt() { $list = array(); $sizeBefore = count($list); array_push($list,'something'); $this->assertEquals($sizeBefore + 1, count($list)); }
Código 3: Delta assertion
Este ejemplo puede parecer algo ridículo pero resume muy bien los fundamentos del patrón de
triangulación para pruebas unitarias. Es cierto, que estas aserciones pueden llegar a ser complejas
de escribir, pero se centran en la esencia de lo que se está poniendo a prueba.
Custom assertion
A veces se necesita mucho código para poder invocar a la funciones que queremos probar (Mocks,
Stubs,…). Cuando esto sucede es una buena idea extraer toda la aserción a un método con el fin de
encapsular toda lógica compleja. Así se gana algo de legibilidad en el código e incluso se puede
utilizar nuestra aserción en otros test si fuese necesario.
public function testTimeslotsAreOnWeekdays() { $calendar = new MeetingCalendar(); //omitido: añadir citas al calendario hasta //final de las horas de oficina el próximo viernes $time = $calendar->nextAvailableStartingTime(); $this->assertIsDuringOfficeHoursOnWeekday($time); } protected function assertIsDuringOfficeHoursOnWeekday(DateTime $time) { // Aserción: Omitida por brevedad }
Código 4:Custom assertion
Una razón muy común para utilizar este tipo de custom assertion es la capacidad de realizar
diferentes tipos de fuzzy matching. Por ejemplo, si necesitamos comparar 2 objetos pero solo por
un subconjunto de propiedades. Además creando custom assertion podemos hacer que se lancen
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript) Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 12
diferentes mensajes en caso de que el test falle y así sabremos en qué punto está fallando nuestro
test.
Interacción (Interaction Assertion)
El último patrón para las aserciones es Interaction Assertion. Esta es la aserción más divertida. Con
este patrón no se comprueban los resultados del código, sino que se verifica que el código interactúa
con el resto de objetos como esperamos que lo haga.
public function testPaperBoyShouldDeliverPapers() { $david = new MockCustomer(); $ana = new MockCustomer(); $paperboy = new PayperBoy(); $paperboy->addToRoute($david); $paperboy->addToRoute($ana); $this->assertTrue(in_array($david, $paperboy->deliever)); $this->assertTrue(in_array($ana, $paperboy->deliever)); } }
Código 5: Interaction Assertion
Este test es solo un ejemplo y no debemos tenerlo demasiado en consideración, ya que solo
nos sirve para ilustrar el patrón interacción. En este ejemplo, se ve como interactúan entre sí clases
Mock con clases que queremos crear.
En la práctica podemos combinar todos estos patrones assert para poder testear SUT (código bajo
test).
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript) Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 13
QUnit – Javascript
¿Qué es Javascript?
“JavaScript (abreviado comúnmente “JS”) es un lenguaje de
programación interpretado, dialecto del estándar ECMAScript. Se define como
orientado a objetos, basado en prototipos, imperativo, débilmente tipado y
dinámico.
Se utiliza principalmente en su forma del lado del cliente (client-side),
implementado como parte de un navegador web, el cual interpreta el código
JavaScript integrado en las páginas web. Para interactuar con una página web
se provee al lenguaje JavaScript de una implementación del Document Object
Model (DOM)”
(Bitácora del desarrollador, s.f).
Para Jorge Mohedano, José Saiz, Pedro Salazar desde el punto de vista técnico, JavaScript
es “un lenguaje interpretado, que significa que las instrucciones son analizadas en secuencia por el
intérprete de JavaScript, (…) de manera que su ejecución es inmediata a la interpretación. Esto
permite que, una vez escrito un programa en JavaScript (…) y sea embebido el código en un fichero
HTML, el navegador es capaz de interpretarlo y ejecutarlo sin necesidad de procesos intermedios”
JavaScript es un lenguaje de programación “que se utiliza principalmente para crear páginas
web capaces de interactuar con el usuario (…). Cuando un desarrollador incorpora JavaScript a su
página, proporciona al usuario cierta capacidad de interacción con la página web, es decir, cierto
dinamismo y por lo tanto se incrementan las prestaciones de la misma al añadir procesos en
respuesta a las acciones del usuario. Es importante señalar que estos procesos se ejecutan en la
máquina del cliente (navegador) y por tanto no implican intercambio de datos con el servidor (sic)”
(Jorge Mohedano, José Saiz, Pedro Salazar, 2012)
Figura 3: Logo JavaScript
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript) Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 14
Técnicamente, JavaScript es un lenguaje de programación interpretado, por lo que no es
necesario compilar los programas para ejecutarlos. En otras palabras, los programas escritos con
JavaScript se pueden probar directamente en cualquier navegador sin necesidad de procesos
intermedios.
¿Cómo nace Javascript?
Javascript es una tecnología que ha sobrevivido por más de 10 años, es fundamental en la
web, junto con la estandarización de la “European Computer Manufacturers Association” (ECMA)
(adoptada luego por la ISO) y W3C DOM, Javascript es considerado por muchos desarrolladores web
como la fundación para la próxima generación de aplicaciones web dinámicas del lado del cliente.
Nació con la necesidad de permitir a los autores de sitio web crear páginas que permiten
intercambiar con los usuarios, ya que se necesitaba crear webs de mayor complejidad. El HTML solo
permitía crear páginas estáticas donde se podía mostrar textos con estilos, pero se necesitaba
interactuar con los usuarios.
En conjunto con Emmanuel Gutierrez (2009) y Damián Pérez (2007) hacemos un repaso por
la historia de JavaScript desde su origen y evolución:
En los comienzos de Internet, las páginas web estaban compuestas únicamente de texto y
de vínculos hipertexto, limitando así su uso a un ámbito científico y universitario. Por otro lado, las
limitaciones técnicas de la época, sobre todo las relacionadas con la velocidad de conexión, no
catid=70:tutorial-basico-programador-web-php-desde-cero&Itemid=193. [Last Accessed Agosto
2014].
Fabien Potencier, François Zaninotto (2008). Symfony, la guía definitiva. Recuperado el 28/09/2014
de: http://www.jesusda.com/docs/ebooks/symfony_guia_definitiva.pdf
Jorge Mohedano, José Miguel Saiz, Pedro Salazar Román (2012). Iniciación a Javascript. Recuperado el 19/09/2014 de: http://books.google.co.cr/books?id=iy8bAgAAQBAJ&dq=que+es+Javascript&source=gbs_navlinks_ Miguel Ángel Sánchez Maza (2012). Javascript, Innovación Y Cualificación. Recuperado el