சைப்ரஸ்: இணையப் பயன்பாடுகளுக்கான முழுமையான எண்ட்-டு-எண்ட் சோதனை வழிகாட்டி

இன்றைய வேகமாக மாறிவரும் இணைய மேம்பாட்டுச் சூழலில், இணையப் பயன்பாடுகளின் தரத்தையும் நம்பகத்தன்மையையும் உறுதி செய்வது மிக முக்கியம். பயனரின் பார்வையில் இருந்து ஒரு பயன்பாட்டின் அனைத்து கூறுகளும் தடையின்றி ஒன்றாகச் செயல்படுகின்றனவா என்பதைச் சரிபார்ப்பதில் எண்ட்-டு-எண்ட் (E2E) சோதனை முக்கியப் பங்கு வகிக்கிறது. சைப்ரஸ் ஒரு முன்னணி E2E சோதனை கட்டமைப்பாக உருவெடுத்துள்ளது, இது டெவலப்பர்களுக்கு ஏற்ற அனுபவம், சக்திவாய்ந்த அம்சங்கள் மற்றும் சிறந்த செயல்திறனை வழங்குகிறது. இந்த விரிவான வழிகாட்டி, சைப்ரஸைத் தொடங்குவதற்கும் உங்கள் இணையப் பயன்பாடுகளைத் திறம்படச் சோதிப்பதற்கும் தேவையான அனைத்தையும் உங்களுக்கு விளக்கும்.

சைப்ரஸ் என்றால் என்ன?

சைப்ரஸ் என்பது நவீன வலைக்காக உருவாக்கப்பட்ட ஒரு அடுத்த தலைமுறை முன்பக்க சோதனை கருவியாகும். உலாவியில் சோதனைகளை இயக்கும் பாரம்பரிய சோதனை கட்டமைப்புகளைப் போலல்லாமல், சைப்ரஸ் நேரடியாக உலாவியில் செயல்படுகிறது, இது உங்கள் பயன்பாட்டின் நடத்தை மீது இணையற்ற கட்டுப்பாட்டையும் தெரிவுநிலையையும் வழங்குகிறது. இது வேகமாகவும், நம்பகத்தன்மையுடனும், பயன்படுத்த எளிதாகவும் வடிவமைக்கப்பட்டுள்ளது, இது உலகெங்கிலும் உள்ள டெவலப்பர்கள் மற்றும் QA பொறியாளர்கள் மத்தியில் பிரபலமான தேர்வாக அமைகிறது. சைப்ரஸ் ஜாவாஸ்கிரிப்டில் எழுதப்பட்டுள்ளது மற்றும் உலாவிக்குள் இயங்குகிறது, இது மிகவும் செயல்திறன் மிக்கதாகவும், பயன்பாட்டின் உள்ளமைப்புகளுக்கு இணையற்ற அணுகலை வழங்குவதாகவும் உள்ளது.

சைப்ரஸ் பயன்படுத்துவதன் முக்கிய நன்மைகள்

• டெவலப்பர்-நட்பு: சைப்ரஸ் ஒரு தெளிவான மற்றும் உள்ளுணர்வுடன் கூடிய API-ஐ வழங்குகிறது, இது சோதனைகளை எழுதுவதையும் பிழைத்திருத்துவதையும் எளிதாக்குகிறது.
• காலப் பயணம் (Time Travel): சைப்ரஸ் ஒவ்வொரு சோதனை கட்டளையின் போதும் உங்கள் பயன்பாட்டின் நிலையின் ஸ்னாப்ஷாட்களை எடுக்கிறது, இது உங்களை காலத்தில் பின்னோக்கிச் சென்று எந்த நேரத்திலும் என்ன நடந்தது என்பதைத் துல்லியமாகக் காண அனுமதிக்கிறது.
• நிகழ்நேர ரீலோடுகள்: உங்கள் சோதனைகளில் மாற்றங்களைச் செய்யும்போது சைப்ரஸ் தானாகவே ரீலோடு ஆகிறது, இது உடனடி பின்னூட்டத்தை வழங்குகிறது.
• தானியங்கி காத்திருப்பு: சைப்ரஸ், செயல்களைச் செய்வதற்கு முன்பு கூறுகள் தெரிவதற்கோ அல்லது செயல்படுவதற்கோ தானாகவே காத்திருக்கிறது, இதனால் வெளிப்படையான காத்திருப்புகளின் தேவையை நீக்குகிறது.
• நெட்வொர்க் கட்டுப்பாடு: சைப்ரஸ் நெட்வொர்க் கோரிக்கைகள் மற்றும் பதில்களை ஸ்டப் செய்ய உங்களை அனுமதிக்கிறது, இது வெவ்வேறு சூழ்நிலைகளை உருவகப்படுத்தவும் உங்கள் பயன்பாட்டின் பிழை கையாளுதலைச் சோதிக்கவும் உதவுகிறது.
• பிழைத்திருத்தும் திறன்: சைப்ரஸ் சக்திவாய்ந்த பிழைத்திருத்தி மற்றும் விரிவான பிழைச் செய்திகள் உட்பட சிறந்த பிழைத்திருத்தும் கருவிகளை வழங்குகிறது.
• பல-உலாவி சோதனை: சைப்ரஸ் Chrome, Firefox, Edge, மற்றும் Electron உள்ளிட்ட பல உலாவிகளை ஆதரிக்கிறது.
• ஹெட்லெஸ் சோதனை: CI/CD சூழல்களில் விரைவான செயல்பாட்டிற்காக ஹெட்லெஸ் பயன்முறையில் சோதனைகளை இயக்கவும்.
• உள்ளமைக்கப்பட்ட உறுதிமொழிகள்: உங்கள் பயன்பாட்டின் எதிர்பார்க்கப்படும் நடத்தையைச் சரிபார்க்க, சைப்ரஸ் உள்ளமைக்கப்பட்ட உறுதிமொழிகளின் ஒரு வளமான தொகுப்பை வழங்குகிறது.

