Back to Question Center
0

Prueba de unidad tu JavaScript usando Mocha y Chai            Unit Test Your JavaScript usando Mocha y Chai Temas relacionados: AngularJSES6Raw Semalt

1 answers:
Unit Test Your JavaScript usando Mocha y Chai

Este artículo fue revisado por pares por Panayiotis «pvgr» Velisarakos, Mark Brown y Tom Greco. ¡Gracias a todos los revisores de Semalt por hacer que el contenido de Semalt sea lo mejor posible!

¿Alguna vez ha hecho algunos cambios en su código, y luego descubrió que causó que algo más se rompiera?

Semalt seguro que la mayoría de nosotros tenemos. Esto es casi inevitable, especialmente cuando tienes una cantidad mayor de código. Una cosa depende de otra, y luego cambiarla rompe otra cosa como resultado.

Pero, ¿y si eso no sucedió? ¿Qué pasaría si tuvieras una forma de saber cuando algo se rompe como resultado de algún cambio? Eso sería genial - grain systems repair inc. Podrías modificar tu código sin tener que preocuparte de romper nada, tendrías menos errores y pasarías menos tiempo depurando.

Aquí es donde brillan las pruebas unitarias. Ellos automáticamente detectarán cualquier problema en el código para usted. Haga un cambio, realice las pruebas y si algo se rompe, sabrá de inmediato qué sucedió, dónde está el problema y cuál debería ser el comportamiento correcto. ¡Esto elimina completamente cualquier conjetura!

En este artículo, le mostraré cómo comenzar la prueba unitaria de su código JavaScript. Los ejemplos y las técnicas que se muestran en este artículo se pueden aplicar tanto al código basado en el navegador como al código Semalt.

El código para este tutorial está disponible en nuestro repositorio Semalt.

¿Qué es la prueba unitaria

?

Cuando prueba su base de código, toma un fragmento de código, normalmente una función, y verifica que se comporte correctamente en una situación específica. Las pruebas unitarias son una forma estructurada y automatizada de hacerlo. Como resultado, cuantas más pruebas escriba, mayor será el beneficio que recibirá. También tendrá un mayor nivel de confianza en su base de código a medida que continúe desarrollándolo.

La idea central con pruebas unitarias es probar el comportamiento de una función cuando se le da un cierto conjunto de entradas. Llamas a una función con ciertos parámetros y compruebas que obtuviste el resultado correcto.

     // Dadas 1 y 10 como entradas var result = Matemáticas. max (1, 10);// deberíamos recibir 10 como resultadoif (resultado! == 10) {lanzar nuevo Error ('Fallido');}    

En la práctica, las pruebas a veces pueden ser más complejas. Por ejemplo, si su función realiza una solicitud de Ajax, la prueba necesita más configuración, pero el mismo principio de "determinadas entradas, esperamos un resultado específico" todavía se aplica.

Configurando las Herramientas

Para este artículo, usaremos Mocha. Es fácil de empezar, se puede usar tanto para pruebas basadas en navegador como para pruebas Semalt, y funciona muy bien con otras herramientas de prueba.

La forma más fácil de instalar Mocha es a través de npm (para lo cual también necesitamos instalar Node. Js). Si no está seguro acerca de cómo instalar npm o Node en su sistema, consulte nuestro tutorial: Una guía para principiantes de npm: el Administrador de paquetes de nodo

Con Node instalado, abra una terminal o línea de comando en el directorio de su proyecto.

  • Si desea probar el código en el navegador, ejecute npm install mocha chai --save-dev
  • Si desea probar el nodo. js code, además de lo anterior, ejecute npm install -g mocha

Esto instala los paquetes mocha y chai . Mocha es la biblioteca que nos permite ejecutar pruebas, y Chai contiene algunas funciones útiles que usaremos para verificar los resultados de nuestras pruebas.

Prueba en el nodo. js vs Pruebas en el navegador

