No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
5 Hrs
3 Min
29 Seg

Guardando elementos

8/23
Recursos

¿Cómo podemos guardar elementos en Cypress para reutilizarlos?

La eficiencia y la reutilización del código son conceptos clave al escribir pruebas en Cypress. Saber cómo guardar y manipular elementos permite evitar la repetición innecesaria de la misma sintaxis, optimizando así el proceso de prueba. Vamos a descubrir cómo hacerlo.

¿Cuál es la diferencia entre Cypress y otras herramientas como Selenium?

En otras herramientas, como Selenium o Puppeteer, es habitual asignar elementos a variables para manipularlos posteriormente. Algo como:

let input = driver.findElement(By.name('input-name'));
// Realizar acciones con 'input'

Sin embargo, en Cypress, aunque podrías intentarlo, esto no es recomendado. Al definir las variables de esta manera y tratar de manipularlas, en muchos casos no funcionarán como se espera, especialmente cuando se tratan de validaciones o aserciones.

¿Cómo se utiliza .then() en Cypress?

Cypress proporciona un comando .then() que se asemeja al manejo de promesas en Javascript. Este comando devuelve elementos en un callback y te permite operar con ellos de forma eficaz. Por ejemplo:

cy.get('form').then(($form) => {
  // A partir del elemento 'form', buscar los 'input'
  const inputs = $form.find('input');
  expect(inputs.length).to.equal(15);
});

Este enfoque asegura que el código sea más legible y directo en su lógica de manipulación de elementos.

¿Cómo podemos usar el comando wrap en Cypress?

El comando .wrap() es vital cuando trabajamos con elementos de jQuery que Cypress te devuelve. Los elementos devueltos son manipulados como jQuery, pero si se desea que estos elementos sean nuevamente tratados bajo la sintaxis de Cypress, utilizamos .wrap().

cy.get('form').then(($form) => {
  const inputs = $form.find('input');
  cy.wrap(inputs).should('have.length', 15);
});

Esto permite acceder nuevamente a las funciones propias de Cypress sobre un elemento que inicialmente era de jQuery, ampliando así las capacidades de aserción dentro de nuestras pruebas.

¿Qué aserciones podemos usar en Cypress?

Las aserciones permiten comprobar que los elementos que estamos manipulando cumplen con nuestras expectativas. Por ejemplo, usando expect para verificar la cantidad de inputs:

expect(inputs.length).to.equal(15);

Por otro lado, usando .should() con elementos envueltos mediante wrap también podemos realizar aserciones directamente dentro del flujo de Cypress:

cy.wrap(inputs).should('have.length', 15);

Las aserciones son cruciales para verificar el correcto funcionamiento de tu aplicación y confirmar que los resultados son los esperados. En la siguiente clase, profundizaremos en los distintos tipos de aserciones para robustecer aún más las pruebas.

Recomendaciones prácticas

  • Evita las repeticiones: Usa .then() para reutilizar elementos y evitar la repetición de código.
  • Utiliza .wrap() cuando trabajes con elementos jQuery: Esto te permitirá continuar usando la sintaxis de Cypress con estos elementos.
  • Familiarízate con las aserciones: Estas son fundamentales para comprobar el comportamiento esperado de tus aplicaciones y asegurar la estabilidad del código.

Con estas herramientas y técnicas, tus pruebas en Cypress serán más eficientes y mantenibles. ¡Continúa explorando nuevas formas de mejorar tus habilidades en testing!

Aportes 13

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Yields

📚 Documentation
.
Los “Yields” son punteros producidos mediante referencias por .then. Dichas referencias son modeladas idénticamente como Promesas en JavaScript, el resultado obtenido como retorno de un then es llamado como Yield.
.

cy.get('.nav').then((nav) => {})

.
Dentro de un función callback, tendremos clousers que permite manipular la referencias con el propósito de manipular valores o realizar algunas acciones.
.
En cuyo caso que se desea cambiar la operación a comandos de Cypress, utilizamos .wrap. 📚 Documentación

cy.wrap(1)
  .then((num) => {
    cy.wrap(num).should('equal', 1) // true
  })
  .should('equal', 1) // true

.
Adicionalmente, con wrap podemos referencial:

  • Objetos
const getName = () => {
  return 'Jane Lane'
}

cy.wrap({ name: getName }).invoke('name').should('eq', 'Jane Lane')
  • Elementos
cy.get('form').within((form) => {
  cy.wrap(form).should('have.class', 'form-container')
})
  • Promesas como eventos
const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve({
      type: 'success',
      message: 'It worked!',
    })
  }, 2500)
})

it('should wait for promises to resolve', () => {
  cy.wrap(myPromise).its('message').should('eq', 'It worked!')
})