நிறுவுதல் மற்றும் அமைத்தல்

சைப்ரஸைத் தொடங்குவது மிகவும் எளிதானது. அதை எப்படி நிறுவுவது என்பது இங்கே:

1. முன்நிபந்தனைகள்: உங்கள் கணினியில் Node.js மற்றும் npm (Node Package Manager) நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும். அவற்றை அதிகாரப்பூர்வ Node.js இணையதளத்திலிருந்து பதிவிறக்கம் செய்யலாம்.
2. சைப்ரஸை நிறுவவும்: உங்கள் டெர்மினல் அல்லது கமெண்ட் ப்ராம்ப்ட்டைத் திறந்து, உங்கள் ப்ராஜெக்ட் கோப்பகத்திற்குச் சென்று, பின்வரும் கட்டளையை இயக்கவும்:

npm install cypress --save-dev

3. சைப்ரஸைத் திறக்கவும்: நிறுவல் முடிந்ததும், நீங்கள் சைப்ரஸ் டெஸ்ட் ரன்னரைத் திறக்க பின்வரும் கட்டளையை இயக்கலாம்:

npx cypress open

இந்தக் கட்டளை சைப்ரஸ் டெஸ்ட் ரன்னரைத் தொடங்கும், இது உங்கள் சோதனைகளை இயக்கவும் பிழைத்திருத்தவும் ஒரு வரைகலை இடைமுகத்தை வழங்குகிறது.

உங்கள் முதல் சைப்ரஸ் சோதனையை எழுதுதல்

ஒரு இணையதளத்தின் முகப்புப்பக்கம் சரியாக ஏற்றப்படுகிறதா என்பதைச் சரிபார்க்க ஒரு எளிய சோதனையை உருவாக்குவோம். உங்கள் ப்ராஜெக்ட்டின் `cypress/e2e` கோப்பகத்தில் `example.cy.js` என்ற புதிய கோப்பை உருவாக்கவும்.

// cypress/e2e/example.cy.js

describe('My First Test', () => {
  it('Visits the Kitchen Sink', () => {
    cy.visit('https://example.cypress.io')
    cy.contains('type').click()
    cy.url().should('include', '/commands/actions')

    cy.get('.action-email')
      .type('fake@email.com')
      .should('have.value', 'fake@email.com')
  })
})

இந்த சோதனையை விரிவாகப் பார்ப்போம்:

• `describe()`: இது ஒரு சோதனைத் தொகுப்பை வரையறுக்கிறது, இது தொடர்புடைய சோதனைகளின் தொகுப்பாகும்.
• `it()`: இது சோதனைத் தொகுப்பிற்குள் ஒரு தனிப்பட்ட சோதனை வழக்கினை வரையறுக்கிறது.
• `cy.visit()`: குறிப்பிட்ட URL-க்குச் செல்கிறது.
• `cy.contains()`: குறிப்பிட்ட உரையைக் கொண்ட ஒரு உறுப்பைக் கண்டறிகிறது.
• `.click()`: தேர்ந்தெடுக்கப்பட்ட உறுப்பின் மீது கிளிக் செய்கிறது.
• `cy.url()`: பக்கத்தின் தற்போதைய URL-ஐப் பெறுகிறது.
• `.should()`: பயன்பாட்டின் நிலை குறித்த ஒரு உறுதிமொழியைச் செய்கிறது.
• `cy.get()`: ஒரு CSS செலக்டரைப் பயன்படுத்தி ஒரு உறுப்பைத் தேர்ந்தெடுக்கிறது.
• `.type()`: தேர்ந்தெடுக்கப்பட்ட உறுப்பில் உரையைத் தட்டச்சு செய்கிறது.
• `.should('have.value', 'fake@email.com')`: உறுப்பின் மதிப்பு 'fake@email.com'-க்கு சமமாக இருப்பதை உறுதி செய்கிறது.

இந்த சோதனையை சைப்ரஸ் டெஸ்ட் ரன்னரில் இயக்கி, அதன் செயல்பாட்டைக் காணுங்கள். உலாவி சைப்ரஸ் கிச்சன் சிங்க் இணையதளத்திற்குச் செல்வதையும், "type" இணைப்பைக் கிளிக் செய்வதையும், URL-ஐ சரிபார்ப்பதையும் நீங்கள் காண வேண்டும்.