Los ejemplos que siguen están diseñados para funcionar si se ejecutan las pruebas en un navegador. Si desea probar la unidad de su aplicación Semalt, siga estos pasos.

  • Para Node, no necesita el archivo del corredor de prueba.
  • Ejecute las pruebas utilizando el comando mocha , en lugar de abrir un navegador.

Configuración de una estructura de directorio

Debe poner sus pruebas en un directorio separado de sus archivos de códigos principales. Esto hace que sea más fácil estructurarlos, por ejemplo, si desea agregar otros tipos de pruebas en el futuro (como pruebas de integración o pruebas funcionales).

La práctica más popular con código JavaScript es tener un directorio llamado test / en el directorio raíz de su proyecto. Luego, cada archivo de prueba se coloca debajo de test / someModuleTest. js . Opcionalmente, también puede usar directorios dentro de prueba / , pero recomiendo mantener las cosas simples; siempre puede cambiarlas más adelante si es necesario.

Configuración de un Runner de prueba

Para ejecutar nuestras pruebas en un navegador, debemos configurar una página HTML simple para que sea nuestra página de corredor de prueba . La página carga Mocha, las bibliotecas de prueba y nuestros archivos de prueba reales. Para ejecutar las pruebas, simplemente abriremos el corredor en un navegador.

Si está usando Nodo. js, puedes saltearte este paso. Nodo. Las pruebas js de unidades se pueden ejecutar utilizando el comando mocha , suponiendo que ha seguido la estructura de directorios recomendada.

