Tartalomjegyzék
- Mi az a Cypress Commands?
- A Cypress által biztosított felhasználói felület interakciós parancsai
- Cypress Kattintson jobb gombbal a parancsra
- Cypress Double Click Command
- Cypress Kattintson a Parancsra
- Cypress Trigger Command
- Cypress Type Command
- Cypress Select Command
- Cypress Check Command
- Cypress Clear Command
- A Cypress Commands aszinkron?
- Cypress egyéni parancsok
- Assertion parancsok láncolása a Cypressben
- Meglévő Cypress parancsok felülírása
- Cypress Chainable Commands
- Szülő egyéni parancs a Cypressben
- Gyermek egyéni parancs a Cypressben
- Kettős egyéni parancs a Cypressben
- Cypress egyéni parancsok példával
- Cypress import parancsok
- Cypress Custom Command IntelliSense
Mi az a Cypress Commands?
A Cypress API-kat és módszereket biztosít számunkra az alkalmazás felhasználói felületével való interakcióhoz. Cypress Commands néven ismertek, és segítik a webalkalmazás interakcióját. Az összes elérhető parancs beépített metódussal rendelkezik, és csak teszteseteinkben hívjuk meg a metódusokat. A Cypress parancsok hasonló műveletet szimulálnak, mint egy felhasználó, aki műveleteket próbál végrehajtani az alkalmazáson.
A Cypress által biztosított felhasználói felület interakciós parancsai
A Cypress különféle parancsokat biztosít, amelyek kölcsönhatásba lépnek a felhasználói felülettel. Részletesen megvizsgáljuk az összes parancs listáját.
- .click()
- .dblclick()
- .Jobb klikk()
- .típus()
- .egyértelmű()
- .jelölje be()
- .uncheck()
- .select()
- .trigger()
Cypress Kattintson a Parancsra
.click() – Ez a parancs az kettyenés bármely elem a DOM-on.
Az alábbiakban a click parancs szintaxisa látható
.click()
.click(options)
.click(position)
.click(position, options)
.click(xCoordinate, yCoordinate)
.click(xCoordinate, yCoordinate, options) Mint fentebb látható, a kattintás olyan paramétereket fogad el, mint pl opciók, pozíció, és a koordináták.
Opciók
A kattintáshoz átadható lehetőségek a következők
| opció | alapértelmezett | Leírás |
|---|---|---|
| altKey | hamis | Kapcsolja be az Alternatív billentyűt (Option Key Mac gépen), mint optionKey |
ctrlKey | hamis | Kapcsolja be a vezérlőgombot. Más néven: controlKey. |
| metaKey | hamis | Működteti a meta billentyűt (Windows billentyű Windowsban vagy parancsbillentyű Macen). Is: commandKey, cmdKey. |
| ShiftKey | hamis | Működteti a Shift billentyűt |
| log | igaz | Kinyomtatja a naplókat a parancssorban |
| kényszeríteni | hamis | Ez az opció kényszeríti a műveletet, és letiltja a műveletre való várakozást |
| többszörös | hamis | Kattintson egymás után több elemre |
| timeout | alapértelmezettCommandTimeout | Ideje a .click()-nek, várjon, mielőtt feloldja az időtúllépést |
| vár Animációkat | vár Animációkat | Lehetőség, hogy a parancs végrehajtása előtt várja meg, amíg az elemek befejezik az animációt |
pozíciók
A .click()-nek átadható pozíciók különböző típusai
- központ (alapértelmezett)
- balra
- jobb
- felső
- bal felső
- jobb felső
- alsó
- bal alsó
- jobb alsó
Példa
cy.get('btn').click() //a gombra kattintás cy.get('btn').click({ force: true }) //kattintás a gombra a 'force' opció true cyként való átadásával. get('btn').click('bottomRight') // kattintás a gombra a jobb alsó pozícióban cy.get('btn').click(10, 70, { force: true }) // a gombra kattintás pozíció értéke és erő igaz
Cypress Double Click Command
használatával dupla kattintás érhető el dblclick() szintaxis a Cypress nyelven.
Szintaxis
.dblclick()
.dblclick(position)
.dblclick(x, y)
.dblclick(options)
.dblclick(position, options)
.dblclick(x, y, options)Opciók
.dblclick() elfogadja az összes általa elfogadott opciót .click(). A lehetőségeket a fenti részben találja.
pozíciók
pontban megadott összes lehetséges pozíció .click() rendelkezésre állnak dblclick(). A pozíciók listája a fenti részben található.
Példa
cy.get('button').dblclick() // Dupla kattintás a gombra cy.focused().dblclick() // Dupla kattintás a fókuszált elemre cy.contains('Home').dblclick() // Dupla kattintás kattintson a 'Home' elemet tartalmazó első elemre cy.get('button').dblclick('top') // Kattintson duplán a felső pozícióban lévő gombra Kattintson duplán a 30 és 10 koordinátáira
Cypress Kattintson jobb gombbal a parancsra
Ez a Cypress parancs jobb gombbal a DOM elemre kattint .rightclick() parancs nem nyitja meg a böngésző helyi menüit.rightclick() a jobb gombbal kapcsolatos események kezelésének tesztelésére szolgál az alkalmazásban, mint pl contextmenu.
Szintaxis
.rightclick()
.rightclick(position)
.rightclick(options)
.rightclick(position, options)
.rightclick(x, y)
.rightclick(x, y, options)Opciók
Mint fentebb láttuk, az összes lehetőséget, amelyet elfogad .click() paranccsal konfigurálható .rightclick() parancsot is.
pozíciók
Az összes lehetséges pozíció, amely átadható a .rightclick() megegyezik a .click() fent emlitett.
Példa
cy.get('.welcome').rightclick() // Jobb kattintás a .welcome cy.focused().rightclick() // Jobb kattintás a fókuszált elemre cy.contains('January').rightclick() / / Kattintson jobb gombbal az első 'January' elemre cy.get('button').dblclick('topRight') // Kattintson duplán a jobb felső pozícióban lévő gombra cy.get('button').dblclick(80, 20 ) // Kattintson duplán a 80 és 20 koordinátáira
Cypress Type Command
.type() parancs értéket ír be egy DOM elembe.
Szintaxis
.type(text)
.type(text, options)érvek
.type() elfogadja a karakterláncot argumentumként. A következőnek átadott értékek .type() tartalmazhatja az alább megadott speciális karaktersorozatok bármelyikét.
| Sorozat | Megjegyzések |
|---|---|
{{} | Belép a literálba { kulcs |
{backspace} | Törli a karaktert a kurzortól jobbról balra |
{del} | Eltávolítja a karaktert a kurzor bal oldaláról jobbra |
{downarrow} | Lefelé tolja a kurzort |
{end} | A kurzort a sor végére viszi |
{enter} | Beírja az Enter billentyűt |
{esc} | Beírja az Escape billentyűt |
{home} | A kurzort a sor elejére viszi |
{insert} | A karaktert a kurzortól jobbra helyezi el |
{leftarrow} | A kurzort balra mozgatja |
{movetoend} | A kurzort a beírható elem végére viszi |
{movetostart} | A kurzort a beírható elem elejére viszi |
{pagedown} | Görget lefelé |
{pageup} | Felfelé görget |
{rightarrow} | A kurzort jobbra tolja |
{selectall} | Kijelöli az összes szöveget a létrehozásával selection range |
{uparrow} | Felfelé tolja a kurzort |
Opciók
Az objektumokat opcióként adhatjuk át, hogy módosítsuk az alapértelmezett viselkedést .type()
| opció | alapértelmezett | Leírás |
|---|---|---|
delay | 10 | Késleltetési idő opció minden gombnyomás után |
force | false | Kényszeríti a művelet végrehajtását és letiltja akcióképességre vár |
log | true | Megjeleníti a naplókat a Parancsnapló |
parseSpecialCharSequences | true | Speciális karakterek elemzése a következővel körülvett karakterláncokhoz {}, Mint például a {esc}. Beállíthatja az opciót false a szó szerinti karakterek beírásához. |
release | true | Ez az opció lehetővé teszi, hogy a módosító aktív maradjon a parancsok között |
scrollBehavior | scrollBehavior | A nézetablak pozíciója, ahol egy elemet görgetni kell a parancs végrehajtása előtt |
timeout | defaultCommandTimeout | Ideje várni .type() parancs az időkorlát előtti megoldáshoz |
waitForAnimations | waitForAnimations | Megmondani, hogy várja-e az elemeket fejezze be az animációt mielőtt bármilyen parancsot végrehajtana. |
Példa
Lássunk rá példákat .type() parancs
cy.get('textarea').type('Sziasztok') // adjon meg egy értéket a szöveges területen ('body').type('{rightarrow}') //type esemény jobbra nyíl
Cypress Clear Command
A Clear parancs törli a beviteli területen vagy a szövegmezőben lévő értékeket.
Szintaxis
A clear parancs szintaxisa a következő.
.clear()
.clear(options)Opciók
Megvizsgáljuk azokat a lehetőségeket, amelyeket át lehet adni a .clear() parancs.
| opció | alapértelmezett | Leírás |
|---|---|---|
force | false | Ez kényszeríti a műveletet, és letiltja a cselekvésre való várakozást |
log | true | Megjeleníti a parancsot a parancsnaplóban |
scrollBehavior | scrollBehavior | A nézetablak pozíciója, ahová az elemet görgetni kell a parancs végrehajtása előtt |
timeout | defaultCommandTimeout | Ez az opció a várakozás ideje .clear() idő lejárta előtt megoldani |
waitForAnimations | waitForAnimations | Ez megvárja, amíg az elemek befejezik az animációt, mielőtt végrehajtaná a parancsot. |
Példa
Nézzük meg a példákat az egyértelmű parancs érdekében
cy.get('[type="text"]').clear() // Szöveg típusú bevitel törlése cy.get('textarea').type('Üdvözöljük!').clear() // cy textarea törlése .focused().clear() // Fókuszált bemenet/szövegterület törlése
Cypress Check Command
A check parancs bejelöli, vagy egyszerűbb szavakkal kipipálja a jelölőnégyzeteket vagy a rádiógombokat. A jelölőnégyzetek vagy rádiógombok bejelölését a gombbal törölheti .uncheck() parancs.
Szintaxis
Megértjük a Cypress ellenőrzés parancsának szintaxisát.
//Syntax for check command
.check()
.check(value)
.check(options)
.check(values, options)
//Syntax for uncheck command
.uncheck()
.uncheck(value)
.uncheck(options)
.uncheck(values, options)Opciók
A check/chack parancsokhoz átadható opciók megegyeznek a fent felsorolt törlési paranccsal
Példa
Megvizsgáljuk a példát, hogyan használhatjuk a check és uncheck parancsokat.
cy.get('[type="checkbox"]').check() // Checkbox elem bejelölése cy.get('[type="radio"]').first().check() // Első rádió ellenőrzése elem cy.get('[type="radio"]').check('Male') //Ellenőrizze azt a rádióelemet, amelynek Male cy.get('[type="checkbox"]').uncheck() / /Checkbox elem cy.get('[type="radio"]').uncheck() törlése //Az első rádióelem jelölésének törlése cy.get('[type="checkbox"]').uncheck('Breakfast') // Törölje a reggeli elem jelölését
Cypress Select Command
A select Cypress parancs lehetővé teszi az elemek kiválasztását a címke.
Szintaxis
A következő a select parancs szintaxisa
.select(value)
.select(values)
.select(value, options)
.select(values, options)Opciók
Átadhatjuk azokat a beállításokat, amelyekkel módosíthatjuk a select parancs alapértelmezett viselkedését.
| opció | alapértelmezett | Leírás |
|---|---|---|
force | false | Ez az opció kényszeríti a művelet végrehajtását, és letiltja a cselekvésre való várakozást |
log | true | Megjeleníti a naplókat a parancsnaplóban, és alapértelmezés szerint igaz |
timeout | defaultCommandTimeout | Ez az opció a várakozás ideje .select() idő lejárta előtt megoldani |
Példa
Nézzünk példákat a select parancsra
cy.get('select').select('butterfly') // Válassza ki a 'pillangó' opciót cy.get('select').select(0) // kiválasztja a 0 indexű elemet cy.get('select ').select(['papagáj', 'páva']) //kiválasztja a papagáj és a páva opciót
Cypress Trigger Command
A Trigger parancs segít az elem bármely eseményének kiváltásában.
Szintaxis
Megvizsgáljuk a trigger parancs eléréséhez szükséges szintaxist
.trigger(eventName)
.trigger(eventName, position)
.trigger(eventName, x, y)
.trigger(eventName, position, options)
.trigger(eventName, options)
.trigger(eventName, x, y, options)opció
A Trigger parancs elfogadja az összes említett opciót .clear() parancs. Ezen túlmenően az alábbiakban felsorolt néhány beállítást tudjuk konfigurálni.
| opció | alapértelmezett | Leírás |
|---|---|---|
bubbles | true | Legyen-e az esemény buborékos |
cancelable | true | Az esemény lemondható-e |
eventConstructor | Event | Az eseményobjektumot létrehozó konstruktor (pl MouseEvent, keyboardEvent) |
Példa
Lássunk különböző felhasználási módokat .trigger() a kódot.
cy.get('a').trigger('mouseover') // Egéráthelyezési esemény aktiválása egy hivatkozáson cy.get('.target').trigger('mousedown', { button: 0 }) //Egérleállítás aktiválása: Button
A Cypress parancsok aszinkronban vannak?
Az összes Cypress parancs aszinkron. Egy későbbi időpontban végrehajtásra várnak, és nem várják meg a parancsok befejezését. A Cypress parancs nem csinál semmit a meghívásuk idején, hanem elmentik későbbi végrehajtásra. Megértheti a Cypress aszinkron viselkedését itt
Cypress Chainable Commands
A Cypress-ben egy sor parancsot használhatunk a DOM elemeivel való interakcióhoz. Feltétlenül meg kell érteni, hogyan működik a parancsok láncolása belsőleg. Ha egy adott sorban parancsokat láncolunk, akkor a Cypress a parancslánc alapján kezel egy ígéretet, és a tárgy alapján ad parancsot a következő parancsnak, amíg a parancslánc véget nem ér vagy hiba nem történik.
A Cypress lehetővé teszi, hogy rákattintsunk egy elemre vagy gépeljünk be elemeket a .click() or .type() parancsokat az elemek használatával cy.get() or cy.contains(). Lássunk egy egyszerű példát a parancsok láncolására
cy.get('textarea').type('Hogy vagy?')
A fenti példában cy.get() az egyik Cypress parancs és .type() egy másik parancs, ahol leláncoljuk a .type() parancsot a cy.get() parancsot, és megmondja neki, hogy gépeljen be a tárgyból, amelyet a cy.get() elem. Hasonlóképpen leláncolhatjuk az összes fent tárgyalt parancsot.
Az érvényesítési parancsok láncolása a ciprusban
Hasonlóan több parancs láncolásához a Cypress használatával, az állításokat is láncolhatjuk parancsokkal. Az állítások olyan parancsok, amelyek segítségével leírhatja a várható az alkalmazás állapota vagy viselkedése. A Cypress megvárja, amíg az elemek elérik a várt állapotot, és a teszt sikertelen lesz, ha az állítások nem felelnek meg. Meglátjuk, hogyan használhatjuk a láncolási parancsokat egy elem érvényesítéséhez.
cy.get('button').should('be.disabled') //várja, hogy a gombot le kell-e tiltani cy.get('form').should('have.class', 'form-vertical') / /elvárják, hogy az űrlap osztálya legyen-e 'form-vertical' cy.get('input').should('not.have.value', 'Name') // azt állítja, hogy a bemenetnek nem kell-e a 'Név' értéke '
A fent felsoroltak szerint a cy.get() parancsot és leláncolni a .should() Az assertion parancs az eredmény alapján elvárja a viselkedést. Így használhatjuk a láncot érvényesítési parancsok a Cypressben.
Cypress egyéni parancsok
A Cypress API-kat biztosít számunkra a parancsok létrehozásához a követelményeink alapján. A Cypress egyéni parancs hasonló az alapértelmezett parancsokhoz, amelyek már léteznek, kivéve, hogy az felhasználó által meghatározott. Egyéni parancsokkal játszhatunk a parancsokkal, és a használati esetünknek megfelelően láncolhatjuk őket. A Cypress egyéni parancsai hasznosak a munkafolyamatunkban, ha újra és újra fel kell használni őket a tesztekben.
Lássuk a szintaxist egy új egyéni parancs létrehozásához a Cypressben.
Cypress.Commands.add(name, callbackFn)
Cypress.Commands.add(name, options, callbackFn)
Cypress.Commands.overwrite(name, callbackFn)ahol az érvek a következők
név – A parancs neve a karakterláncban, amelyet hozzáadni vagy felülírni szeretnénk
visszahívásFn – Ez a függvény a parancsnak átadott argumentumot vesz fel
lehetőségek – Adjon át minden opcióobjektumot a parancs viselkedésének meghatározásához
Megjegyzések : az opciók csak az add parancsoknál támogatottak és nem támogatja a felülírási parancsokat
| opció | elfogadja | alapértelmezett | Leírás |
|---|---|---|---|
prevSubject | Boolean, String or Array | false | meghatározza, hogyan kell kezelni a korábban leadott tárgyat. |
Azok a lehetőségek, amelyek prevSubject elfogadja a következő
false- figyelmen kívül hagyja az előző tárgyakat (szülői parancs)true– elfogadja az előző tárgyakat (gyermekparancs)optional- adja meg, hogy új láncot szeretne indítani, vagy egy meglévő láncot szeretne használni (kettős parancs)
Szülő egyéni parancs a Cypressben
Meglátjuk, hogyan adhatunk hozzá egyéni szülőparancsot a Cypress-hez. A szülőparancs mindig új parancsláncot indít, még akkor is, ha egy korábbi parancsot leláncolt. A korábban láncolt parancs figyelmen kívül marad, és egy új parancs mindig láncolva lesz. Néhány szülőparancs az cy.visit(), cy.get(), cy.request(),cy.exec(), cy.route()
Példa
Példát fogunk látni arra, hogyan írjunk szülő egyéni parancsot a Cypressben
Cypress.Commands.add('clickLink', (label) => { cy.get('a').contains(label).click() }) //kattintson a "Vásárlás most" linkre cy.clickLink('Buy Most')
A fenti példában "kattintson a Link gombra' az egyéni parancsunk neve. Meg fogja keresni a címke. A 2. sorban a parancs a következőt kapja:a", és keresse meg a címkét tartalmazó hivatkozást, majd kattintson az elemre. cy.clickLink() végrehajtja a műveletet a tesztfájlban, és rákattint a „Megveszem”Link.
Gyermek egyéni parancs a Cypressben
A Cypress gyermek egyéni parancsai le vannak láncolva egy szülőparancstól vagy egy másik gyermekparancstól. Az előző parancs tárgyát a rendszer átadja a visszahívási függvénynek.
Néhány Cypress parancs, amely gyermekparancsként láncolható .click(), .trigger(), .should(), .find(), .as()
Példa
Megvizsgálunk egy példát egy gyermek egyéni parancs láncolására
Cypress.Commands.add('forceClick', {prevSubject: 'element'}, (subject, options) => { // csomagolja be a meglévő tárgyat és csináljon vele valamit cy.wrap(subject).click({force:true }) }) //a forceClick elérése a tesztfájlban cy.get("[data-test='panel-VALUES']").forceClick();
A fenti példában az egyéni parancsunkat a következőképpen nevezzük el:forceClick'. A prevSubject argumentumot átadjuk az elemnek, és becsomagoljuk a meglévő alanyt. Val vel cy.wrap(), erőltetetten rákattintunk a témára. Ezután a tesztfájlban elérjük az egyéni parancsot,forceClick' rajta cy.get() parancs.
Kettős egyéni parancsok a Cypressben
A kettős egyéni parancsok hibridek a szülő- és a gyermekparancs között. Elindíthat egy új parancsláncot, vagy leláncolhat egy meglévő parancsot. A kettős parancsok akkor hasznosak, ha azt szeretnénk, hogy a parancsunk különböző módon működjön a meglévő tárggyal vagy anélkül.
A kettős parancsokhoz használható parancsok közül néhány cy.contains(), cy.screenshot(), cy.scrollTo(), cy.wait()
Példa
Lássunk egy példát a kettős egyéni parancsok használatára
Cypress.Commands.add('getButton', { prevSubject: 'optional' }, (subject) => { if (subject) { cy.get(subject).get('btn').its('button'); } else { cy.get('btn').its('button'); } })
Bizonyos esetekben a szöveg gombját a getButton segítségével kell megszereznünk, amely az elem összes gombját megkapja. Most a getButton segítségével leláncolhatjuk a szülő elemet, vagy leláncolhatjuk a gyermek elemet, ahol meghívhatja a szülő elemeit.
Mivel a prevSubject opcionális, akkor átadhatjuk a tárgyat argumentumként, vagy meghívhatjuk a parancsot az alany nélkül a tesztfájlban az alábbiak szerint
cy.getButton() // tárgy nélkül cy.get('#loginBtn').getButton() // a tárgy nélkül
Meglévő ciprusparancsok felülírása
Felülírhatjuk a már meglévő Cypress parancsokat, és módosíthatjuk a viselkedést annak érdekében, hogy ne hozzunk létre újabb parancsot, amely a végén megpróbálja az eredeti parancsot használni.
Az eredeti Cypress parancs néhány felülírható cy.visit(), cy.type(), cy.screenshot(), cy.contains()
Példa
Lássunk egy példa arra, hogyan írhatjuk felül a meglévő Cypress-t parancs.
Cypress.Commands.overwrite('contains', (originalFn, tárgy, szűrő, szöveg, options = {}) => { // annak meghatározása, hogy átadták-e a szűrő argumentumot if (typeof text === 'object') { options = text text = filter filter = undefined } options.matchCase = false return originalFn(tárgy, szűrő, szöveg, beállítások) } )
Amint fentebb láttuk, a Cypress.Commands.overwrite a meglévő Cypress parancs módosításához. Egyéni parancsunkat így nevezzük el contains és argumentumokat adunk át annak megállapítására, hogy a szűrő argumentum átment-e.
Cypress import parancsok
Ebben a részben meg fogjuk érteni, hogyan importálhatunk Cypress parancsokat.
A Cypress egyéni parancsainkat létre kell hoznunk a cypress/support/commands.js fájlt. Adjuk hozzá az egyéni parancsokat a command.js fájlhoz, és importáljuk a teszteset fájlunkba a használatához.
Cypress egyéni parancsok példával
Meg fogjuk érteni, hogyan hozhatunk létre egyéni parancsot, és hogyan használjuk azt a specifikációs fájlunkban, valós idejű példával.
Mint fentebb láttuk, új egyéni parancsokat kell hozzáadnunk a parancsok.js fájlt. Ebben a fájlban adjunk hozzá egy egyéni parancsot egy bejelentkezési funkcióhoz
Cypress.Commands.add("login", (felhasználónév, jelszó) => { //egy login nevű új parancs hozzáadása cy.get('[id=Email]').clear(); cy.get('[id =Email]').type(felhasználónév); cy.get('[id=Jelszó]').clear(); cy.get('[id=Jelszó]').type(password); cy.get( '[type=submit]').click(); });
A fenti kódban az egyéni parancsunkat így nevezzük el Belépés. Az egyéni parancson belül hozzáadtuk a felhasználónév mező törlését és az érték beírását a szövegmezőbe. Hasonlóképpen törli a mezőt, és hozzáadja a jelszót a jelszómezőhöz. Később a küldés gombra kattintunk. Ez egy egyszerű egyéni parancs, amely két argumentumot fogad el: felhasználónév és jelszó. A specifikációs fájlunkban lévő felhasználónév és jelszó értékét továbbítjuk.
Most hozzunk létre egy specifikációs fájlt customCommand.spec.js az integrációs mappa alatt. Specifikációs fájlunk a következő kódot tartalmazza
description("Egyéni parancsok példája", () => { it("be kell jelentkezni az egyéni parancsokkal", () => { cy.visit("https://admin-demo.nopcommerce.com/"); cy .login("admin@yourstore.com", "admin"); cy.url().should('be.equal', 'https://admin-demo.nopcommerce.com/admin/') }); });
Amint fentebb láttuk, egyéni parancsunkat a következőképpen érjük el cy.login() , ahol a felhasználónév és a jelszó értékeit adjuk át.
Cypress egyéni parancsok IntelliSense
Az IntelliSense intelligens kódjavaslatokat kínál közvetlenül az IDE-ben vagy a kódszerkesztőben, miközben teszteket írunk. Segít egy felugró ablak megjelenítésével, amely megjeleníti a parancsdefiníciót, a dokumentációs oldalra mutató hivatkozást és a kódpéldákat. Ha bármilyen modern kódszerkesztőt használunk, mint a Visual Studio Code vagy az IntellJ, akkor az IntelliSense nagyon hasznos lesz.
Az IntelliSense Typescriptet használ a szintaxis megértéséhez és megjelenítéséhez. Ha egyéni parancsokat írunk, és TypeScript-definíciókat adunk meg az egyéni parancsokhoz, akkor a három perjelet használhatjuk az IntelliSense megjelenítéséhez, még akkor is, ha projektünk csak JavaScriptet használ.
Az IntelliSense konfigurálásához le kell írnunk a kódot ciprus/support/index.d.ts fájlt.
// típusdefiníciók a "cy" Cypress objektumhoz /// deklarál névtér Cypress { interface Chainable { /** * Bejelentkezés hitelesítő adatokkal * @example * cy.login(felhasználónév,jelszó) */ login(felhasználónév: String, jelszó: String): Láncolható } }
Most pedig tudatnunk kell a specifikációs fájljainkkal, hogy van néhány Typescript-definíció a index.d.ts fájlt. Tehát a specifikációs fájlunk elejéhez adja hozzá az alábbi kódot, hogy az IntelliSense javaslatokat tudjon adni nekünk.
// az olyan egyéni parancsok típusdefiníciói, mint a "login" // a "cypress/support/index.d.ts" lesz. //
Ahogy fentebb láttuk, az IntelliSense a command.js fájlunkban megadott érvekkel szolgál, és segít az automatikus kiegészítésben.