சைப்ரஸ் கட்டளைகள்

உங்கள் பயன்பாட்டுடன் தொடர்புகொள்வதற்கு சைப்ரஸ் பரந்த அளவிலான கட்டளைகளை வழங்குகிறது. மிகவும் பொதுவாகப் பயன்படுத்தப்படும் சில கட்டளைகள் இங்கே:

• `cy.visit(url)`: குறிப்பிட்ட URL-க்குச் செல்கிறது.
• `cy.get(selector)`: ஒரு CSS செலக்டரைப் பயன்படுத்தி ஒரு உறுப்பைத் தேர்ந்தெடுக்கிறது.
• `cy.contains(content)`: குறிப்பிட்ட உரையைக் கொண்ட ஒரு உறுப்பைத் தேர்ந்தெடுக்கிறது.
• `cy.click()`: தேர்ந்தெடுக்கப்பட்ட உறுப்பின் மீது கிளிக் செய்கிறது.
• `cy.type(text)`: தேர்ந்தெடுக்கப்பட்ட உறுப்பில் உரையைத் தட்டச்சு செய்கிறது.
• `cy.clear()`: ஒரு உள்ளீடு அல்லது டெக்ஸ்ட்ஏரியா உறுப்பின் உள்ளடக்கங்களை அழிக்கிறது.
• `cy.submit()`: ஒரு படிவத்தைச் சமர்ப்பிக்கிறது.
• `cy.check()`: ஒரு செக்பாக்ஸ் அல்லது ரேடியோ பட்டனைச் சரிபார்க்கிறது.
• `cy.uncheck()`: ஒரு செக்பாக்ஸை தேர்வுநீக்கம் செய்கிறது.
• `cy.select(value)`: ஒரு கீழ்தோன்றல் மெனுவிலிருந்து ஒரு விருப்பத்தைத் தேர்ந்தெடுக்கிறது.
• `cy.scrollTo(position)`: பக்கத்தை குறிப்பிட்ட நிலைக்கு உருட்டுகிறது.
• `cy.trigger(event)`: தேர்ந்தெடுக்கப்பட்ட உறுப்பில் ஒரு DOM நிகழ்வைத் தூண்டுகிறது.
• `cy.request(url, options)`: குறிப்பிட்ட URL-க்கு ஒரு HTTP கோரிக்கையைச் செய்கிறது.
• `cy.intercept(route, handler)`: குறிப்பிட்ட பாதையுடன் பொருந்தும் HTTP கோரிக்கைகளை இடைமறிக்கிறது.
• `cy.wait(time)`: குறிப்பிட்ட நேரத்திற்கு காத்திருக்கிறது.
• `cy.reload()`: தற்போதைய பக்கத்தை மீண்டும் ஏற்றுகிறது.
• `cy.go(direction)`: உலாவி வரலாற்றில் முந்தைய அல்லது அடுத்த பக்கத்திற்குச் செல்கிறது.
• `cy.url()`: பக்கத்தின் தற்போதைய URL-ஐப் பெறுகிறது.
• `cy.title()`: பக்கத்தின் தலைப்பைப் பெறுகிறது.
• `cy.window()`: விண்டோ ஆப்ஜெக்டைப் பெறுகிறது.
• `cy.document()`: டாக்குமெண்ட் ஆப்ஜெக்டைப் பெறுகிறது.
• `cy.viewport(width, height)`: வியூபோர்ட் அளவை அமைக்கிறது.

இவை சைப்ரஸில் கிடைக்கும் பல கட்டளைகளில் சில மட்டுமே. கட்டளைகள் மற்றும் அவற்றின் விருப்பங்களின் முழுமையான பட்டியலுக்கு சைப்ரஸ் ஆவணங்களைப் பார்க்கவும்.

சைப்ரஸில் உறுதிமொழிகள்

உங்கள் பயன்பாட்டின் எதிர்பார்க்கப்படும் நடத்தையைச் சரிபார்க்க உறுதிமொழிகள் பயன்படுத்தப்படுகின்றன. சைப்ரஸ், உறுப்புகளின் நிலை, URL, தலைப்பு மற்றும் பலவற்றைச் சரிபார்க்க நீங்கள் பயன்படுத்தக்கூடிய உள்ளமைக்கப்பட்ட உறுதிமொழிகளின் ஒரு வளமான தொகுப்பை வழங்குகிறது. உறுதிமொழிகள் `.should()` முறையைப் பயன்படுத்தி சைப்ரஸ் கட்டளைகளுக்குப் பிறகு சங்கிலித் தொடராக இணைக்கப்படுகின்றன.

சில பொதுவான உறுதிமொழி எடுத்துக்காட்டுகள் இங்கே:

