CursosEmpresasBlogLiveConfPrecios

Pruebas Unitarias con Jest y Vue Test Utils

Clase 10 de 12 • Curso de Testing con Vue.js 2

Contenido del curso

Introducción

  • 1

    Pruebas en Proyectos de Software con Vue y Automatización

    01:03 min
  • 2

    Pruebas Unitarias e Integración en Desarrollo de Software

    03:29 min
  • 3

    Evolución de Pruebas de Software: De Turing a la Calidad Actual

    02:16 min
  • 4

    Preparación para pruebas de proyectos Vue con NPM y Vue Test Utils

    01:11 min

Entendiendo las pruebas

  • 5

    Pruebas de Entradas y Salidas en Componentes Vue

    01:44 min

Herramientas de desarrollo

  • 6

    Pruebas unitarias en Vue con Test Utils: Introducción práctica

    02:51 min
  • 7

    Pruebas unitarias con Jest: detección de anomalías y defectos

    03:55 min

Desarrollo de pruebas

  • 8

    Aplicar TDD en Vue: Desarrollo y Pruebas de Funcionalidades

    02:15 min
  • 9

    Pruebas de Software con Mocking en Aplicaciones de JavaScript

    03:05 min
  • 10

    Pruebas Unitarias con Jest y Vue Test Utils

    Viendo ahora
  • 11

    Pruebas Unitarias y Asíncronas en Vue con $nextTick

    03:09 min

Tips y buenas prácticas

  • 12

    Pruebas Unitarias y Mocking en Vue con Jest

    02:38 min
Tomar examen

