Pruebas-unitarias-para-los-lenguajes-de-programacion-PHP-y-JavaScript-con-las-herramientas-PHPUnit-y-QUnit

Programación I

•

Albert Einstein

FREDY PICHIHUA

17/7/2023

¡Este material tiene más páginas!

Entonces, ¿te gustó este material?

Ayude a animar a otros estudiantes a mejorar el contenido

¿Te gustó este material? ¡Compartir! 🧡

Programación I

55.845 Materiales compartidos

Descarga la aplicación para disfrutar aún más

Lea materiales sin conexión, sin usar Internet. Además de muchas otras características!

Vista previa del material en texto

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
Introducción ........................................................................................................................................ 5
Pruebas unitarias ................................................................................................................................. 6
¿Qué son las pruebas unitarias? .................................................................................................... 6
PHPUnit-PHP ................................................................................................................................... 7
¿Qué es PHP? ¿Para qué sirve PHP? .......................................................................................... 7
Las primeras versiones de PHP .................................................................................................. 8
Características de PHP ................................................................................................................ 8
¿Qué es PHPUnit? ....................................................................................................................... 9
Patrones para realizar assert con PHPUnit .............................................................................. 10
QUnit – Javascript ......................................................................................................................... 13
¿Qué es Javascript? .................................................................................................................. 13
¿Cómo nace Javascript?............................................................................................................ 14
¿Qué es Qunit? ......................................................................................................................... 16
¿Cómo nace Qunit? .................................................................................................................. 17
Características o atributos de QUnit ........................................................................................ 17
Conclusiones ..................................................................................................................................... 23
Bibliografía ........................................................................................................................................ 25
Glosario de términos ......................................................................................................................... 26
Anexos ............................................................................................................................................... 28
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
Código 2: guard assertion ................................................................................................................. 10
Código 3: Delta assertion .................................................................................................................. 11
Código 4:Custom assertion ............................................................................................................... 11
Código 5: Interaction Assertion ......................................................................................................... 12
Código 6: Qunit.module .................................................................................................................... 18
Código 7: Test .................................................................................................................................... 19
Código 8: Trows ................................................................................................................................. 19
Código 9: strictEqual ......................................................................................................................... 19
Código 10: ok ..................................................................................................................................... 20
Código 11:noStrictEquial ................................................................................................................... 20
Código 12: notEqual .......................................................................................................................... 20
Código 13: notDeepEqual .................................................................................................................. 20
Código 14: equal ................................................................................................................................ 21
Código 15: deepEqual ....................................................................................................................... 21
Código 16: propEqual ........................................................................................................................ 21
Código 17: notPropEqual .................................................................................................................. 22
Código 18: PruebaTest.php ............................................................................................................... 43
Código 19: Ejemplo1_PHPUnit .......................................................................................................... 45
Código 20: SalidaEjemplo .................................................................................................................. 47
Código 21: RemoteConnect.php ....................................................................................................... 48
Código 22: RemoteConnectTest ........................................................................................................ 48
Código 23: require_once ................................................................................................................... 49
Código 24: FalloPrueba ..................................................................................................................... 50
Código 25: Crear archivo HTML ......................................................................................................... 52
Código 26: Funciones ........................................................................................................................ 53
Código 27: Archivos test .................................................................................................................... 54

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 5

Introducción

El software se crea a través de una serie de procesos de desarrollo los cuales
representan las tareas físicas y los requerimientos lógicos del producto. Diseñar un
software que requiera la participación simultánea de muchos usuarios trabajando
durante un largo periodo es un proceso complejo que significa una cuidadosa
planificación y ejecución para cumplir los objetivos, por lo que es una necesidad el
mantener una gestión del producto de software (Dustin, Rashka, Paul, 2004, p. 6).
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.
Las pruebas unitarias pueden ser expresadas como un medio para comprobar el
correcto funcionamiento de una regla de código, estas tiene sus ventajas y beneficios,
sin embargo crear una prueba unitaria no puede considerarse eficiente si no cumple
una serie de requisitos entre los cuales se puede mencionar que deben permitir que la
prueba unitaria sea reutilizable. Las pruebas unitarias no son perfectas y a pesar de ser
muy eficientes, estas no resuelven todo, se darán a conocer algunas de las limitaciones
de estas.

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 6

Pruebas unitarias

¿Qué son las pruebas unitarias?
En programación, una prueba unitaria es una forma de comprobar el correcto
funcionamiento de un módulo de código. Esto sirve para asegurar que cada uno de los módulos
funcione correctamente por separado.
Las pruebas unitarias son el medio que se emplea para que por medio de un entorno de
prueba se consiga verificar los módulos de un sistema. Estas pruebas unitarias deben conservar un
formato, el cual debe mantener un estándarde independencia entre cada prueba, además deben
tratarse como una porción más del proyecto y como tal debe conservar su mismo formato y
profesionalidad.
Algunos de los requisitos que tienen las pruebas unitarias son:
 Automatizable: No debe solicitar una manipulación manual, esto quiere decir que debe
funcionar sin la necesidad de que el programador deba digitar algo al tener que realizar la
prueba.
 Completas: Se debe envolver la mayor parte del código posible. Significa que entre más
completa sea la verificación de los métodos se puede mantener una mayor certeza sobre la
fiabilidad del producto.
 Repetibles o Reutilizables: La reutilización de código es un importante punto que es
considerado en el paradigma orientado a objetos, este no debe omitirse en las pruebas, por
lo tanto es necesario que cada prueba no esté creada para que solo pueda ejecutarse una
vez, esto es útil para la integración continua.
 Independientes: No debe existir una dependencia entre las pruebas, por tanto no se deben