• `.should('be.visible')`: ஒரு உறுப்பு தெரிகிறது என்பதை உறுதி செய்கிறது.
• `.should('not.be.visible')`: ஒரு உறுப்பு தெரியவில்லை என்பதை உறுதி செய்கிறது.
• `.should('be.enabled')`: ஒரு உறுப்பு இயக்கப்பட்டது என்பதை உறுதி செய்கிறது.
• `.should('be.disabled')`: ஒரு உறுப்பு முடக்கப்பட்டது என்பதை உறுதி செய்கிறது.
• `.should('have.text', 'expected text')`: ஒரு உறுப்பில் குறிப்பிட்ட உரை உள்ளது என்பதை உறுதி செய்கிறது.
• `.should('contain', 'expected text')`: ஒரு உறுப்பு குறிப்பிட்ட உரையைக் கொண்டுள்ளது என்பதை உறுதி செய்கிறது.
• `.should('have.value', 'expected value')`: ஒரு உறுப்பு குறிப்பிட்ட மதிப்பைக் கொண்டுள்ளது என்பதை உறுதி செய்கிறது.
• `.should('have.class', 'expected class')`: ஒரு உறுப்பு குறிப்பிட்ட வகுப்பைக் கொண்டுள்ளது என்பதை உறுதி செய்கிறது.
• `.should('have.attr', 'attribute name', 'expected value')`: ஒரு உறுப்பு குறிப்பிட்ட பண்புக்கூறு மற்றும் மதிப்பைக் கொண்டுள்ளது என்பதை உறுதி செய்கிறது.
• `.should('have.css', 'css property', 'expected value')`: ஒரு உறுப்பு குறிப்பிட்ட CSS பண்பு மற்றும் மதிப்பைக் கொண்டுள்ளது என்பதை உறுதி செய்கிறது.
• `.should('have.length', expected length)`: ஒரு உறுப்பு குறிப்பிட்ட நீளத்தைக் கொண்டுள்ளது என்பதை உறுதி செய்கிறது (எ.கா., ஒரு பட்டியலில் உள்ள உறுப்புகளின் எண்ணிக்கை).

உங்கள் குறிப்பிட்ட தேவைகளுக்கு ஏற்ப தனிப்பயன் உறுதிமொழிகளையும் நீங்கள் உருவாக்கலாம்.

சைப்ரஸ் சோதனைகளை எழுதுவதற்கான சிறந்த நடைமுறைகள்

சிறந்த நடைமுறைகளைப் பின்பற்றுவது, பராமரிக்கக்கூடிய, நம்பகமான மற்றும் திறமையான சைப்ரஸ் சோதனைகளை எழுத உங்களுக்கு உதவும். சில பரிந்துரைகள் இங்கே:

• தெளிவான மற்றும் சுருக்கமான சோதனைகளை எழுதுங்கள்: ஒவ்வொரு சோதனையும் ஒரு குறிப்பிட்ட செயல்பாடு அல்லது சூழ்நிலையில் கவனம் செலுத்த வேண்டும். புரிந்துகொள்வதற்கும் பராமரிப்பதற்கும் கடினமான மிகவும் சிக்கலான சோதனைகளை எழுதுவதைத் தவிர்க்கவும்.
• அர்த்தமுள்ள சோதனைப் பெயர்களைப் பயன்படுத்துங்கள்: உங்கள் சோதனைகளுக்கு அவை எதைச் சோதிக்கின்றன என்பதைத் தெளிவாகக் குறிக்கும் விளக்கமான பெயர்களைக் கொடுங்கள்.
• மதிப்புகளை ஹார்ட்கோடிங் செய்வதைத் தவிர்க்கவும்: காலப்போக்கில் மாறக்கூடிய மதிப்புகளைச் சேமிக்க மாறிகள் அல்லது உள்ளமைவுக் கோப்புகளைப் பயன்படுத்தவும்.
• தனிப்பயன் கட்டளைகளைப் பயன்படுத்துங்கள்: மீண்டும் பயன்படுத்தக்கூடிய தர்க்கத்தை இணைக்கவும் உங்கள் சோதனைகளை மேலும் படிக்கக்கூடியதாக மாற்றவும் தனிப்பயன் கட்டளைகளை உருவாக்கவும்.
• சோதனைகளைத் தனிமைப்படுத்துங்கள்: ஒவ்வொரு சோதனையும் மற்ற சோதனைகளிலிருந்து சுயாதீனமாக இருக்க வேண்டும். முந்தைய சோதனைகளிலிருந்து பயன்பாட்டின் நிலையைச் சார்ந்திருப்பதைத் தவிர்க்கவும்.
• சோதனைகளுக்குப் பிறகு சுத்தம் செய்யுங்கள்: ஒவ்வொரு சோதனைக்குப் பிறகும் பயன்பாட்டின் நிலையை மீட்டமைக்கவும், அடுத்தடுத்த சோதனைகள் ஒரு சுத்தமான நிலையில் இருந்து தொடங்குவதை உறுதிசெய்யவும்.
• தரவு பண்புக்கூறுகளைப் பயன்படுத்துங்கள்: உங்கள் சோதனைகளில் உறுப்புகளைத் தேர்ந்தெடுக்க தரவு பண்புக்கூறுகளைப் பயன்படுத்தவும் (எ.கா., `data-testid`). தரவு பண்புக்கூறுகள் CSS வகுப்புகள் அல்லது ID-க்களை விட மாறுவதற்கான வாய்ப்புகள் குறைவு, இது உங்கள் சோதனைகளை UI-இல் ஏற்படும் மாற்றங்களுக்கு மேலும் நெகிழக்கூடியதாக மாற்றுகிறது.
• வெளிப்படையான காத்திருப்புகளைத் தவிர்க்கவும்: சைப்ரஸ் தானாகவே உறுப்புகள் தெரிவதற்கோ அல்லது செயல்படுவதற்கோ காத்திருக்கிறது. முற்றிலும் அவசியமின்றி வெளிப்படையான காத்திருப்புகளைப் பயன்படுத்துவதைத் தவிர்க்கவும் (எ.கா., `cy.wait()`).
• பயனர் ஓட்டங்களைச் சோதிக்கவும்: தனிப்பட்ட கூறுகளை விட பயனர் ஓட்டங்களைச் சோதிப்பதில் கவனம் செலுத்துங்கள். இது உங்கள் பயன்பாடு பயனரின் பார்வையில் இருந்து சரியாகச் செயல்படுவதை உறுதிசெய்ய உதவும்.
• சோதனைகளைத் தவறாமல் இயக்கவும்: சைப்ரஸ் சோதனைகளை உங்கள் CI/CD பைப்லைனில் ஒருங்கிணைத்து, மேம்பாட்டுச் செயல்பாட்டில் ஆரம்பத்திலேயே பிழைகளைக் கண்டறிய அவற்றைத் தவறாமல் இயக்கவும்.