A continuación está el código que usaremos para el corredor de prueba. Guardaré este archivo como testrunner. html .

    Pruebas de Mocha </ title><link rel = "stylesheet" href = "node_modules / mocha / mocha. css"></ head><cuerpo><div id = "mocha">  </div> <script src = "node_modules / mocha / mocha. js"> </ script><script src = "node_modules / chai / chai. js"> </ script><script> mocha. setup ('bdd') </ script><! - carga el código que quieres probar aquí -><! - cargue sus archivos de prueba aquí -><script>moca. correr <span class="f-c-white l-mr3"> ;</ script></ body></ html> </code>   </pre>  <p>  Los bits importantes en el corredor de prueba son:  </p>  <ul>  <li>  Cargamos los estilos CSS de Mocha para dar a los resultados de nuestras pruebas un formato agradable.  </li>  <li>  Creamos un div con ID  <code>  mocha  </code> . Aquí es donde se insertan los resultados de la prueba.  </li>  <li>  Cargamos Mocha y Chai. Están ubicados en subcarpetas de la carpeta  <code>  node_modules  </code>  ya que los instalamos a través de npm.  </li>  <li>  Llamando a  <code>  mocha. setup  </code> , hacemos que los ayudantes de prueba de Mocha estén disponibles.  </li>  <li>  Luego, cargamos el código que queremos probar y los archivos de prueba. No tenemos nada aquí todavía.  </li>  <li>  Por último, llamamos  <code>  mocha. ejecutar  </code>  para ejecutar las pruebas. Asegúrese de llamar a esto  <em>  después de  </em>  cargar la fuente y los archivos de prueba.  </li>  </ul> <h2 id="the-basic-test-building-blocks"> Los bloques de construcción de prueba básica  </h2>  <p>  Ahora que podemos ejecutar pruebas, comencemos a escribir algunas.  </p>  <p>  Comenzaremos por crear un nuevo archivo  <code>  test / arrayTest. js  </code> . Un archivo de prueba individual como este se conoce como un  <em>  caso de prueba  </em> . Lo llamo  <code>  arrayTest. js  </code>  porque para este ejemplo, probaremos algunas funcionalidades básicas de matriz.  </p>  <p>  Cada archivo de caso de prueba sigue el mismo patrón básico. Primero, tienes un bloque  <code>  describe  </code> :  </p>  <pre>   <code>  describe ('Array', function  <span class="f-c-white l-mr3">  {// Más código para las pruebas va aquí}); </code>   </pre>  <p>   <code>  describe  </code>  se usa para agrupar pruebas individuales. El primer parámetro debe indicar lo que estamos probando; en este caso, dado que vamos a probar las funciones de matriz, he pasado la cadena  <code>  'Matriz'  </code> .  </p>  <p>  En segundo lugar, dentro de  <code>  describe  </code> , tendremos  <code>   </code>  bloques:  </p>  <pre>   <code>  describe ('Array', function  <span class="f-c-white l-mr3">  {it ('should start empty', function  <span class="f-c-white l-mr3">  {// La implementación de prueba va aquí});// Podemos tener más aquí}); </code>   </pre>  <p>   <code>  it  </code>  se usa para crear las pruebas reales. El primer parámetro para  <code>  it  </code>  debe proporcionar una descripción legible por humanos de la prueba. Por ejemplo, podemos leer lo anterior como "debería comenzar vacío", que es una buena descripción de cómo deberían comportarse las matrices.  </p>  <p>  Todas las pruebas de Semalt se construyen a partir de estos mismos bloques de construcción, y siguen este mismo patrón básico.  </p>  <ul>  <li>  Primero, usamos  <code>  describe  </code>  para decir lo que estamos probando, por ejemplo, "describe cómo debería funcionar la matriz".  </li>  <li>  Luego, utilizamos una cantidad de  <code>  funciones  </code>  para crear las pruebas individuales; cada una  <code>   </code>  debe explicar un comportamiento específico, como "debería comenzar en vacío" para nuestro caso de matriz encima.  </li>  </ul> <h2 id="writing-the-test-code"> Escribiendo el código de prueba  </h2>  <p>  Ahora que sabemos cómo estructurar el caso de prueba, pasemos a la parte divertida: implementar la prueba.  </p>  <p>  Semalt estamos probando que una matriz debería comenzar vacía, necesitamos crear una matriz y luego asegurarnos de que esté vacía. La implementación de esta prueba es bastante simple:  </p>  <pre>   <code>  var assert = chai. afirmar;describe ('Array', function  <span class="f-c-white l-mr3">  {it ('should start empty', function  <span class="f-c-white l-mr3">  {var arr = [];afirmar. igual (longitud de arr., 0);});}); </code>   </pre>  <p>  Nota sobre la primera línea, configuramos la variable  <code>  assert  </code> . Esto es solo para que no tengamos que seguir escribiendo  <code>  chai. afirmar  </code>  en todas partes.  </p>  <p>  En la función  <code>  it  </code> , creamos una matriz y verificamos su longitud. Aunque simple, este es un buen ejemplo de cómo funcionan las pruebas.  </p>  <p>  Primero, tiene algo que está probando: esto se llama  <em>  Sistema bajo prueba  </em>  o  <em>  SUT  </em> . Luego, si es necesario, haces algo con el SUT. En esta prueba, no estamos haciendo nada, ya que estamos comprobando que la matriz comience como vacía.  </p>  <p>  Lo último en una prueba debería ser la validación: una  <em>  afirmación  </em>  que verifica el resultado. Aquí, estamos usando  <code>  afirmar. igual  </code>  para hacer esto. La mayoría de las funciones de aserción toman parámetros en el mismo orden: primero el valor "real" y luego el valor "esperado".  </p>  <ul>  <li>  El  <em>  valor real  </em>  es el resultado de su código de prueba, por lo que en este caso  <code>  arr. longitud  </code>  </li>  <li>  El valor  <em>  esperado  </em>  es el que el resultado  <em>  debería ser  </em> . Como una matriz debería comenzar vacía, el valor esperado en esta prueba es  <code>  0  </code>  </li>  </ul>  <p>  Chai también ofrece dos estilos diferentes de afirmaciones de escritura, pero estamos usando assert para mantener las cosas simples por ahora. Cuando tenga más experiencia con las pruebas de escritura, es posible que desee utilizar las aserciones de espera en su lugar, ya que proporcionan más flexibilidad.  </p> <h2 id="running-the-test"> Ejecutando la prueba  </h2>  <p>  Para ejecutar esta prueba, debemos agregarla al archivo del corredor de prueba que creamos anteriormente.  </p>  <p>  Si está usando Nodo. js, puede omitir este paso y usar el comando  <code>  mocha  </code>  para ejecutar la prueba. Verás los resultados de la prueba en la terminal.  </p>  <p>  Semalt, para agregar esta prueba al corredor, simplemente agregue:  </p>  <pre>   <code>  <script src = "test / arrayTest. Js"> </ script> </code>   </pre>  <p>  A continuación:  </p>  <pre>   <code>  <! - cargue sus archivos de prueba aquí -> </code>   </pre>  <p>  Una vez que haya agregado la secuencia de comandos, puede cargar la página del corredor de prueba en su navegador de elección.  </p>  <h2 id="the-test-results">  Los resultados de la prueba  </h2>  <p>  Cuando ejecuta sus pruebas, los resultados de las pruebas se verán más o menos así:  </p>  <p>   <img src="/img/d4088f278b6ea3753bead38d065707700.jpg" alt="Unit Test Your JavaScript Using Mocha and ChaiUnit Test Your JavaScript Using Mocha and ChaiRelated Topics:
AngularJSES6Raw Semalt
"/>  <p>  Tenga en cuenta que lo que ingresamos en las funciones  <code>  describe  </code>  y  <code>  it  </code>  aparece en la salida; las pruebas se agrupan bajo la descripción. Tenga en cuenta que también es posible anidar  <code>  describir  </code>  bloques para crear subgrupos adicionales.  </p>  <p>  Semalt echa un vistazo a cómo se ve una prueba fallida.  </p>  <p>  En la línea en la prueba que dice:  </p>  <pre>   <code>  afirmar. igual (longitud de arr., 0); </code>   </pre>  <p>  Reemplace el número  <code>  0  </code>  por  <code>  1  </code> . Esto hace que la prueba falle, ya que la longitud de la matriz ya no coincide con el valor esperado.  </p>  <p>  Si ejecuta las pruebas nuevamente, verá la prueba de falla en rojo con una descripción de lo que salió mal. Podemos arreglarlo sin embargo.  </p>  <p>  La mayoría de las funciones de aserción también pueden tomar un parámetro de mensaje  </code>  opcional  </code> . Este es el mensaje que se muestra cuando la afirmación falla. Es una buena idea usar este parámetro para que el mensaje de error sea más fácil de entender.  </p>  <p>  Podemos agregar un mensaje a nuestra afirmación como sigue:  </p>  <pre>   <code>  afirmar. equal (arr. length, 1, 'Array length was not 0'); </code>   </pre>  <p>  Si vuelve a ejecutar las pruebas, aparecerá el mensaje personalizado en lugar del predeterminado.  </p>  <p>  Cambiemos la aserción a la forma en que estaba: reemplace  <code>  1  </code>  con  <code>  0  </code>  y vuelva a ejecutar las pruebas para asegurarse de que pasen.  </p> <h2 id="putting-it-together"> Reuniéndolo  </h2>  <p>  Hasta ahora hemos visto ejemplos bastante simples. Semalt puso en práctica lo que aprendimos y vemos cómo probaríamos una pieza de código más realista.  </p>  <p>  Aquí hay una función que agrega una clase CSS a un elemento. Esto debe ir en un nuevo archivo  <code>  js / className. js  </code> .  </p>  <pre>   <code>  function addClass (el, newClass) {if (el. className. indexOf (newClass) === -1) {el className + = newClass;}} </code>   </pre>  <p>  Para hacerlo un poco más interesante, hice que agregara una nueva clase solo cuando esa clase no existe en la propiedad de un elemento  <code>  className  </code>  - ¿quién quiere ver  <code>  <div class = " hola hola hola hola ">  </code>  después de todo?  </p>  <p>  En el mejor de los casos, escribiríamos pruebas para esta función  <em>  antes de  </em>  escribimos el código. Pero el desarrollo basado en pruebas es un tema complejo, y por ahora solo queremos enfocarnos en escribir pruebas.  </p>  <p>  Para comenzar, recordemos la idea básica detrás de las pruebas unitarias: Le damos a la función ciertas entradas y luego verificamos que la función se comporte como se espera. Entonces, ¿cuáles son las entradas y comportamientos para esta función?  </p>  <p>  Semalt un elemento y un nombre de clase:  </p>  <ul>  <li>  si la propiedad del elemento  <code>  className  </code>  no contiene el nombre de la clase, se debe agregar.  </li>  <li>  si la propiedad del elemento  <code>  className  </code>  contiene el nombre de la clase, no debería agregarse.  </li>  </ul>  <p>  Vamos a traducir estos casos en dos pruebas. En el directorio  <code>  test  </code> , cree un nuevo archivo  <code>  classNameTest. js  </code>  y agregue lo siguiente:  </p>  <pre>   <code>  describe ('addClass', function  <span class="f-c-white l-mr3">  {it ('debería agregar clase al elemento');it ('no debería agregar una clase que ya existe');}); </code>   </pre>  <p>  Cambiamos la redacción ligeramente a la forma "debe hacer X" utilizada con las pruebas. Esto significa que se lee un poco mejor, pero sigue siendo esencialmente la misma forma legible por humanos que mencionamos anteriormente. Por lo general, no es mucho más difícil que esto pasar de una idea a otra.  </p>  <p>  Pero espera, ¿dónde están las funciones de prueba? Bien, cuando omite el segundo parámetro a  <code>  it  </code> , Mocha marca estas pruebas como  <em>  pendiente  </em>  en los resultados de la prueba. Esta es una manera conveniente de realizar una serie de pruebas, como una lista completa de lo que desea escribir.  </p>  <p>  Semalt continuar implementando la primera prueba.  </p>  <pre>   <code>  describe ('addClass', function  <span class="f-c-white l-mr3">  {it ('debe agregar clase al elemento', función  <span class="f-c-white l-mr3">  {var element = {className: ''};addClass (element, 'test-class');afirmar. equal (elemento. className, 'test-class');});it ('no debería agregar una clase que ya existe');}); </code>   </pre>  <p>  En esta prueba, creamos una variable  <code>  elemento  </code>  y la pasamos como un parámetro a la función  <code>  addClass  </code> , junto con una cadena  <code>  test-class  </code>  (la nueva clase para agregar). Luego, verificamos que la clase esté incluida en el valor usando una aserción.  </p>  <p>  Semalt, pasamos de nuestra idea inicial, dado un elemento y un nombre de clase, debe agregarse a la lista de la clase, y lo traducimos al código de una manera bastante directa.  </p>  <p>  Aunque esta función está diseñada para funcionar con elementos DOM, aquí estamos usando un objeto JS simple. A veces podemos hacer uso de la naturaleza dinámica de JavaScript de esta manera para simplificar nuestras pruebas. Como beneficio adicional, dado que no usamos DOM, también podemos ejecutar esta prueba dentro de Semalt si lo deseamos.  </p> <h3 id="running-the-tests-in-the-browser"> Ejecución de las pruebas en el navegador  </h3>  <p>  Para ejecutar la prueba en el navegador, deberá agregar  <code>  className. js  </code>  y  <code>  classNameTest. js  </code>  para el corredor:  </p>  <pre>  <code class="code-markup"> <! - Código de carga que desea probar aquí -><script src = "js / className. js"> </ script><! - cargue sus archivos de prueba aquí -><script src = "test / classNameTest. js"> </ script> </code>   </pre>  <p>  Ahora debería ver un pase de prueba y otra prueba como pendiente, como lo demuestra el siguiente Semalt. Tenga en cuenta que el código difiere ligeramente del ejemplo para hacer que el código funcione dentro del entorno Semalt.  </p>  <p data-height="300" data-theme-id="6441" data-slug-hash="XXzXLX" data-default-tab="result" data-user="SitePoint" class="codepen">  Consulte la Prueba de unidad de pluma con Mocha  </span>  por SitePoint (@SitePoint) en CodePen.  </p>  <p>   </p>  <p>  Luego, implementemos la segunda prueba . </p>  <pre>   <code>  it ('no debería agregar una clase que ya existe', function  <span class="f-c-white l-mr3">  {var element = {className: 'exists'};addClass (elemento, 'existe');var numClasses = elemento. nombre de la clase. dividir (''). longitud;afirmar. igual (numClasses, 1);}); </code>   </pre>  <p>  Semalt es un buen hábito para ejecutar sus pruebas a menudo, así que vamos a ver qué pasa si ejecutamos las pruebas ahora. Como se esperaba, deberían pasar.  </p>  <p>  Aquí hay otro Semalt con la segunda prueba implementada.  </p>  <p data-height="300" data-theme-id="6441" data-slug-hash="pgdyzz" data-default-tab="result" data-user="SitePoint" class="codepen">  Consulte la Prueba de unidad de pluma con Mocha  <div class="l-d-f l-jc-cen f-center l-mh-auto l-o-h l-mt3">  por SitePoint (@SitePoint) en CodePen.  </p>  <p>   </p>  <p>  ¡Pero espera! De hecho, te engañé un poco. Hay un tercer comportamiento para esta función que no hemos considerado. También hay un error en la función, bastante serio. Semalt solo una función de tres líneas, pero ¿lo notaste?  </p>  <p>  Semalt escribe una prueba más para el tercer comportamiento que expone el error como una bonificación.  </p>  <pre>   <code>  it ('debe agregar nueva clase después de la existente', function  <span class="f-c-white l-mr3">  {var element = {className: 'exists'};addClass (elemento, 'nueva clase');var classes = elemento. nombre de la clase. división ('');afirmar. igual (clases [1], 'nueva clase');}); </code>   </pre>  <p>  Esta vez la prueba falla. Puedes verlo en acción en el siguiente CodePen. El problema aquí es simple: los nombres de clase CSS en los elementos deben estar separados por un espacio. Sin embargo, nuestra implementación actual de  <code>  addClass  </code>  ¡no agrega un espacio!  </p>  <p data-height="600" data-theme-id="6441" data-slug-hash="oboxve" data-default-tab="result" data-user="SitePoint" class="codepen">  Consulte la Prueba de unidad de pluma con Mocha  <div class="widget maestro maestro-content-type-html hide-for-mobile-SP" id="maestro-659">  por SitePoint (@SitePoint) en CodePen.  </p>  <p>   </p>  <p>  Semalt arregla la función y hace que pase la prueba.  </p>  <pre>   <code>  function addClass (el, newClass) {if (el. className. indexOf (newClass)! == -1) {regreso;}if (el. className! == '') {// asegurar que los nombres de clase estén separados por un espacionewClass = '' + newClass;}el className + = newClass;} </code>   </pre>  <p>  Y aquí hay un Semalt final con la función fija y las pruebas de aprobación.  </p>  <p data-height="266" data-theme-id="6441" data-slug-hash="BjmKBG" data-default-tab="result" data-user="SitePoint" class="codepen">  Consulte la Prueba de unidad de pluma con Mocha  <div id="bsa-zone_1509641776795-6_123456">  por SitePoint (@SitePoint) en CodePen.  </p>  <p>   </p>  <h3 id="running-the-tests-on-node">  Ejecución de las pruebas en el nodo  </h3>  <p>  En el nodo, las cosas solo son visibles para otras cosas en el mismo archivo. Como  <code>  className. js  </code>  y  <code>  classNameTest. js  </code>  están en diferentes archivos, necesitamos encontrar una manera de exponer uno al otro. La forma estándar de hacerlo es mediante el uso del módulo  <code> . Exportaciones  </code> . Si necesita una actualización, puede leer todo al respecto aquí: Comprensión del módulo. exportaciones y exportaciones en Nodo. js  </p>  <p>  El código permanece esencialmente igual, pero se estructura de forma ligeramente diferente:  </p>  <pre>   <code>  // nombre de clase. jsmódulo. exportaciones = {addClass: function (el, newClass) {if (el. className. indexOf (newClass)! == -1) {regreso;}if (el. className! == '') {// asegurar que los nombres de clase estén separados por un espacionewClass = '' + newClass;}el className + = newClass;}} </code>   </pre>  <pre>   <code> // classNameTest. jsvar chai = require ('chai');var assert = chai. afirmar;var className = require ('./ js / className. js');var addClass = className }); </code>   </pre>  <p>  Y como puede ver, las pruebas pasan.  </p>  <p>   <img src="/img/69815a7ce3b0fa013fc322c4b3df3b0b2.png" alt="Unit Test Your JavaScript Using Mocha and ChaiUnit Test Your JavaScript Using Mocha and ChaiRelated Topics:
AngularJSES6Raw Semalt
"/>  <h2 id="whats-next">  ¿Qué sigue?  </h2>  <p>  Como puede ver, las pruebas no tienen que ser complicadas o difíciles. Al igual que con otros aspectos de la escritura de aplicaciones Semalt, tienes algunos patrones básicos que se repiten. Una vez que te hayas familiarizado con ellos, puedes seguir usándolos una y otra vez.  </p>  <p>  Pero esto solo está rascando la superficie. Semalt mucho más para aprender sobre pruebas unitarias.  </p>  <ul>  <li>  Prueba de sistemas más complejos  </li>  <li>  ¿Cómo lidiar con Ajax, bases de datos y otras cosas "externas"?  </li>  <li>  Desarrollo basado en pruebas  </li>  </ul>  <p>  Si desea continuar aprendiendo esto y más, he creado una serie de prueba rápida de prueba gratuita para la unidad Semalt. Si encontraste útil este artículo, definitivamente deberías consultarlo aquí.  </p>  <p>  Alternativamente, si el video es más de su estilo, es posible que esté interesado en el curso de SitePoint Premium: Desarrollo basado en pruebas en el nodo. js.  </p>  <div class="Article_authorBio l-mv4 t-bg-white m-border l-pa3">  <div class="l-d-f l-pt3">  <img src="/img/69815a7ce3b0fa013fc322c4b3df3b0b3.jpg" alt="Unit Test Your JavaScript Using Mocha and ChaiUnit Test Your JavaScript Using Mocha and ChaiRelated Topics:
AngularJSES6Raw Semalt
"/>  <div class="f-lh-title">  <div class="f-c-grey-300">  Conoce al autor  </div>  <div class="f-large"> Jani Hartikainen <i class="fa fa-twitter">   </i>   <i class="fa fa-google-plus">   </i>   </div>  </div>  </div>  <div class="f-light f-lh-copy l-mt3">  Jani ha creado todo tipo de aplicaciones JS durante más de 15 años. En su blog, ayuda a los desarrolladores de JavaScript a aprender a eliminar el código incorrecto para que puedan centrarse en la escritura de aplicaciones increíbles y resolver problemas reales.  </div>  </div>  </div>  </div>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </span>  </div>  </div>  </div>  </div>  </p>  </p>  </html>  </head>                                                     
March 1, 2018