afectar entre ellas durante la ejecución.
 Profesionales: Las pruebas deben ser tratadas como parte del código de la aplicación, esto
quiere decir que las mismas formalidades deben aplicarse a las pruebas, por ejemplo
colocarle documentación.
(Canarias, 2012, p.3).
Las pruebas unitarias permiten un mayor alcance que otros tipos de pruebas, facilitan el trabajo en
equipo, reducen el uso de la depuración, debido a que las pruebas funcionan para comprobar los
http://es.wikipedia.org/wiki/Programaci%C3%B3n
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 7

métodos no es necesario depender tanto de la depuración para encontrar el error, son útiles en la
labor de refactorización (refactoring). La refactorización permite la optimización de un código
escrito previamente, favorecen el mejoramiento del diseño y sirven como documentación.
(Universidad de Sevilla, 2004, p.8).
A continuación hablaremos de las pruebas unitarias para PHP y Javascript, haciendo primero
una pequeña introducción de estos lenguajes.
PHPUnit-PHP

¿Qué es PHP? ¿Para qué sirve PHP?

Enrique González en su entrega nº3 del ‘Tutorial básico del programador web: PHP desde
cero’ explica que PHP “es un lenguaje de código abierto (significa que es de uso libre y gratuito para
todos los programadores que quieran usarlo), y que puede ser Incrustado en HTML (significa que
en un mismo archivo se puede combinar código PHP con código HTML, siguiendo unas reglas.)”
Figura 1: Logo PHP
PHP es utilizado para generar páginas web
dinámicas (páginas cuyo contenido no es
el mismo siempre sino que este puede
cambiar en base a los cambios que haya en
una base de datos, de búsquedas o
aportaciones de los usuarios, etc.). Este
lenguaje se procesa en servidores
(potentes ordenadores con un software y hardware especial) y cuando se escribe una dirección tipo
http://www.______.com/index.php en un navegador web (por ejemplo Internet Explorer, Firefox,
Chrome, etc) los datos de la solicitud son enviados al servidor que los procesa, este reúne los datos
y devuelve una página HTML como si fuera estática.
Con PHP se puede procesar la información de formularios, generar páginas con contenidos
dinámicos, o enviar y recibir cookies, entre muchas más cosas. PHP lo utilizan desde pequeñas
páginas web hasta grandes empresas, muchas aplicaciones web están construidas usando PHP, por
ejemplo se puede citar Joomla y Drupal (gestores de contenido de páginas web), osCommerce y
http://www.______.com/index.php
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 noes 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, juntocon 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
permitían proponer algo más.
Figura 4: History of JavaScript
http://www.maestrosdelweb.com/editorial/htmlhis/
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 15

El nacimiento de JavaScript como Livescript

En los años de 1990, Netscape creo Livescript; las primeras versiones de este lenguaje
fueron principalmente dedicadas a pequeños grupos de diseñadores Web que no necesitaban
utilizar un compilador, o sin ninguna experiencia en la programación orientada a objetos.
“Es a mediados de 1990 cuando la necesidad de disponer de páginas web más amigables y con más
servicios se hizo más fuerte. Brendan Eich, por aquel entonces ingeniero informático de Netscape,
tuvo el encargo de desarrollar un nuevo navegador web. Aprovechó la ocasión para desarrollar un
lenguaje de Script, originalmente denominado LiveScript, que debía ser en teoría un complemento
de Java (estos dos lenguajes suelen confundirse debido a su denominación casi idéntica a pesar de
no tener casi nada en común). El objetivo de este lenguaje de programación era desarrollar páginas
web más atractivas y amigables para el usuario, sin tener que usar para ello una programación en
el lado del servidor. Para poder realizar esto, era necesario que el navegador pudiera interpretar el
código JavaScript. Netscape decide entonces implementar de manera nativa LiveScript en la versión
2.0 de su navegador (bautizado entonces Netscape Navigator) a partir del año 1995”
(Emmanuel Gutierrez, 2009).

http://www.maestrosdelweb.com/editorial/programacion-orientada-a-objetos-en-php5/
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 16

Nace JavaScript como JavaScript y Microsoft entra al juego
En diciembre de 1995, “Netscape y Sun Microsystems (el creador del lenguaje Java) luego
de unirse al objetivo de desarrollar el proyecto en conjunto, reintroducen este lenguaje con el nombre
de Javascript. En respuesta a la popularidad de Javascript, en el año de 1996 Microsoft se interesa
por competir (…), por lo que lanza su lenguaje llamado Jscript, introducido en los navegadores de
Internet Explorer (y cuya última versión actualmente es Jscript.Net). A pesar de las diferentes críticas
que se le hacen al lenguaje Javascript, este es uno de los lenguajes de programación más populares
para la web. Desde que los navegadores incluyen el Javascript, no necesitamos el Java Runtime
Environment (JRE), para que se ejecute”.
(Pérez Valdés, 2007)
Su crecimiento y su desprestigio
“Las versiones de JavaScript comenzaron a encadenarse proponiendo en cada una de ellas
nuevas mejoras. Todo el mundo pudo constatar cómo Internet fue invadido rápidamente por páginas
compuestas de pequeños scripts que permitían, por ejemplo, mostrar la hora, la fecha, el nombre
del visitante o validar el contenido de los campos de un formulario. Sin embargo, a pesar de ser
JavaScript un lenguaje respetuoso de las instrucciones dadas por el ECMA (European Computer
Manufacturers Association), organismo internacional encargado de la estandarización de sistemas
de información y de comunicación, los editores de programas desarrollaron desde el principio
navegadores que interpretaban de manera diferente JavaScript. En consecuencia, algunos scripts
podían ejecutarse de manera correcta en un navegador y paradójicamente generar un error en otro.
Por ello, en parte, a finales de los noventa, otros lenguajes como ASP y PHP se hicieron muy
populares. Pero fue sobre todo el uso abusivo de los pop-up (ventana emergente) la razón del
desinterés creciente por JavaScript. Su proliferación afectó negativamente a JavaScript y la
desesperación de los usuarios terminó por desprestigiar sus ventajas entre los desarrolladores web;
llegando a considerarlo incluso como un sublenguaje. Afortunadamente, la llegada de los
bloqueadores de pop-up integrados en los navegadores le permitió a JavaScript recuperar el
prestigio perdido”
(Emmanuel Gutierrez, 2009)