மேம்பட்ட சைப்ரஸ் நுட்பங்கள்

ஸ்டப்பிங் மற்றும் மாக்கிங்

சைப்ரஸ் நெட்வொர்க் கோரிக்கைகள் மற்றும் பதில்களை ஸ்டப் செய்ய உங்களை அனுமதிக்கிறது, இது வெவ்வேறு சூழ்நிலைகளை உருவகப்படுத்தவும் உங்கள் பயன்பாட்டின் பிழை கையாளுதலைச் சோதிக்கவும் உதவுகிறது. வெளிப்புற API-கள் அல்லது சேவைகளைச் சார்ந்திருக்கும் அம்சங்களைச் சோதிக்க இது மிகவும் பயனுள்ளதாக இருக்கும்.

ஒரு நெட்வொர்க் கோரிக்கையை ஸ்டப் செய்ய, நீங்கள் `cy.intercept()` கட்டளையைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, கீழே உள்ள குறியீடு `/api/users`-க்கு ஒரு GET கோரிக்கையை ஸ்டப் செய்து ஒரு மாக் பதிலை வழங்குகிறது:

cy.intercept('GET', '/api/users', {
  statusCode: 200,
  body: [
    { id: 1, name: 'John Doe' },
    { id: 2, name: 'Jane Doe' }
  ]
}).as('getUsers')

பின்னர் நீங்கள் `cy.wait('@getUsers')` ஐப் பயன்படுத்தி இடைமறிக்கப்பட்ட கோரிக்கைக்காகக் காத்திருக்கலாம் மற்றும் உங்கள் பயன்பாடு மாக் பதிலைச் சரியாகக் கையாள்கிறதா என்பதைச் சரிபார்க்கலாம்.

உள்ளூர் சேமிப்பகம் மற்றும் குக்கீகளுடன் பணிபுரிதல்

சைப்ரஸ் உள்ளூர் சேமிப்பகம் மற்றும் குக்கீகளுடன் தொடர்புகொள்வதற்கான கட்டளைகளை வழங்குகிறது. உங்கள் சோதனைகளில் உள்ளூர் சேமிப்பகம் மற்றும் குக்கீகளை அமைக்க, பெற மற்றும் அழிக்க இந்தக் கட்டளைகளைப் பயன்படுத்தலாம்.

ஒரு உள்ளூர் சேமிப்பக உருப்படியை அமைக்க, நீங்கள் `cy.window()` கட்டளையைப் பயன்படுத்தி விண்டோ ஆப்ஜெக்டை அணுகி, பின்னர் `localStorage.setItem()` முறையைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக:

cy.window().then((win) => {
  win.localStorage.setItem('myKey', 'myValue')
})

ஒரு உள்ளூர் சேமிப்பக உருப்படியைப் பெற, நீங்கள் `cy.window()` கட்டளையைப் பயன்படுத்தி, பின்னர் `localStorage.getItem()` முறையைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக:

cy.window().then((win) => {
  const value = win.localStorage.getItem('myKey')
  expect(value).to.equal('myValue')
})

ஒரு குக்கீயை அமைக்க, நீங்கள் `cy.setCookie()` கட்டளையைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக:

cy.setCookie('myCookie', 'myCookieValue')

ஒரு குக்கீயைப் பெற, நீங்கள் `cy.getCookie()` கட்டளையைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக:

cy.getCookie('myCookie').should('have.property', 'value', 'myCookieValue')