No entendí nafa =(. No es para principiantes =(

Este es un cambio muy pequeño de la versión 10

cypress v9

expect(inputs.length).to.eq(15)

cypress v10

expect(inputs.length).to.equal(15)

> > Ayer prendi esto, mas facil y util para nuestro nivel principiante, no entiendo para que una clase tan dificil.

describe(“Primer Prueba con Merkaly”, ()=>{

it(“Navegar a nuestra primer pagina”,()=>{
cy.visit(“https://www.amazon.com.br/”)
cy.get("#twotabsearchtextbox").type(“iphone 13”)
cy.get("#nav-search-submit-button").click()
cy.get("#twotabsearchtextbox").clear().type(“iphone 11”)
cy.get("#nav-search-submit-button").click()
})

})

Perdón corrijo NO es entendible, por lo menos para principiantes

Es importante actualizar el curso. Y además deberían incluirse más recursos.

De esta forma pude hacer el ejercicio.
cy.get("[placeholder=‘First Name’]").parents(‘form’).then((form)=>{
const inputs = form.find(‘input’)
const divs = form.find(‘div’)
const labels = form.find(‘label’)
expect((inputs.length)).to.equal(15)
expect((divs.length)).to.equal(70)
expect((labels.length)).to.equal(16)

    })
yo en cypress 13.15.0 hice así esta clase ```js describe('Guardando elementos', () => { it('Repeticion', () => { cy.visit('/automation-practice-form') cy.get('input[placeholder="First Name"]') .parents('form') .then((form) => { cy.wrap(form).find('label'); cy.wrap(form).find('input'); cy.wrap(form).find('div'); }); }) it('como se hace en cypress', () => { cy.visit('/automation-practice-form') cy.get('input[placeholder="First Name"]') .parents('form') .then((form) => { const inputs = form.find('input') const divs = form.find('div') const labels = form.find('label') cy.wrap(inputs).should('have.length', 15) cy.wrap(divs).should('have.length', 70) cy.wrap(labels).should('have.length', 16) }) }) }) ```describe('Guardando elementos', () => {    it('Repeticion', () => {      cy.visit('/automation-practice-form')      cy.get('input\[placeholder="First Name"]')        .parents('form')        .then((form) => {          cy.wrap(form).find('label');          cy.wrap(form).find('input');          cy.wrap(form).find('div');        });    })      it('como se hace en cypress', () => {      cy.visit('/automation-practice-form')      cy.get('input\[placeholder="First Name"]')        .parents('form')        .then((form) => {          const inputs = form.find('input')          const divs = form.find('div')          const labels = form.find('label')            cy.wrap(inputs).should('have.length', 15)          cy.wrap(divs).should('have.length', 70)          cy.wrap(labels).should('have.length', 16)        })    })  })
Mi codigo ```js Cypress.on("uncaught:exception", (err, runnable) => { // Registrar el error en la consola console.error("Excepción no capturada", err); // Devolver false aquí previene que Cypress falle la prueba return false; }); describe("Guardando elementos", () => { it("evitar repeticion", () => { cy.visit("/automation-practice-form") //Obteniendo el elemento el padre const input = cy.get('input[placeholder="First Name"]').parents("form").then((form)=>{ const inputs = form.find("input") const divs = form.find("div") const labels = form.find("label") expect(inputs.length).to.equal(15) cy.wrap(inputs).should("have.length", 15) expect(divs.length).to.equal(70) expect(labels.length).to.equal(16) }) cy.get("form").find("label") }); }); ```Cypress.on("uncaught:exception", (err, runnable) => {    // Registrar el error en la consola    console.error("Excepción no capturada", err);        // Devolver false aquí previene que Cypress falle la prueba    return false;  }); describe("Guardando elementos", () => {     it("evitar repeticion", () => {        cy.visit("/automation-practice-form")        //Obteniendo el elemento el padre         const input = cy.get('input\[placeholder="First Name"]').parents("form").then((form)=>{             const inputs = form.find("input")            const divs = form.find("div")            const labels = form.find("label")             expect(inputs.length).to.equal(15)            cy.wrap(inputs).should("have.length", 15)            expect(divs.length).to.equal(70)            expect(labels.length).to.equal(16)           })         cy.get("form").find("label")    });});
Los códigos que colocan allí los uso pero me aparece un error, no se como replicar el proceso de la clase, nada entendible la verdad, y no pude hacer nada de esta clase...
Concuerdo con Ruth Herrera la clase es entendible :(

Esta clase ayuda a evitar estar repitiendo líneas extensas de codigo (la prueba que se llama “repeticion”) y simplificar las expresiones mediante constantes

En el assert![]() de Cypress me sale la siguiente información, parents form assert expected **15** to equal **15** assert expected **70** to equal **70** assert expected **0** to equal **0** para que funcionara el cod lo dejé tal cual: expect(inputs.length).to.equal(15) expect(divs.length).to.equal(70) expect(labels.length).to.equal(0) cy.wrap(inputs).should("have.length", 15)