¿Qué es Qunit?

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 17

Qunit es un framework de Javascript para realizar pruebas unitarias. Es altamente usado en
proyectos JQuery, JQuery UI, y JQuery Mobile, siendo capaz tambien de realizar pruebas unitarias a
cualquier codigo en Javascript y una de las cosas más importantes es que hasta se puede incluir a sí
mismo en las pruebas que realiza. Por lo dicho anteriormente se puede concluir que Qunit tiene un
gran alcance y es bastante robusto ademas de que es un framework que trabaja de manera muy
sencilla. Se puede decir que es un tipo de testing de caja blanca ya que se ocupa conocer sobre el
manejo de la herramienta aunque como se mencionó anteriormente, es muy sencilla de manipular.

¿Cómo nace Qunit?

Esta gran herramienta fue diseñada y desarrollada por John Resig un programador y
empresario, que fue el creador de la biblioteca JQuery y autor de un libro tecnico sobre JavaScript.
La elaboración de Qunit se realizó en el mismo momento que el proyecto JQuery, por esto es que
cada desarrollador que utilice JQuery debe usar Qunit para testear el código, ya que ambas se
complementan de manera natural.
Para el año 2008 QUnit tiene su propia casa, nombre y documentación del API, por eso, a
partir de aquí otras personas pueden empezar a usar esta herramienta para las pruebas unitarias.
El problema era que en ese momento, QUnit dependía mucho de JQuery, fue hasta después del año
2009 que se hicieron algunos cambios en la herramienta, y este ya se podía ejecutar solo.

Características o atributos de QUnit

Como crear especificaciones
Las especificaciones es lo que va evaluar el código fuente. Estas especificaciones se pueden
formar de 4 partes:
1. Dentro de una especificación podemos agregar un módulo, el módulo se encarga de agrupar
las pruebas que tienen similitudes entre si, o que estan dentro de un mismo contexto. Cabe
recalcar que lacreaciónn de modulos es meramente opcional, pero se recomienda utilizar
estos modulos ya que así mantienen más orden en las pruebas realizadas.
2. A continuación se procede a crear las pruebas, cada prueba está formada por un bloque de
código, este bloque está conformado por la descripción de lo que el código debe
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 18

hacer.Despuéss se debe crear las expectativas de resultados que debe dar la prueba. Aquí
se recomienda que cada una de las pruebas evalúe una sola funcionalidad del código, es
decir, en una prueba no se puede evaluar dos resultados del mismo código.3. Se escribe el codigo para ver si se cumple la expectativa, una buena práctica es crear
diferentes pruebas a evaluar para una misma seccion de codigo.
4. Por último, se debe repetir los pasos anteriores por cada archivo de código fuente que se
quiera evaluar.

Módulos

Los módulos se definen para mantener todas las pruebas organizadas, estos módulos
también se puede ejecutar de forma unitaria.
Para definir módulos en QUnit se debe usar la función module(nombre, [ciclo de vida])
donde “nombre” es un String y hace referencia al nombre del módulo y “ciclo de vida” permite
establecer callbacks (más adelante se hablará sobre estos elementos) que se ejecutarán antes y
después de cada prueba que compone el módulo, esta parte es opcional.
Todas las pruebas que estén después de la definición de un módulo, van a pertenecer a ese modulo.

Código 6: Qunit.module
Pruebas

Una prueba es un bloque de código en donde se define lo que debe hacer un código específico, se
le asigna un valor esperado y después se compara ese valor esperado con el resultado de la prueba.
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 19

En caso de que ambos resultados coincidan, la prueba se considera correcta, si sucede lo contrario
entonces se mostrará un mensaje con el valor esperado y el obtenido para así proceder a corregir
el error.
Una prueba se define de la siguiente manera: test(nombre, prueba), donde “nombre” es un String
y representa el nombre de la unidad que va ser testeada, y “prueba” representa la función que se
probara.

Código 7: Test
Afirmaciones (asserts)
Las afirmaciones o asserts nos permiten comparar de una forma específica, los valores esperados
con los resultados obtenidos de un código en particular. A continuación se presentan las
afirmaciones que se puede aplicar usando QUnit:
trows: “Evalúa si una funcion envía una excepción cuando se ejecuta.”

Código 8: Trows
strictEqual: “Compara que el resultado y la expectativa sean idénticos.”

Código 9: strictEqual
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 20

ok: “Recibe un valor verdadero (true), es válida si el primer argumento es verdadero.”

Código 10: ok
noStrictEquial: “Afirmación de comparación que busca que sean diferentes.”

Código 11:noStrictEquial
notEqual: “Comparación no estricta donde se busca que el resultado y la expectativa no sean
iguales.”

Código 12: notEqual
notDeepEqual: “Afirmación recursiva de comparación que se busca que no sean idénticos el
resultado y la expectativa.”

Código 13: notDeepEqual
equal: “Afirmación donde la comparación no es estricta, se busca que el resultado y la expectativa
sean iguales.”
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 21