கோப்பு பதிவேற்றங்களைக் கையாளுதல்

சைப்ரஸ் `cypress-file-upload` என்ற ஒரு செருகுநிரலை வழங்குகிறது, இது உங்கள் சோதனைகளில் கோப்பு பதிவேற்றங்களை எளிதாக்குகிறது. செருகுநிரலை நிறுவ, பின்வரும் கட்டளையை இயக்கவும்:

npm install -D cypress-file-upload

பின்னர், உங்கள் `cypress/support/commands.js` கோப்பில் பின்வரும் வரியைச் சேர்க்கவும்:

import 'cypress-file-upload';

பின்னர் நீங்கள் `cy.uploadFile()` கட்டளையைப் பயன்படுத்தி ஒரு கோப்பைப் பதிவேற்றலாம். எடுத்துக்காட்டாக:

cy.get('input[type="file"]').attachFile('example.txt')

IFrame-களுடன் பணிபுரிதல்

IFrame-களைச் சோதிப்பது தந்திரமானதாக இருக்கலாம், ஆனால் சைப்ரஸ் அவற்றுடன் தொடர்புகொள்வதற்கான ஒரு வழியை வழங்குகிறது. ஒரு IFrame ஏற்றுவதற்கு காத்திருக்க `cy.frameLoaded()` கட்டளையைப் பயன்படுத்தலாம், பின்னர் IFrame-ன் டாக்குமெண்ட் ஆப்ஜெக்டைப் பெற `cy.iframe()` கட்டளையைப் பயன்படுத்தலாம்.

cy.frameLoaded('#myIframe')
cy.iframe('#myIframe').find('button').click()

சைப்ரஸ் மற்றும் தொடர்ச்சியான ஒருங்கிணைப்பு/தொடர்ச்சியான வரிசைப்படுத்தல் (CI/CD)

உங்கள் CI/CD பைப்லைனில் சைப்ரஸை ஒருங்கிணைப்பது உங்கள் பயன்பாட்டின் தரத்தை உறுதிப்படுத்த அவசியம். உங்கள் CI/CD சூழலில் சைப்ரஸ் சோதனைகளை ஹெட்லெஸ் பயன்முறையில் இயக்கலாம். அது எப்படி என்பது இங்கே:

1. சைப்ரஸை நிறுவவும்: உங்கள் ப்ராஜெக்ட்டில் சைப்ரஸ் ஒரு சார்புநிலையாக நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும்.
2. CI/CD-ஐ உள்ளமைக்கவும்: ஒவ்வொரு பில்டுக்குப் பிறகும் சைப்ரஸ் சோதனைகளை இயக்க உங்கள் CI/CD பைப்லைனை உள்ளமைக்கவும்.
3. சைப்ரஸை ஹெட்லெஸ் முறையில் இயக்கவும்: சைப்ரஸ் சோதனைகளை ஹெட்லெஸ் பயன்முறையில் இயக்க `cypress run` கட்டளையைப் பயன்படுத்தவும்.

எடுத்துக்காட்டு CI/CD உள்ளமைவு (GitHub Actions பயன்படுத்தி):

name: Cypress Tests

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  cypress-run:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: 16
      - name: Install dependencies
        run: npm install
      - name: Cypress run
        uses: cypress-io/github-action@v5
        with:
          start: npm start
          wait-on: 'http://localhost:3000'

இந்த உள்ளமைவு, `main` கிளைக்கு குறியீடு புஷ் செய்யப்படும்போதோ அல்லது `main` கிளைக்கு எதிராக ஒரு புல் கோரிக்கை உருவாக்கப்படும்போதோ சைப்ரஸ் சோதனைகளை இயக்கும். `cypress-io/github-action` செயல்பாடு GitHub Actions-இல் சைப்ரஸ் சோதனைகளை இயக்கும் செயல்முறையை எளிதாக்குகிறது.

சைப்ரஸ் சோதனைகளைப் பிழைத்திருத்துதல்

உங்கள் சோதனைகளில் உள்ள சிக்கல்களைக் கண்டறிந்து சரிசெய்ய உங்களுக்கு உதவ சைப்ரஸ் சிறந்த பிழைத்திருத்தும் கருவிகளை வழங்குகிறது. சைப்ரஸ் சோதனைகளைப் பிழைத்திருத்துவதற்கான சில குறிப்புகள் இங்கே:

