pruebas unitarias para los lenguajes de programación php y javascript con las herramientas phpunit...

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


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


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


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.


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ándar de 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


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


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.


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


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.


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


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).


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


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

permitían proponer algo más.

Figura 4: History of JavaScript

http://www.maestrosdelweb.com/editorial/htmlhis/


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/


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?


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


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.


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


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.”


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.


pág. 22

Código 17: notPropEqual


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


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“.


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/


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


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


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


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


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


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


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


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.


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


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.


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


pág. 37

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

Figura 16: Consola


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


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


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


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


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.


pág. 43

El desarrollo guiado por pruebas es un tema muy extenso, 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


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.


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.


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


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).


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


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/


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


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.js

Para 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/


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.


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.


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.


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


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.

pruebas unitarias para los lenguajes de programación php y javascript con las herramientas phpunit...

Documents