Escuelas

  • Desarrollo Web
    • Fundamentos del Desarrollo Web Profesional
    • Diseño y Desarrollo Frontend
    • Desarrollo Frontend con JavaScript
    • Desarrollo Frontend con Vue.js
    • Desarrollo Frontend con Angular
    • Desarrollo Frontend con React.js
    • Desarrollo Backend con Node.js
    • Desarrollo Backend con Python
    • Desarrollo Backend con Java
    • Desarrollo Backend con PHP
    • Desarrollo Backend con Ruby
    • Bases de Datos para Web
    • Seguridad Web & API
    • Testing Automatizado y QA para Web
    • Arquitecturas Web Modernas y Escalabilidad
    • DevOps y Cloud para Desarrolladores Web
  • English Academy
    • Inglés Básico A1
    • Inglés Básico A2
    • Inglés Intermedio B1
    • Inglés Intermedio Alto B2
    • Inglés Avanzado C1
    • Inglés para Propósitos Específicos
    • Inglés de Negocios
  • Marketing Digital
    • Fundamentos de Marketing Digital
    • Marketing de Contenidos y Redacción Persuasiva
    • SEO y Posicionamiento Web
    • Social Media Marketing y Community Management
    • Publicidad Digital y Paid Media
    • Analítica Digital y Optimización (CRO)
    • Estrategia de Marketing y Growth
    • Marketing de Marca y Comunicación Estratégica
    • Marketing para E-commerce
    • Marketing B2B
    • Inteligencia Artificial Aplicada al Marketing
    • Automatización del Marketing
    • Marca Personal y Marketing Freelance
    • Ventas y Experiencia del Cliente
    • Creación de Contenido para Redes Sociales
  • Inteligencia Artificial y Data Science
    • Fundamentos de Data Science y AI
    • Análisis y Visualización de Datos
    • Machine Learning y Deep Learning
    • Data Engineer
    • Inteligencia Artificial para la Productividad
    • Desarrollo de Aplicaciones con IA
    • AI Software Engineer
  • Ciberseguridad
    • Fundamentos de Ciberseguridad
    • Hacking Ético y Pentesting (Red Team)
    • Análisis de Malware e Ingeniería Forense
    • Seguridad Defensiva y Cumplimiento (Blue Team)
    • Ciberseguridad Estratégica
  • Liderazgo y Habilidades Blandas
    • Fundamentos de Habilidades Profesionales
    • Liderazgo y Gestión de Equipos
    • Comunicación Avanzada y Oratoria
    • Negociación y Resolución de Conflictos
    • Inteligencia Emocional y Autogestión
    • Productividad y Herramientas Digitales
    • Gestión de Proyectos y Metodologías Ágiles
    • Desarrollo de Carrera y Marca Personal
    • Diversidad, Inclusión y Entorno Laboral Saludable
    • Filosofía y Estrategia para Líderes
  • Diseño de Producto y UX
    • Fundamentos de Diseño UX/UI
    • Investigación de Usuarios (UX Research)
    • Arquitectura de Información y Usabilidad
    • Diseño de Interfaces y Prototipado (UI Design)
    • Sistemas de Diseño y DesignOps
    • Redacción UX (UX Writing)
    • Creatividad e Innovación en Diseño
    • Diseño Accesible e Inclusivo
    • Diseño Asistido por Inteligencia Artificial
    • Gestión de Producto y Liderazgo en Diseño
    • Diseño de Interacciones Emergentes (VUI/VR)
    • Desarrollo Web para Diseñadores
    • Diseño y Prototipado No-Code
  • Contenido Audiovisual
    • Fundamentos de Producción Audiovisual
    • Producción de Video para Plataformas Digitales
    • Producción de Audio y Podcast
    • Fotografía y Diseño Gráfico para Contenido Digital
    • Motion Graphics y Animación
    • Contenido Interactivo y Realidad Aumentada
    • Estrategia, Marketing y Monetización de Contenidos
  • Desarrollo Móvil
    • Fundamentos de Desarrollo Móvil
    • Desarrollo Nativo Android con Kotlin
    • Desarrollo Nativo iOS con Swift
    • Desarrollo Multiplataforma con React Native
    • Desarrollo Multiplataforma con Flutter
    • Arquitectura y Patrones de Diseño Móvil
    • Integración de APIs y Persistencia Móvil
    • Testing y Despliegue en Móvil
    • Diseño UX/UI para Móviles
  • Diseño Gráfico y Arte Digital
    • Fundamentos del Diseño Gráfico y Digital
    • Diseño de Identidad Visual y Branding
    • Ilustración Digital y Arte Conceptual
    • Diseño Editorial y de Empaques
    • Motion Graphics y Animación 3D
    • Diseño Gráfico Asistido por Inteligencia Artificial
    • Creatividad e Innovación en Diseño
  • Programación
    • Fundamentos de Programación e Ingeniería de Software
    • Herramientas de IA para el trabajo
    • Matemáticas para Programación
    • Programación con Python
    • Programación con JavaScript
    • Programación con TypeScript
    • Programación Orientada a Objetos con Java
    • Desarrollo con C# y .NET
    • Programación con PHP
    • Programación con Go y Rust
    • Programación Móvil con Swift y Kotlin
    • Programación con C y C++
    • Administración Básica de Servidores Linux
  • Negocios
    • Fundamentos de Negocios y Emprendimiento
    • Estrategia y Crecimiento Empresarial
    • Finanzas Personales y Corporativas
    • Inversión en Mercados Financieros
    • Ventas, CRM y Experiencia del Cliente
    • Operaciones, Logística y E-commerce
    • Gestión de Proyectos y Metodologías Ágiles
    • Aspectos Legales y Cumplimiento
    • Habilidades Directivas y Crecimiento Profesional
    • Diversidad e Inclusión en el Entorno Laboral
    • Herramientas Digitales y Automatización para Negocios
  • Blockchain y Web3
    • Fundamentos de Blockchain y Web3
    • Desarrollo de Smart Contracts y dApps
    • Finanzas Descentralizadas (DeFi)
    • NFTs y Economía de Creadores
    • Seguridad Blockchain
    • Ecosistemas Blockchain Alternativos (No-EVM)
    • Producto, Marketing y Legal en Web3
  • Recursos Humanos
    • Fundamentos y Cultura Organizacional en RRHH
    • Atracción y Selección de Talento
    • Cultura y Employee Experience
    • Gestión y Desarrollo de Talento
    • Desarrollo y Evaluación de Liderazgo
    • Diversidad, Equidad e Inclusión
    • AI y Automatización en Recursos Humanos
    • Tecnología y Automatización en RRHH
  • Finanzas e Inversiones
    • Fundamentos de Finanzas Personales y Corporativas
    • Análisis y Valoración Financiera
    • Inversión y Mercados de Capitales
    • Finanzas Descentralizadas (DeFi) y Criptoactivos
    • Finanzas y Estrategia para Startups
    • Inteligencia Artificial Aplicada a Finanzas
    • Domina Excel
    • Financial Analyst
    • Conseguir trabajo en Finanzas e Inversiones
  • Startups
    • Fundamentos y Validación de Ideas
    • Estrategia de Negocio y Product-Market Fit
    • Desarrollo de Producto y Operaciones Lean
    • Finanzas, Legal y Fundraising
    • Marketing, Ventas y Growth para Startups
    • Cultura, Talento y Liderazgo
    • Finanzas y Operaciones en Ecommerce
    • Startups Web3 y Blockchain
    • Startups con Impacto Social
    • Expansión y Ecosistema Startup
  • Cloud Computing y DevOps
    • Fundamentos de Cloud y DevOps
    • Administración de Servidores Linux
    • Contenerización y Orquestación
    • Infraestructura como Código (IaC) y CI/CD
    • Amazon Web Services
    • Microsoft Azure
    • Serverless y Observabilidad
    • Certificaciones Cloud (Preparación)
    • Plataforma Cloud GCP