• சைப்ரஸ் டெஸ்ட் ரன்னரைப் பயன்படுத்தவும்: சைப்ரஸ் டெஸ்ட் ரன்னர் உங்கள் சோதனைகளை இயக்கவும் பிழைத்திருத்தவும் ஒரு காட்சி இடைமுகத்தை வழங்குகிறது. நீங்கள் உங்கள் சோதனைகளை ஒரு நேரத்தில் ஒரு கட்டளையாகச் செல்லலாம், பயன்பாட்டின் நிலையை ஆய்வு செய்யலாம், மற்றும் விரிவான பிழைச் செய்திகளைக் காணலாம்.
• `cy.pause()` கட்டளையைப் பயன்படுத்தவும்: `cy.pause()` கட்டளை உங்கள் சோதனையின் செயல்பாட்டை இடைநிறுத்தி, உலாவியின் டெவலப்பர் கருவிகளில் பயன்பாட்டின் நிலையை ஆய்வு செய்ய உங்களை அனுமதிக்கிறது.
• `cy.debug()` கட்டளையைப் பயன்படுத்தவும்: `cy.debug()` கட்டளை தேர்ந்தெடுக்கப்பட்ட உறுப்பை கன்சோலில் அச்சிடுகிறது, அதன் பண்புகள் மற்றும் பண்புக்கூறுகளை ஆய்வு செய்ய உங்களை அனுமதிக்கிறது.
• உலாவியின் டெவலப்பர் கருவிகளைப் பயன்படுத்தவும்: உலாவியின் டெவலப்பர் கருவிகள் DOM, நெட்வொர்க் கோரிக்கைகள், மற்றும் கன்சோல் பதிவுகள் உட்பட உங்கள் பயன்பாடு பற்றிய ஏராளமான தகவல்களை வழங்குகின்றன.
• பிழைச் செய்திகளை கவனமாகப் படியுங்கள்: சைப்ரஸ் பிழையின் காரணத்தைக் கண்டறிய உதவும் விரிவான பிழைச் செய்திகளை வழங்குகிறது. பிழைச் செய்தி மற்றும் ஸ்டாக் ட்ரேஸில் கவனம் செலுத்துங்கள்.

சைப்ரஸ் மற்றும் பிற சோதனை கட்டமைப்புகள்

சைப்ரஸ் ஒரு சக்திவாய்ந்த எண்ட்-டு-எண்ட் சோதனை கட்டமைப்பாக இருந்தாலும், அது மற்ற பிரபலமான விருப்பங்களுடன் எவ்வாறு ஒப்பிடுகிறது என்பதைப் புரிந்துகொள்வது அவசியம். இங்கே ஒரு சுருக்கமான கண்ணோட்டம்:

• செலினியம் (Selenium): செலினியம் பரவலாகப் பயன்படுத்தப்படும் ஒரு ஆட்டோமேஷன் சோதனை கட்டமைப்பாகும். நெகிழ்வானதாகவும் பல மொழிகளை ஆதரிப்பதாகவும் இருந்தாலும், அதை அமைப்பதும் பராமரிப்பதும் சிக்கலானதாக இருக்கலாம். சைப்ரஸ், குறிப்பாக ஜாவாஸ்கிரிப்ட் அடிப்படையிலான பயன்பாடுகளுக்கு எளிமையான மற்றும் டெவலப்பர்களுக்கு ஏற்ற அனுபவத்தை வழங்குகிறது.
• பப்படியர் (Puppeteer): பப்படியர் என்பது ஹெட்லெஸ் Chrome அல்லது Chromium-ஐக் கட்டுப்படுத்த உயர்-நிலை API-ஐ வழங்கும் ஒரு Node நூலகமாகும். இது ஸ்கிராப்பிங் மற்றும் உலாவி பணிகளை தானியக்கமாக்குவதற்கு சிறந்தது, ஆனால் எண்ட்-டு-எண்ட் சோதனைக்கு சைப்ரஸுடன் ஒப்பிடும்போது அதிக கைமுறை உள்ளமைவு தேவைப்படலாம்.
• பிளேரைட் (Playwright): பிளேரைட் என்பது மைக்ரோசாப்ட் உருவாக்கிய மற்றொரு பல-உலாவி ஆட்டோமேஷன் கட்டமைப்பாகும். இது பப்படியருடன் ஒற்றுமைகளைப் பகிர்ந்து கொள்கிறது ஆனால் பரந்த உலாவி ஆதரவை வழங்குகிறது. சைப்ரஸ் ஒரு தனித்துவமான காலப் பயண பிழைத்திருத்தி மற்றும் ஒரு ஒருங்கிணைந்த சோதனை அனுபவத்தைக் கொண்டுள்ளது.

கட்டமைப்பின் தேர்வு உங்கள் ப்ராஜெக்ட்டின் குறிப்பிட்ட தேவைகள் மற்றும் தேவைகளைப் பொறுத்தது. வேகமான, நம்பகமான, மற்றும் டெவலப்பர்களுக்கு ஏற்ற எண்ட்-டு-எண்ட் சோதனை தேவைப்படும் நவீன இணையப் பயன்பாடுகளுக்கு சைப்ரஸ் ஒரு சிறந்த தேர்வாகும்.

செயல்பாட்டில் சைப்ரஸின் நிஜ-உலக எடுத்துக்காட்டுகள்

வெவ்வேறு வகையான இணையப் பயன்பாடுகளைச் சோதிக்க சைப்ரஸை எவ்வாறு பயன்படுத்தலாம் என்பதற்கான சில நிஜ-உலக எடுத்துக்காட்டுகளை ஆராய்வோம்:

ஒரு இ-காமர்ஸ் பயன்பாட்டைச் சோதித்தல்