Código 14: equal
deepEqual: “Afirmación recursiva de comparación que se busca que sean idénticos el resultado y la
expectativa.”

Código 15: deepEqual
propEqual: Comparación de valor y tipo estricto de las propiedades de un objeto.

Código 16: propEqual
notPropEqual: Comparación estricta de la propiedades de un objeto y busca que estos no sean
iguales.
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 22

Código 17: notPropEqual
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 23

Conclusiones

El desarrollo de aplicaciones en los diversos entornos que se exigen en la actualidad
trae consigo un problema que se desarrolla durante la gestión del mismo, este corresponde
a la búsqueda de posibles errores o fallos que puedan ocurrir durante las pruebas e
integración del software.
Para velar por un producto que sea fiable y que no sea entregado sin demora, se han
creado herramientas de testeo o entornos de prueba los cuales son una ayuda para
encontrar los posibles fallos a los que puede atentar la aplicación. Estos entornos de prueba
tienen muchos beneficios para quien los utiliza, ya que en proyectos grandes es importante
tener la certeza de que todo funciona como debe. Los entornos de prueba facilitan el
trabajo en equipo y permiten un mayor control sobre gran parte del código ya que por
medio de pruebas unitarias y siguiendo los estándares que cada método debe cumplir, se
puede corroborar que la aplicación no presenta fallos.
En programación, una prueba unitaria es una forma de comprobar el correcto
funcionamiento de un módulo de código. Esto sirve para asegurar que cada uno de los
módulos funcione correctamente por separado. Las pruebas unitarias deben ser
automatizables, completas, repetibles o reutilizables, independientes y profesionales.
Sin embargo las pruebas unitarias no resuelven todo, estos traen sus limitaciones,
en los que por ejemplo pueden presentar desventajas, como el de verificar todos los
posibles casos de entradas. Además no siempre se puede depender de que si la aplicación
no ha mostrado errores funciona bien, esto porque el rendimiento de la aplicación no es
algo que toma en cuenta.
Existen diferentes entornos de prueba, ya sea PHPUnit para PHP o Qunit para
JavaScript, el uso de estas herramientas facilitan una gestión más eficiente en el desarrollo.
Y permiten un control del programador sobre su aplicación.
http://es.wikipedia.org/wiki/Programaci%C3%B3n
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 24

Los entornos de prueba siempre que se usen de manera correcta, brindaran un
aporte importante en la creación de un producto confiable.
Como dice Sebastian Bergmann, el creador de PHPUnit , “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“.

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 25

Bibliografía

Bitácora del desarrollador. Jherax (s.f). JavaScript. Recuperado el 20/09/2014 de:
https://jherax.wordpress.com/category/front-end/javascript/
Damián Pérez Valdés (3 de julio del 2007). ¿Qué es Javascript?. Recuperado el 19/20/2014 de:
http://www.maestrosdelweb.com/editorial/%C2%BFque-es-javascript/
Dextructables Tutoriales y Programación (s.f). Instalar PHPUnit en Windows. Recuperado el
27/09/2014 de: http://dextructables.com/instalar-phpunit-en-windows/
Emmanuel Gutierrez (2009). JavaScript: Conceptos básicos y avanzados. Recuperado el 20/09/2014
de: http://books.google.co.cr/books?id=gsxVpvEC4iUC&dq=Javascript&source=gbs_navlinks_s
Enrique González (). ¿Qué es PHP? y ¿Para qué sirve? Un potente lenguaje de programación para
crear páginas web. (CU00803B). [ONLINE] Available at:
http://aprenderaprogramar.com/index.php?option=com_content&view=article &id=492:ique-es-
php-y-ipara- que-sirve-un-potente-lenguaje-de-programacion-para-crear-paginas-web-cu00803b&
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
19/09/2014 de:
http://books.google.co.cr/books?id=3x09sewjaHIC&dq=Javascript&source=gbs_navlinks_s
Patrones para mejorar tests con PHP y PHPUnit - TDD. (n.d.). Retrieved September 19, 2014, from
http://jesuslc.com/2014/07/04/patrones-para-mejorar-tests-con-php-y-phpunit-tdd/
PHP desde Cero: Clases & Objetos - CODEHERO. (n.d.). Retrieved September 29, 2014, from
http://codehero.co/php-desde-cero-clases-objetos/
¿Que es PHP, cómo surgió y para qué se utiliza? (n.d.). Retrieved September 29, 2014, from
http://www.nociondigital.com/webmasters/php-tutorial-que-es-php-como-surgio-y-para-que-se-
utiliza-detalle-191.html
¿Qué es PHPUnit? (n.d.). Retrieved September 08, 2014, from http://blog.eltallerweb.com/que-es-
phpunit/#sthash.nYphcLlt.dpuf
http://jesuslc.com/2014/07/04/patrones-para-mejorar-tests-con-php-y-phpunit-tdd/
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 26

Glosario de términos