Platzi y comunidad

  • Platzi Business
  • Live Classes
  • Lanzamientos
  • Executive Program
  • Trabaja con nosotros
  • Podcast

Recursos

  • Manual de Marca

Soporte

  • Preguntas Frecuentes
  • Contáctanos

Legal

  • Términos y Condiciones
  • Privacidad
  • Tyc promociones
Reconocimientos
Reconocimientos
Logo reconocimientoTop 40 Mejores EdTech del mundo · 2024
Logo reconocimientoPrimera Startup Latina admitida en YC · 2014
Logo reconocimientoPrimera Startup EdTech · 2018
Logo reconocimientoCEO Ganador Medalla por la Educación T4 & HP · 2024
Logo reconocimientoCEO Mejor Emprendedor del año · 2024
De LATAM conpara el mundo
YoutubeInstagramLinkedInTikTokFacebookX (Twitter)Threads

      Ya que tenemos todo listo, empezamos a probar. Vamos a eliminar todos los archivos que tenemos en nuestra carpeta de test/unit y crearemos un archivo que se llame request.spec.js (la parte de spec se pone por nomenclatura y buena práctica).

      7.png

      Dentro de este archivo importamos lo siguiente:

      6.png
      • Nuestro servicio mock.

      import { mockService } from '../../public/mockCall';

      Después empezamos con un describe y de nombre le ponemos "Fetching data from mock service".

      Dentro de este describe le creamos el siguiente test:

      1) Revisar que la promesa del servicio me está regresando los datos que quiero

      Para esto mandaremos a llamar a mockService y utilizaremos dos matchers de Jest:

      • expect.assertions()

        • Este matcher recibe un número que significará el número de validaciones que se van a hacer dentro de esta prueba.

        • Cuando estemos trabajando con código asíncrono, debemos poder ver si se está llamando o no a nuestra validación.

      • expect(Promise.resolve(promesa)).resolves

        • Regresa el valor que salió del resolve_ _de la promesa.

      Con estos matchers juntos probaremos que nuestra promesa nos regresa los datos que queremos. Nos hace falta algo más para probar estos datos y son los datos en sí, así que vamos a ir a nuestro archivo de mockCall.js y vamos a copiar el valor de la _variable pokemon _y vamos a pegarlo en otra entre nuestro describe y nuestro test.

      Nos debe de quedar algo así:

      5.png

      Repasemos lo que hicimos.

      Creamos una prueba que nos valida si la petición mock nos regresa los datos que queremos; para lograrlo, pusimos en una variable los datos que vamos a comparar y usamos el matcher .resolves para checar el resultado de la promesa.


      Segunda parte del proceso

      Ya hemos probado la parte más difícil, solamente hace falta hacer las validaciones de las demás funcionalidades que tenemos.

      Seguimos con la función de setData().

      Como en esta función nos estamos metiendo con data(), también hay que validar data().


      Creamos otro archivo llamado dataTest.spec.js en la misma carpeta donde esta el anterior archivo.

      En esta carpeta vamos a importar shallowMount del módulo de @vue/test-utils.

      Esta función, nos permite montar un componente sin cargar a los componentes hijos que tenga. Su contraparte es mount, que veremos más adelante.

      Después de hacer esto, creamos un wrapper del componente para usarlo dentro de nuestras pruebas.

      Hay que recordar que estamos haciendo pruebas unitarias, asi que vamos a probar el ¿QUÉ?

      data() contiene varias propiedades, las cuales vamos a probar que existan y que sean del tipo que nosotros queremos. Quedando nuestro código de la siguiente manera:

      describe('Testing integrity of data() properties', () => {

      test('should have name property', () => { expect(wrapper.vm.$data).toHaveProperty('name') expect(typeof wrapper.vm.name).toBe('string') }) test('should have image property', () => { expect(wrapper.vm.$data).toHaveProperty('image') expect(typeof wrapper.vm.image).toBe('string') }) test('should have type property', () => { expect(wrapper.vm.$data).toHaveProperty('type') expect(typeof wrapper.vm.type).toBe('string') }) test('should have weight property', () => { expect(wrapper.vm.$data).toHaveProperty('weight') expect(typeof wrapper.vm.weight).toBe('number') }) test('should have height property', () => { expect(wrapper.vm.$data).toHaveProperty('height') expect(typeof wrapper.vm.height).toBe('number') }) test('should have abilities property', () => { expect(wrapper.vm.$data).toHaveProperty('abilities') expect(Array.isArray(wrapper.vm.abilities)).toBeTruthy() }) })

      Si te das cuenta, en el último assert utilizamos la función Array.isArray() para que nos dé un valor booleano que podamos usar con el matcher toBeTruthy().

      Lo último que vamos a probar es que todos nuestros elementos se estén renderizando de la manera correcta.

      Añadimos un nuevo archivo llamado renderTest.spec.js y empezamos importando la función mount que mencionamos anteriormente, la cual nos permite renderizar nuestros componentes hijos.

      Empezaremos probando que los elementos del padre se renderizan.

      Estos son:

      • 2 section

      • 1 img

      • 2 p

      • 1 button

      • 1 ul

      • 1 componente poke-stats

      Los elementos de la lista, al ser dinámicos, deberemos probarlos con las pruebas de integración.

      Para hacer lo anterior, utilizaremos la función exist() e is para corroborar el tipo.

      Quedando de la siguiente manera:

      describe('Testing the correct rendering of elements', () => { const wrapper = mount(App) test('should render 2 sections', () => { expect(wrapper.find('.app-pokemon-main').exists()).toBeTruthy(); expect(wrapper.find('.app-pokemon-main').is('section')).toBeTruthy(); expect(wrapper.find('.app-pokemon-stats').exists()).toBeTruthy(); expect(wrapper.find('.app-pokemon-stats').is('section')).toBeTruthy(); }) test('should render 1 img', () => { expect(wrapper.find('img').exists()).toBeTruthy(); expect(wrapper.find('img').is('img')).toBeTruthy(); }) test('should render 2 p', () => { expect(wrapper.find('.pokemon-name').exists()).toBeTruthy(); expect(wrapper.find('.pokemon-name').is('p')).toBeTruthy(); expect(wrapper.find('#abilities').exists()).toBeTruthy(); expect(wrapper.find('#abilities').is('p')).toBeTruthy(); }) test('should render 1 button', () => { expect(wrapper.find('button').exists()).toBeTruthy(); expect(wrapper.find('button').is('button')).toBeTruthy(); }) test('should render 1 ul', () => { expect(wrapper.find('ul').exists()).toBeTruthy(); expect(wrapper.find('ul').is('ul')).toBeTruthy(); }) test('should render 1 ul', () => { expect(wrapper.find('.component').exists()).toBeTruthy(); }) })

      Te preguntarás .component, ¿qué es eso?.

      Normalmente cuando hacemos pruebas, tratamos de mantenerlas lo más modular posible, es decir, no probamos los hijos en los padres. En el caso de Vue, al no crear una etiqueta de nuestro componente, nos crea esta etiqueta con esa clase.

      Lo recomendable es no probar los hijos y si los probamos, deberiamos probar las funcionalidades internas.

      Si quieres ver como se ve esto, puedes probar poner un console.log(wrapper.html()) dentro de este describe para que veas cómo es que se renderiza todo.


      Con eso concluimos nuestras pruebas unitarias. ¿Qué es lo que probarías de inmediato en tus proyectos? Ponlo en los comentarios. En la siguiente clase aprenderemos a implementar Pruebas de Integración.

      Carlos Rafael Córdova Flores

      Carlos Rafael Córdova Flores

      student•
      hace 5 años
      Carlos Eduardo Gomez García

      Carlos Eduardo Gomez García

      teacher•
      hace 5 años
        Arlex Felipe Llanos Betancourt

        Arlex Felipe Llanos Betancourt

        student•
        hace 5 años
      Iván Antonio Bustos Calderón

      Iván Antonio Bustos Calderón

      student•
      hace 5 años
      Juan Esteban Galvis

      Juan Esteban Galvis

      student•
      hace 6 años
      Kevin Nick Pascual Tuesta

      Kevin Nick Pascual Tuesta

      student•
      hace 6 años
      Brayan Stiven Castaño Zuluaga

      Brayan Stiven Castaño Zuluaga

      student•
      hace 5 años
        Sergio Castro García

        Sergio Castro García

        student•
        hace 5 años
        Jorge Chaux

        Jorge Chaux

        student•
        hace 4 años
      Jesús Alberto Martínez Hernández

      Jesús Alberto Martínez Hernández

      student•
      hace 6 años
        Sergio Guzmán Mayorga

        Sergio Guzmán Mayorga

        student•
        hace 5 años
      Andrés Martínez González

      Andrés Martínez González

      student•
      hace 3 años
        Juan Hernandez

        Juan Hernandez

        student•
        hace 3 años
      jesus joven

      jesus joven

      student•
      hace 3 años
      Añaqui Apolinar Morales

      Añaqui Apolinar Morales

      student•
      hace 5 años
        Andrés Martínez González

        Andrés Martínez González

        student•
        hace 3 años
      Luis Miguel Mejia Martinez

      Luis Miguel Mejia Martinez

      student•
      hace 5 años
      Jose Daniel Barría Reyes

      Jose Daniel Barría Reyes

      student•
      hace 6 años
      Brayan Stiven Castaño Zuluaga

      Brayan Stiven Castaño Zuluaga

      student•
      hace 5 años
        Stiven Castillo Montero

        Stiven Castillo Montero

        student•
        hace 5 años
      Cheché Pech

      Cheché Pech

      student•
      hace 5 años

      No entendí la clase, lo sentí incompleto.

      Vale, a esta clase le hizo falta explicar algunas cosas, y siento que se pasó algunas otras cosas por alto, por ejemplo no se pusieron los código completos, ni se mostraron las partes de los import de las funciones mount pero creo que lo logré entender

      Algo IMPORTANTE

      Actualmente la función .is() está deprecada, en su lugar hay que usar element.tagName, por lo que nuestras validaciones deberían quedar así de ahora en adelante:

      expect(wrapper.find('img').element.tagName.toLowerCase() == 'img').toBeTruthy();

      Se usa al final toLoweCase porque tagName devuelve los tags en mayúscula, más información aquí:

      Correcto, para mi es mejor con el toLowerCase(), para no tener que escribir las etiquetas en mayúscula, lo de los import me pasó igual, al menos se recordó y se practicó su importación 😅

      Este capítulo es demasiado importante y no se logró explicar del todo. Tomé este curso por este módulo. Sugiero que graben este curso de nuevo con el mismo profesor.

      En la actualidad, las pruebas unitarias son extremadamente importantes para conseguir un puesto de desarrollador. Es un excluyente.

      Cambien todos los .is por:

      expect(wrapper.find('.app-pokemon-main').element.tagName).toBe('SECTION') expect(wrapper.find('.app-pokemon-stats').element.tagName).toBe('SECTION') expect(wrapper.find('img').element.tagName).toBe('IMG'); expect(wrapper.find('.pokemon-name').element.tagName).toBe('P'); expect(wrapper.find('#abilities').element.tagName).toBe('P'); expect(wrapper.find('button').element.tagName).toBe('BUTTON'); expect(wrapper.find('ul').element.tagName).toBe('UL');

      Si verifican la función tagname devuelve en mayúscula, por eso pongan en mayúscula en el toBe.

      Para aquellos que se preguntan como solucionar el error

      [vue-test-utils]: is is deprecated and will be removed in the next major version. Use element.tagName instead.

      En ves de is solo cambien en a ->

      expect(wrapper.find('.app-pokemon-main').element.tagName).toBe('SECTION')

      Y les quedara algo así.

      test('should render 2 sections', () => { expect(wrapper.find('.app-pokemon-main').exists()).toBeTruthy() expect(wrapper.find('.app-pokemon-main').element.tagName).toBe('SECTION') expect(wrapper.find('.app-pokemon-stats').exists()).toBeTruthy() expect(wrapper.find('.app-pokemon-stats').element.tagName).toBe('SECTION') })

      Aquí el código de la sección dataTest.spect.js

      import {shallowMount } from '@vue/test-utils'; import App from '@/App.vue'; const wrapper = shallowMount(App); describe('Testing of the data() properties', ()=>{ test('should have name property',()=>{ //Se valida la propiedad name de data() expect(wrapper.vm.$data).toHaveProperty('name'); //Se valida el tipo de dato de la propiedad name expect(typeof wrapper.vm.name).toBe('string'); }); test('should have image property',()=>{ //Se valida la propiedad image de data() expect(wrapper.vm.$data).toHaveProperty('image'); //Se valida el tipo de dato de la propiedad image expect(typeof wrapper.vm.image).toBe('string'); }); test('should have type property',()=>{ //Se valida la propiedad type de data() expect(wrapper.vm.$data).toHaveProperty('type'); //Se valida el tipo de dato de la propiedad type expect(typeof wrapper.vm.type).toBe('string'); }); test('should have weight property',()=>{ //Se valida la propiedad weight de data() expect(wrapper.vm.$data).toHaveProperty('weight'); //Se valida el tipo de dato de la propiedad weight expect(typeof wrapper.vm.weight).toBe('number'); }); test('should have height property',()=>{ //Se valida la propiedad height de data() expect(wrapper.vm.$data).toHaveProperty('height'); //Se valida el tipo de dato de la propiedad height expect(typeof wrapper.vm.height).toBe('number'); }) test('should have abilities property',()=>{ //Se valida la propiedad abilities de data() expect(wrapper.vm.$data).toHaveProperty('abilities'); //Se valida el tipo de dato de la propiedad abilities //preguntando si es o no un array por medio de un booleano expect(Array.isArray(wrapper.vm.abilities)).toBeTruthy(); }) })

      renderTest.spec.js

      import {mount} from '@vue/test-utils'; import App from '@/App'; const wrapper = mount(App); describe('Testing the correct rendering of elements', ()=>{ test('should render 2 sections',()=>{ //comprueba que exista la clase y luego comprueba si el elemento es un section expect(wrapper.find('.app-pokemon-main').exists()).toBeTruthy(); expect(wrapper.find('.app-pokemon-main').element.tagName.toLowerCase() == 'section').toBeTruthy(); expect(wrapper.find('.app-pokemon-stats').exists()).toBeTruthy(); expect(wrapper.find('.app-pokemon-stats').element.tagName.toLowerCase() == 'section').toBeTruthy(); }); test('should render 1 image',()=>{ //comprueba que exista la clase y luego comprueba si el elemento es un section expect(wrapper.find('img').exists()).toBeTruthy(); expect(wrapper.find('img').element.tagName.toLowerCase() == 'img').toBeTruthy(); }); test('should render 2 p',()=>{ //comprueba que exista la clase y luego comprueba si el elemento es un section expect(wrapper.find('.pokemon-name').exists()).toBeTruthy(); expect(wrapper.find('.pokemon-name').element.tagName.toLowerCase() == 'p').toBeTruthy(); expect(wrapper.find('#abilities').exists()).toBeTruthy(); expect(wrapper.find('#abilities').element.tagName.toLowerCase() == 'p').toBeTruthy(); }); test('should render 1 button', () => { expect(wrapper.find('button').exists()).toBeTruthy(); expect(wrapper.find('button').element.tagName.toLowerCase() == 'button').toBeTruthy(); }); test('should render 1 ul', () => { expect(wrapper.find('ul').exists()).toBeTruthy(); expect(wrapper.find('ul').element.tagName.toLowerCase() == 'ul').toBeTruthy(); }); test('should render 1 ul', () => { //Normalmente cuando hacemos pruebas, tratamos de mantenerlas lo más modular posible, //es decir, no probamos los hijos en los padres. //En el caso de Vue, al no crear una etiqueta de nuestro componente, //nos crea esta etiqueta con esa clase. expect(wrapper.find('.component').exists()).toBeTruthy(); }); // console.log(wrapper.html()) })```

      Muchas gracias por el aporte andaba perdido

      Gracias!

      Me marca lo siguiente, considero que esto se puede actualizar para hacerlo con la forma que te recomiendan

      console.error node_modules/@vue/test-utils/dist/vue-test-utils.js:1735 [vue-test-utils]: is is deprecated and will be removed in the next major version. Use element.tagName instead. console.error node_modules/@vue/test-utils/dist/vue-test-utils.js:1735 [vue-test-utils]: is is deprecated and will be removed in the next major version. Use element.tagName instead. console.error node_modules/@vue/test-utils/dist/vue-test-utils.js:1735 [vue-test-utils]: is is deprecated and will be removed in the next major version. Use element.tagName instead. console.error node_modules/@vue/test-utils/dist/vue-test-utils.js:1735 [vue-test-utils]: is is deprecated and will be removed in the next major version. Use element.tagName instead. console.error node_modules/@vue/test-utils/dist/vue-test-utils.js:1735 [vue-test-utils]: is is deprecated and will be removed in the next major version. Use element.tagName instead.

      Sería usar algo así:

      expect(wrapper.find('.pokemon-name').element.tagName).toBe('P');

      Para el caso del archivo request.spec.js la función toBe del resolves actualmente me marca como deprecada, la solución es usar toStrictEqual

      expect(Promise.resolve(res)).resolves.toStrictEqual(data);

      gracias anfres me sirvio no daba con la solucion de este error

      no estoy de acuerdo con las clases sin videos, así parce estar leyendo pura documentaci'on

      Me podrian apoyar sobre si esta variable le falta algo para el request.spect.js

      const data = { "mock": [ 'name', "height", "weight", "sprites", "abilities", "type" ] }

      Me parece que tienes que copear todo el contenido de la constante Pokemon del archivo mockCall.js en la constante data

      Otro tema importante en este ejemplo es que la función toBe del resolves actualmente está deprecad, nos pide usar toStrictEqual

      Entonces tu request.spec.js archivo quedaría así:

      import { mockService } from "../../public/mockCall"; describe("Fetching data from mock service", () => { test("Testing the data from the resolved promise", () => { const data = { mock: [ { data: { name: "bulbasaur", height: 7, weight: 69, sprites: "https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/1.png", abilities: ["chlorophyll", "overgrow"], type: "poison", }, }, { data: { name: "charmander", height: 6, weight: 85, sprites: "https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/4.png", abilities: ["solar-power", "blaze"], type: "fire", }, }, { data: { name: "squirtle", height: 5, weight: 90, sprites: "https://raw.githubusercontent.com/PokeAPI/sprites/master/sprites/pokemon/7.png", abilities: ["rain-dish", "torrent"], type: "water", }, }, ], }; expect.assertions(1); const res = mockService(); expect(Promise.resolve(res)).resolves.toStrictEqual(data); }); });

      El set de pruebas hecho en dataTest.spec.js, en el entorno laboral se debe hacer con cada atributo del data, o solo fue hecho con fines educativos?

      De la misma manera, lo hecho en el set de pruebas hecho en renderTest.spec.js??

      Gracias por responder.

      Lo que probaria de inmediato en mis proyectos son las properties y los requests

      Poniendo cómo ejemplo lo siguiente:

      test('should render 2 sections', () => { expect(wrapper.find('.app-pokemon-main').exists()).toBeTruthy(); expect(wrapper.find('.app-pokemon-main').is('section')).toBeTruthy(); expect(wrapper.find('.app-pokemon-stats').exists()).toBeTruthy(); expect(wrapper.find('.app-pokemon-stats').is('section')).toBeTruthy(); })

      Si tuviera que validar 10 sections, se debe hacer de la misma manera o se puede usar un for ?

      Podrías hacer una función que reciba la clase y el tipo, esa función debe devolver un true. Así se ahorra un poco de código, pero con el for tendrías que tener un arreglo con la clase y el tipo y puedes testear con test.each https://jestjs.io/docs/api#testeachtablename-fn-timeout

      Este fué un ejemplo práctico, muy bueno no sabía de esto, excelente y me pongo a pensar, en un proyecto real y enorme, hacer esto es mucha "talacha"...