ஒரு இ-காமர்ஸ் பயன்பாட்டில் பல்வேறு பயனர் ஓட்டங்களைச் சோதிக்க சைப்ரஸைப் பயன்படுத்தலாம், அதாவது:

• பொருட்களைத் தேடுதல்
• பொருட்களை கார்ட்டில் சேர்த்தல்
• செக் அவுட் செய்து ஆர்டர் செய்தல்
• கணக்கு அமைப்புகளை நிர்வகித்தல்

ஒரு பயனர் வெற்றிகரமாக ஒரு பொருளைத் தங்கள் கார்ட்டில் சேர்க்க முடியும் என்பதைச் சரிபார்க்கும் ஒரு சைப்ரஸ் சோதனைக்கான எடுத்துக்காட்டு இங்கே:

it('Adds a product to the cart', () => {
  cy.visit('/products')
  cy.get('.product-card').first().find('button').click()
  cy.get('.cart-count').should('have.text', '1')
})

ஒரு சமூக ஊடக பயன்பாட்டைச் சோதித்தல்

ஒரு சமூக ஊடக பயன்பாட்டில் பயனர் தொடர்புகளைச் சோதிக்க சைப்ரஸைப் பயன்படுத்தலாம், அதாவது:

• ஒரு புதிய பதிவை உருவாக்குதல்
• ஒரு பதிவை விரும்புதல்
• ஒரு பதிவில் கருத்துரைத்தல்
• மற்ற பயனர்களைப் பின்தொடர்தல்

ஒரு பயனர் வெற்றிகரமாக ஒரு புதிய பதிவை உருவாக்க முடியும் என்பதைச் சரிபார்க்கும் ஒரு சைப்ரஸ் சோதனைக்கான எடுத்துக்காட்டு இங்கே:

it('Creates a new post', () => {
  cy.visit('/profile')
  cy.get('#new-post-textarea').type('Hello, world!')
  cy.get('#submit-post-button').click()
  cy.get('.post').first().should('contain', 'Hello, world!')
})

ஒரு வங்கி பயன்பாட்டைச் சோதித்தல்

வங்கி பயன்பாடுகளுக்கு, சைப்ரஸை முக்கியமான செயல்பாடுகளைச் சோதிக்கப் பயன்படுத்தலாம், அதாவது:

• பாதுகாப்பாக உள்நுழைதல்
• கணக்கு இருப்பைச் சரிபார்த்தல்
• நிதிகளைப் பரிமாற்றுதல்
• பயனாளிகளை நிர்வகித்தல்

ஒரு நிதிப் பரிமாற்றத்தைச் சரிபார்க்கும் ஒரு சோதனை இதுபோன்று இருக்கலாம் (பாதுகாப்புக்காக பொருத்தமான ஸ்டப்பிங்குடன்):

it('Transfers funds successfully', () => {
  cy.visit('/transfer')
  cy.get('#recipient-account').type('1234567890')
  cy.get('#amount').type('100')
  cy.intercept('POST', '/api/transfer', { statusCode: 200, body: { success: true } }).as('transfer')
  cy.get('#transfer-button').click()
  cy.wait('@transfer')
  cy.get('.success-message').should('be.visible')
})

முடிவுரை

சைப்ரஸ் ஒரு சக்திவாய்ந்த மற்றும் பல்துறை எண்ட்-டு-எண்ட் சோதனை கட்டமைப்பாகும், இது உங்கள் இணையப் பயன்பாடுகளின் தரத்தையும் நம்பகத்தன்மையையும் உறுதிப்படுத்த உதவும். அதன் டெவலப்பர்களுக்கு ஏற்ற API, சக்திவாய்ந்த அம்சங்கள், மற்றும் சிறந்த செயல்திறன் ஆகியவை உலகெங்கிலும் உள்ள டெவலப்பர்கள் மற்றும் QA பொறியாளர்கள் மத்தியில் பிரபலமான தேர்வாக அமைகின்றன. இந்த வழிகாட்டியில் கோடிட்டுக் காட்டப்பட்டுள்ள சிறந்த நடைமுறைகளைப் பின்பற்றுவதன் மூலம், மேம்பாட்டுச் செயல்பாட்டில் ஆரம்பத்திலேயே பிழைகளைக் கண்டறியவும், உங்கள் பயனர்களுக்கு உயர்தர மென்பொருளை வழங்கவும் உதவும் பயனுள்ள சைப்ரஸ் சோதனைகளை நீங்கள் எழுதலாம்.

இணையப் பயன்பாடுகள் தொடர்ந்து বিকশিতமாகும்போது, எண்ட்-டு-எண்ட் சோதனையின் முக்கியத்துவம் மேலும் அதிகரிக்கும். சைப்ரஸை ஏற்றுக்கொண்டு, அதை உங்கள் மேம்பாட்டுப் பணிப்பாய்வுகளில் ஒருங்கிணைப்பது, மேலும் வலுவான, நம்பகமான, மற்றும் பயனர்களுக்கு ஏற்ற இணைய அனுபவங்களை உருவாக்க உங்களுக்கு அதிகாரம் அளிக்கும்.