Interpretado: Un lenguaje interpretado es un lenguaje de programación que está diseñado para ser
ejecutado por medio de un intérprete, en contraste con los lenguajes compilados. (Wikipedia).
ECMAScript: “ECMAScript es una especificación de lenguaje de programación publicada por ECMA
International. Actualmente está aceptado como el estándar ISO 16262. Comenzó a ser desarrollado,
basándose en el lenguaje JavaScript propuesto por Netscape Communications Corporation.
“ECMAScript define un lenguaje de tipos dinámicos ligeramente inspirado en Java y otros lenguajes
del estilo de C. Tiene características de programación orientada a objetos mediante objetos basado
en prototipos y pseudoclases”. (http://www.alegsa.com.ar/Dic/ecmascript.php, Diccionario De
Informática Y Tecnología)
Una definición más simple es: “Es el estándar de lo que la gran mayoría de la gente conocemos como
JavaScript. Hablando en sentido estricto, JavaScript y ECMAScript no son exactamente lo mismo.
JavaScript es un dialecto de ECMAScript, pero las diferencias son, en general, irrelevantes y vienen
sobre todo ocasionadas por motivos históricos de compatibilidad con versiones anteriores”. (Modo
Estricto de ECMAScript, DesarrolloWEB.com, http://www.desarrolloweb.com/articulos/modo-
estricto-ecmascript.html)
Document Object Model (DOM): “Es un conjunto de utilidades específicamente diseñadas para
manipular documentos XML. Por extensión, DOM también se puede utilizar para manipular
documentos XHTML y HTML. Técnicamente, DOM es una API de funciones que se pueden utilizar
para manipular las páginas XHTML de forma rápida y eficiente”. (Introducción a AJAX, Librosweb.es,
http://librosweb.es/ajax/)
HyperText Markup Language (HTML): “Es el lenguaje básico de casi todo el contenido web. La
mayor parte de lo que ves en la pantalla de tu navegador está escrita, fundamendalmente, usando
HTML. Específicamente, HTML es el lenguaje con el que se escribe la estructura y la semántica del
contenido de un documento web”. (HTML, Fundación Mozilla,
https://developer.mozilla.org/es/docs/Web/HTML)
European Computer Manufacturers Association (ECMA): "Ecma International es una organización
internacional basada en membresías de estándares para la comunicación y la información. Adquirió
el nombre Ecma International en 1994, cuando la European Computer Manufacturers Association
http://www.alegsa.com.ar/Dic/ecmascript.php
http://www.desarrolloweb.com/articulos/modo-estricto-ecmascript.html
http://www.desarrolloweb.com/articulos/modo-estricto-ecmascript.html
http://librosweb.es/ajax/
https://developer.mozilla.org/es/docs/Web/HTML
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 27

(ECMA) cambió su nombre para expresar su alcance internacional. (Wikipedia,
http://es.wikipedia.org/wiki/Ecma_International)
Organización Internacional de Normalización (ISO): Es una federación de entidades a nivel mundial,
que se dedican a estándares que agrupan más de 100 países. Su objetivo primordial es fomentar el
desarrollo mundial de actividades de normalización, y así hacer más fácil el intercambio de bienes y
servicios entre países. (ISO, Organización Internacional de Normalización: Historia, Funciones y
Estructura, ISOTools Excellence, http://www.isotools.org/2013/06/20/iso-organizacion-
internacional-de-normalizacion-historia-funciones-y-estructura/#sthash.12oXl6ER.dpuf)
Netscape: Netscape Communications Corporation es una empresa de software famosa por ser la
creadora del navegador web Netscape Navigator. Fue comprada por AOL en 1999. (Wikipedia,
http://es.wikipedia.org/wiki/Netscape_Communications_Corporation)
ASP (Active Server Pages): Es la tecnología desarrollada por Microsoft para la creación de páginas
dinámicas del servidor. ASP se escribe en la misma página web, utilizando el lenguaje Visual Basic
Script o Jscript (Javascript de Microsoft). (Qué es ASP , Miguel Angel Álvarez,
http://www.desarrolloweb.com/articulos/393.php)
PHP (acrónimo recursivo de PHP: Hypertext Preprocessor): Es un lenguaje de código abierto muy
popular especialmente adecuado para el desarrollo web y que puede ser incrustado en HTML.
(Página Oficial De PHP, http://php.net/manual/es/intro-whatis.php)
PATH: “Es una variable de entorno de los sistemas operativos POSIX y los sistemas de Microsoft,en
ella se especifican las rutas en las cuales el intérprete de comandos debe buscar los programas a
ejecutar. Las variables de entorno forman un conjunto de valores dinámicos que normalmente
afectan el comportamiento de los procesos en una computadora”. (Wikipedia,
http://es.wikipedia.org/wiki/Variable_de_entorno)
http://es.wikipedia.org/wiki/Ecma_International
http://www.isotools.org/2013/06/20/iso-organizacion-internacional-de-normalizacion-historia-funciones-y-estructura/#sthash.12oXl6ER.dpuf
http://www.isotools.org/2013/06/20/iso-organizacion-internacional-de-normalizacion-historia-funciones-y-estructura/#sthash.12oXl6ER.dpuf
http://es.wikipedia.org/wiki/Netscape_Communications_Corporation
http://www.desarrolloweb.com/articulos/393.php
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 28

Anexos

Guía de instalación y manual de uso de PHPUnit – PHP

Para este manual se asume que se tiene instalado PHP en el sistema. Si no lo tienen instalado,
pueden instalar Wamp o Xampp, que son paquetes para Windows que instala Apache, PHP y MySQL.
Enlace de Descarga: Xampp Wampp
Existen diferentes formas de instalar Php-Unit, la primera que utilizaremos es mediante PEAR.
¿Qué es PEAR?
“PEAR, o PHP Extension and Application Repository, es un “framework y sistema de distribución
para componentes PHP reutilizables, un entorno de desarrollo y sistema de distribución para
componentes de código PHP. El proyecto PEAR fue fundado por Stig S. Bakken en 1999 para
promover la reutilización de código que realizan tareas comunes.
PEAR permite descargar, instalar, actualizar y desinstalar scripts de PHP. Si se utiliza un paquete de
PEAR, no es necesario decidir donde guardar los scripts, cómo hacer que se puedan utilizar o cómo
extender la línea de comandos (CLI).
PEAR es un proyecto creado por la comunidad de usuarios de PHP, está desarrollado con PHP y se
incluye en las distribuciones estándar de PHP”. (Fabien Potencier, François Zaninotto, 2008)
Verificar que PHP se encuentre en el PATH:
Primero tenemos que asegurarnos que PHP se puede ejecutar mediante consola desde cualquier
ubicación. Para esto abrimos la consola de Windows o Símbolo del sistema y ejecutamos el
comando:
1. php --version
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar JeanCarlos
pág. 29

Si nunca hemos agregado PHP al PATH (variable de entorno de Windows) o ningún programa lo ha
hecho por nosotros, lo más probable es que nos aparece el siguiente mensaje de error.

Figura 5: Error
Si muestra información de PHP entonces ya se encuentra agregado y pueden continuar hasta
Instalación de PEAR
Agregando PHP al PATH
Primero hay que ir a “Equipo” (en Windows 7 y versiones posteriores) y dar clic sobre la opción
Configuración avanzada del sistema.

Figura 6: Configuración Avanzada del sistema

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 30

Se abrirá una ventana con opciones avanzadas del sistema. Aquí hay que hacer clic al botón
Variables de entorno

Figura 7: Propiedades del sistema

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 31

En esta nueva ventana, en la lista de la parte de abajo (Variables del sistema), hay que buscar la
opción que dice PATH y hacer clic en el botón Editar

Figura 8: Variables de entorno

En esta ventana se agrega manualmente la ruta de la carpeta donde se encuentra el ejecutable de
PHP para consola.
Para agregar rutas en el PATH simplemente hay que colocar el cursor al final del cuadro de texto y
agregar el símbolo “;” (punto y coma), seguido de la ruta de la carpeta donde se encuentra el
ejecutable. Luego presionamos Aceptar

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 32

Figura 9: Editar la variable del sistema
En Wamp, el ejecutable de PHP para consola se encuentra en una ubicación similar a la que se
aprecia en la imagen. En este caso la carpeta se llama php5.4.16 pero el nombre puede variar
dependiendo de la versión que venga con la instalación de Wamp (la misma situación ocurre con
Xampp). También hay que notar que la ruta del ejecutable no incluye el nombre del archivo.
Ya que hayamos agregado la ruta de PHP al PATH aceptamos, y reiniciamos el sistema. No siempre
es necesario pero normalmente el PATH no reconoce la nueva ruta hasta que el sistema haya sido
reiniciado.

Después de reiniciar comprobamos que funcione correctamente. Para ello abrimos la consola y de
nuevo ejecutamos el comando:
1. php --version

Figura 10: Consola

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 33

Deberá desplegar la información de la versión de PHP instalada en el sistema.

Figura 11: Consola
Ya que comprobamos que PHP se puede ejecutar desde cualquier ubicación, procederemos a la
instalación de PEAR.

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 34

Instalación de PEAR
El primer paso para la instalación de PEAR es descargar el siguiente archivo: go-pear.phar y copiarlo
a la carpeta del ejecutable de consola de PHP (la misma ruta que se añadió al PATH).

Figura 12: Ruta PATH

Posteriormente hay que abrir la consola, dirigirnos a la ubicación (mediante comandos “cd” más
espacio en blanco más nombre de la carpeta a abrir) y ejecutar el siguiente comando:
1. php go-pear.phar
Para evitar errores de permisos administrativos es recomendable ejecutar la consola
como Administrador
http://pear.php.net/go-pear.phar
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 35

Figura 13: Consola
El instalador nos preguntará si deseamos instalar PEAR de forma local o a nivel de sistema. La
segunda opción (de forma local) es la que viene por default, así que simplemente presionamos
“Enter”

Figura 14: Consola.

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 36

El instalador nos mostrará después una serie de rutas y nos preguntará si son correctas. En caso de
que alguna no pueda ser determinada tendremos que teclearla manualmente.

Figura 15: Consola

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 37

Presionamos “Enter” y el instalador procederá a la instalación de PEAR.

Figura 16: Consola

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 38

Es muy probable que nos aparezca una advertencia como la siguiente, informando que la ruta de
librerías instaladas mediante PEAR no se encuentra en el include_path de PHP. El instalador nos
preguntará si deseamos agregar la ruta al archivo PHP.ini.
Simplemente hay que teclear “Y” y presionar “Enter”.

Figura 17: Consola

Una vez que haya finalizado la instalación se nos avisará que se ha creado un archivo “.reg” que se
encargará de actualizar el PATH de Windows.

Figura 18: Consola
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 39

Simplemente hay que ejecutar el archivo “PEAR_ENV” para actualizar las entradas de registro. Es
probable que se nos muestre alguna advertencia pero es normal con este tipo de archivos por el
tipo de información que modifican.

Figura 19: Ventana
Presionar “Sí”

Figura 20:Mensaje

Figura 21: Mensaje

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 40

Ahora debemos comprobar que efectivamente PEAR sea accesible desde la consola. Para ello
escribimos lo siguiente en la consola:
1. pear versión

Figura 22: Consola
Se debe mostrar algo similar a lo que se aprecia en la imagen, en este caso muestra la versión de
PEAR 1.9.5, esto significa que PEAR se encuentra instalado correctamente.
Ahora procederemos a instalar PHPUnit.

Instalación de PHPUnit
Hay que abrir la consola y ejecutar lo siguiente para que PEAR identifique de forma automática las
fuentes de donde obtendrá los archivos de PHPUnit.
1. pear config-set auto_discover 1

Figura 23: Consola
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 41

A continuación hay que escribir y ejecutar lo siguiente en la consola de comandos para comenzar la
instalación de PHPUnit.
1. pear install -a pear.phpunit.de/PHPUnit
La opción -a se asegura de obtener las dependencias necesarias para la instalación.

Figura 24: Consola
Una vez que finalice la instalación ejecutamos el siguiente comando:
1. pear clear-cache
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 42

Figura 25: Consola
Este paso es opcional pero es una buena práctica que evita que existan problemas si después se
instalan otros paquetes mediante PEAR
Al igual que con PHP y PEAR, vamos a comprobar que PHPUnit se ejecute correctamente. Para ello
vamos a desplegar en consola la versión instalada mediante el siguiente comando:

Figura 26: Consola
Listo; hemos terminado de instalar PHPUnit en Windows.
Hasta aquí todo parece estar correcto pero podemos hacer una pequeña prueba con un script de
PHP.
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 43

El desarrollo guiado por pruebas es un tema muyextenso, el cuál queda fuera del objetivo del
tutorial, por lo que creamos un ejemplo muy sencillo. En el editor de nuestra preferencia vamos a
crear un archivo llamado PruebaTest.php y lo guardamos donde deseemos. El archivo deberá
contener el siguiente código:
1. <?php
2. class PruebaTest extends PHPUnit_Framework_TestCase
3. {
4. public function testPrueba()
5. {
6. $this->assertTrue(true);
7. }
8. }
9. ?>
Código 18: PruebaTest.php
En la consola de Windows navegamos hacia la ubicación del archivo y escribimos el siguiente
comando para ejecutar las pruebas que se encuentran en la clase PruebaTest; en este caso sólo
hemos definido una prueba: Test.php.
PHPUnit revisa la clase y ejecuta cada método que empiece con la palabra “test”. La consola deberá
mostrarnos un mensaje como el siguiente, indicando que la prueba se ha ejecutado correctamente.

Figura 27: Consola

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 44

Manual De PHPUnit

Con PHPUnit, lo más básico que escribiremos es un caso de prueba. Pero primero existen algunas
reglas que necesitamos considerar a la hora de escribir los casos de prueba, esto a fin de que
trabajen con PHPUnit:
 “Frecuentemente, querremos que nuestra clase de prueba extienda la clase
PHPUnit_Framework_TestCase. Esto nos dará acceso a ciertas funcionalidades como los
métodos para las pruebas setUp() y tearDown().
 El nombre de la clase de prueba debe imitar el nombre de la clase que se está probando. Por
ejemplo, en el primer ejemplo para probar RemoteConnect, utilizaremos
RemoteConnectTest, para el segundo.
 Al crear métodos de prueba, es necesario que empiecen con la palabra “test”, como
testDoesLikeWaffles(). Los métodos deben ser públicos. Podemos tener métodos privados en
las pruebas, pero no se podrán ejecutar como pruebas por PHPUnit.
 Los métodos de prueba no recibirán ningún parámetro. Cuando escribamos las pruebas, es
necesario que sean lo más autónomas posibles, tratando de que ellas mismas se necesiten.
Esto puede ser frustrante a veces, pero nos proporcionará unas pruebas más limpias y
eficaces”.(BALUART.NET, 2011)

Ejemplo #1

En el primer ejemplo vamos a crear solo una clase prueba que contenga los métodos a probar (sin
el uso de otra clase). El nombre del archivo es “ArrayTest.php” y en el caso nuestro lo guardamos
en la dirección del wampp: C:\wam_x86\www\PHP-Unit\ArrayTest.php
El proyecto tiene dos métodos:
 testNewArrayIsEmpty: Verifica que la matriz arrayTest sea vacía, es decir; que el tamaño
sea 0.
 testArrayContainsAnElement: Verifica que el tamaño de la matriz sea igual a 1.
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 45

Código 19: Ejemplo1_PHPUnit
Podrán percibir que la clase principal ArrayTest extiende la clase TestCase de PHPUnit, por lo que
una gran cantidad de funcionalidades se añaden con ella. Si notas, en el código hay un assertEquals,
esa es una de las funciones de ayuda de PHPUnit.

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 46

A continuación una lista de algunas de las funcionalidades más comunes que podemos utilizar en
nuestras pruebas:
AssertTrue/AssertFalse Comprueba la entrada para verificar si es igual a true/false
AssertEquals Comprueba el resultado frente a otra entrada en busca de
coincidencias
AssertGreaterThan Comprueba el resultado para ver si es mayor que un valor
(también hay LessThan, GreaterThanOrEqual, y
LessThanOrEqual)
AssertContains Comprueba que la entrada contiene un valor específico
AssertType Comprueba que una variable es de un cierto tipo
AssertNull Comprueba que una variable es nula
AssertFileExists Comprueba que un archivo existe
AssertRegExp Comprueba la entrada con una expresión regular
Tabla 1: Funcionalidades comunes de pruebas unitarias

Continuando con el ejemplo, ejecutar las pruebas es tan sencillo como llamar al ejecutable phpunit
y señalar las pruebas. Aquí tenemos el ejemplo de cómo llamar a nuestra prueba:
Primero en la consola de comandos nos ubicamos dentro de la carpeta donde se encuentra nuestro
código de prueba, y ejecutamos el siguiente código
phpunit ArrayTest.php
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 47

Figura 28: Consola
Por cada una de las pruebas del caso de prueba, PHPUnit se ejecuta a través de ellos y recoge
algunas estadísticas como el número de pruebas y aserciones. He aquí una vista de la salida de
nuestro ejemplo:
PHPUnit 4.0.17 by Sebastian Bergmann
.
Time: 111 ms, Memory: 3.75MB
OK(2 test, 2 assertions)
Código 20: SalidaEjemplo
Para cada prueba que ejecutamos, veremos un punto (.) si se tiene éxito (como arriba), una “F” o
una “E” si ocurrió un error, y una “I” si la prueba está marcada como incompleta o una “S” si se ha
marcado como Omitida (Skipped).

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 48

Ejemplo #2

En el segundo ejemplo, recurriremos al código encontrado en baluart.net (2011), utilizando dos
clases, la clase principal que tiene las funcionalidades del programa (el cual simplemente intentara
crear una conexión con la dirección web que le proporcionaremos desde el código de prueba).
La primera la llamaremos RemoteConnect.php

Código 21: RemoteConnect.php
Y la segunda clase que es la que contendrá la prueba unitaria y será la que ejecutemos con el phpunit
se llamara RemoteConnectTest.php

Código 22: RemoteConnectTest
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 49

En este caso utilizaremos el assertTrue que lo único que hace es comprobar que una expresión
booleana es true, es decir en nuestra prueba verifica que la conexión con el servidor sea diferente
de falso, es decir; verdadero, la prueba tendrá éxito si el programa consigue establecer la conexión,
en este caso con www.google.com.
Ejecutamos la prueba de la misma manera que la anterior.
phpunit RemoteConnectTest.php

Figura 29: Consola
Y el resultado nos muestra que la prueba fue exitosa. Ahora para variar probemos con la conexión
a una dirección web que no existe, para que el resultado de la prueba sea fallido.

Código 23: require_once
Modificamos el archivo RemoteConnectTest.php y la variable $serverName la cambiamos por una
dirección no exista o no pueda conectarse. Y volvemos a ejecutar la prueba desde la consola de
comandos.
http://www.google.com/
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 50

Figura 30: Consola
El resultado nos muestra que la prueba ha fallado.
PHPUnit 4.0.17 by Sebastian Bergmann
E
Time: 118 ms, Memory: 3.75MB
There was 1 error:
...
FAILURES!
Test: 1, Assertions:0, Errors: 1.)
Código 24: FalloPrueba

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 51

Guía de instalación y manual de uso de QUnit - Javascript

Qunit tiene la característica de que no es una herramienta que ocupe instalarse en la computadora,
más bien hay que descargar un par de archivos desde la página oficial y estos archivos hay que
llamarlos desde la página html que se desea probar, esto es una de las partes sencillas de Qunit.

1. Descargar los archivos qunit.css y qunit.jsPara esto, hay que ir a la página oficial http://qunitjs.com/ y se descargar estos dos archivos. Estos
dos archivos son la interfaz de los resultados del test.

Figura 31: QUnit:: A JavaScript Unit Testing framework

http://qunitjs.com/
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 52

2. Crear el archivo HTML
Este va ser el archivo que vamos a ejecutar para ver los resultados del test. Este archivo HTML debe
contener la referencia a los dos archivos descargados en el paso 1.

Código 25: Crear archivo HTML
Línea 6: referencia a el archivo descargado “qunit.css” descargado en el paso 1.
Línea 10 y 11: Estas dos líneas se ocupan para desplegar el resultado de las pruebas que se
llevarán a cabo.
Línea 12: Hace referencia a el archivo “qunit.js” descargado en el paso 1.
Línea 15: Referencia al archivo javaScript que posee el programa o funciones del programa.
Línea 18: Referencia a el archivo javaScript que posee los test que se desean probrar.
Esto es lo único que ocupa el archivo HTML para poder ejecutar un test.

3. Archivo de funciones (funciones.js)
Para mantener el orden, se procede a realizar un archivo.js del programa que contiene las funciones.
Y se llama (hace referencia) como se hizo en el paso anterior. En nuestro caso, el archivo de
funciones .js va ser las 4 funciones básicas de una calculadora.
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 53

Código 26: Funciones

4. Archivo de pruebas (test.js)
Este archivo también es recomendable crearlo aparte de los otros códigos y después hace referencia
a el en el archivo HTML que se debe ejecutar, como en el ejemplo del paso 2.
En nuestro caso, se crea dos módulos de pruebas, uno es para probar cuando uno de los números
de la operación está indefinido y el otro módulo prueba con ambos números definidos.

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 54

Código 27: Archivos test
5. Ejecutar el archivo HTML
Una vez hecho los pasos anteriores, ejecutamos nuestro archivo HTML para ver los resultados de la
prueba, el archivo puede ser ejecutado en cualquier navegador.

Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 55

De esta manera es que se observan los test realizados. Aquí hay varias opciones para ver los
resultados como más se desee.

● Hide passed tests: Aqui se puede esconder los test pasados satisfactoriamente.
● Check for Globals: Crea una lista de los elementos que tiene el objeto Window antes y
después del test, para después hacer una comparación.
● No try-catch: Ejecuta la prueba fuera de un try-catch para encontrar excepciones de cada
navegador en que es ejecutado.

Debajo de estas opciones, se muestra la cantidad de afirmaciones pasadas y fallidas.
En la esquina superior derecha se puede escoger la visualización de las pruebas, clasificadas por
módulos.
Después ya se muestran todos los resultados clasificados por módulo y sus funciones, al elegir una
de estas, se muestra el mensaje de cada prueba.
En el ejemplo se puede ver que cada una de las funciones probadas, fueron pasadas
satisfactoriamente. Caso contrario la respuesta sería similar a la siguiente:

Figura 32: Guia de Qunit
Pruebas unitarias (PHPUnit – PHP y QUnit – Javascript)
Araya Gómez Jeimy Pamela, Pacheco Corella Uriel Isaac & Salas Aguilar Jean Carlos
pág. 56

Figura 33: Error
Para este caso, la función suma falló porque en el test se puso que el número 5 era el que se
esperaba al sumar “2+4” por tanto no es correcto, y el resultado correcto era 6. El informe también
enseña la ubicación del archivo que tiene la falla.