முன்-முனையில் சோதனை தானியங்குதல்: ப்ளேரைட் மற்றும் சைப்ரஸின் மேம்பட்ட முறைகள்

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

நிலப்பரையை புரிந்துகொள்வது: ப்ளேரைட் vs சைப்ரஸ்

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

ப்ளேரைட்: குறுக்கு-உலாவி பவர்ஹவுஸ்

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

சைப்ரஸ்: டெவலப்பர்-நட்பு தேர்வு

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

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

மேம்பட்ட சோதனை முறைகள்: ஆழமான டைவ்

இப்போது, ​​உங்கள் ப்ளேரைட் மற்றும் சைப்ரஸ் சோதனை தொகுப்புகளின் தரம் மற்றும் பராமரிப்புத் திறனை கணிசமாக மேம்படுத்தக்கூடிய சில மேம்பட்ட சோதனை முறைகளை ஆராய்வோம்.

1. பக்க பொருள் மாதிரி (POM)

பக்க பொருள் மாதிரி (POM) என்பது ஒரு வடிவமைப்பு வடிவமாகும், இது ஒரு பிரத்யேக வகுப்பில் ஒரு குறிப்பிட்ட பக்கத்தின் கூறுகள் மற்றும் தொடர்புகளை மூடுவதன் மூலம் குறியீடு மறுபயன்பாடு மற்றும் பராமரிப்புத் திறனை ஊக்குவிக்கிறது. இந்த முறை அடிப்படை HTML கட்டமைப்பைத் தவிர்த்து, UI மாறும்போது உங்கள் சோதனைகளை குறைவாக உடையக்கூடியதாகவும் புதுப்பிப்பதை எளிதாக்குகிறது.

செயல்படுத்துதல் (ப்ளேரைட்):

            // page.ts
import { expect, Locator, Page } from '@playwright/test';

export class HomePage {
    readonly page: Page;
    readonly searchInput: Locator;
    readonly searchButton: Locator;

    constructor(page: Page) {
        this.page = page;
        this.searchInput = page.locator('input[name="q"]');
        this.searchButton = page.locator('button[type="submit"]');
    }

    async goto() {
        await this.page.goto('https://www.example.com');
    }

    async search(searchTerm: string) {
        await this.searchInput.fill(searchTerm);
        await this.searchButton.click();
    }
}

            

              
                Copy
              
            
          

            // example.spec.ts
import { test, expect } from '@playwright/test';
import { HomePage } from './page';

test('search for a term', async ({ page }) => {
    const homePage = new HomePage(page);
    await homePage.goto();
    await homePage.search('Playwright');
    await expect(page).toHaveURL(/.*Playwright/);
});

            

              
                Copy
              
            
          

செயல்படுத்துதல் (சைப்ரஸ்):

            // page.js
class HomePage {
    visit() {
        cy.visit('https://www.example.com')
    }

    search(searchTerm) {
        cy.get('input[name="q"]')
            .type(searchTerm)
        cy.get('button[type="submit"]')
            .click()
    }

    verifySearch(searchTerm) {
        cy.url().should('include', searchTerm)
    }
}

export default HomePage

            

              
                Copy
              
            
          

            // example.spec.js
import HomePage from './page'

describe('Home Page', () => {
    it('should search for a term', () => {
        const homePage = new HomePage()
        homePage.visit()
        homePage.search('Cypress')
        homePage.verifySearch('Cypress')
    })
})

            

              
                Copy
              
            
          

2. கூறு சோதனை

கூறு சோதனை தனித்தனி UI கூறுகளை தனிமைப்படுத்தி சோதிப்பதில் கவனம் செலுத்துகிறது. இந்த அணுகுமுறை முழு பயன்பாட்டையும் சார்ந்திருக்காமல் ஒவ்வொரு கூறுகளின் செயல்பாட்டையும் நடத்தையையும் சரிபார்க்க உங்களை அனுமதிக்கிறது. கூறு சோதனை சிக்கலான UI நூலகங்கள் மற்றும் React, Vue.js மற்றும் Angular போன்ற கட்டமைப்புகளுக்கு குறிப்பாக பயனுள்ளதாக இருக்கும்.

கூறு சோதனையின் நன்மைகள்:

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

செயல்படுத்துதல் (React உடன் ப்ளேரைட்):

Vite மற்றும் React's Testing Library போன்ற கருவிகளுடன் கூறு சோதனைக்கு ப்ளேரைட்டைப் பயன்படுத்தலாம். ப்ளேரைட் E2E இல் சிறந்து விளங்கினாலும், இந்த குறிப்பிட்ட பயன்பாட்டு வழக்கிற்காக பிரத்யேக கூறு சோதனை கட்டமைப்புகள் சிறந்த DX ஐ வழங்கக்கூடும்.

செயல்படுத்துதல் (React உடன் சைப்ரஸ்):

            // Button.jsx
import React from 'react';

function Button({ onClick, children }) {
  return {children};
}

export default Button;

            

              
                Copy
              
            
          

            // Button.cy.jsx
import React from 'react';
import Button from './Button';

describe('Button Component', () => {
  it('should call onClick when clicked', () => {
    const onClick = cy.stub();
    cy.mount(Click Me);
    cy.get('button').click();
    cy.wrap(onClick).should('be.called');
  });

  it('should display the children text', () => {
    cy.mount(Hello World);
    cy.get('button').should('contain', 'Hello World');
  });
});

            

              
                Copy
              
            
          

3. காட்சி சோதனை

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

காட்சி சோதனைக்கான கருவிகள்:

• Applitools: மேம்பட்ட பட ஒப்பீடு மற்றும் AI-இயங்கும் பகுப்பாய்வை வழங்கும் ஒரு வணிக காட்சி சோதனை தளம்.
• Percy: CI/CD குழாய்களுடன் தடையின்றி ஒருங்கிணைக்கக்கூடிய மற்றொரு பிரபலமான வணிக காட்சி சோதனை தளம்.
• ப்ளேரைட்டின் உள்ளமைக்கப்பட்ட ஸ்னாப்ஷாட் சோதனை: உங்கள் சோதனைகளுக்குள் நேரடியாக அடிப்படை படங்களுடன் ஸ்கிரீன் ஷாட்டுகளை எடுத்து அவற்றை ஒப்பிட ப்ளேரைட் உங்களை அனுமதிக்கிறது.
• சைப்ரஸ் பட ஸ்னாப்ஷாட்: ஒத்த ஸ்கிரீன் ஷாட் ஒப்பீட்டு திறன்களை வழங்கும் ஒரு சைப்ரஸ் செருகுநிரல்.

செயல்படுத்துதல் (உள்ளமைக்கப்பட்ட ஸ்னாப்ஷாட்களுடன் ப்ளேரைட்):

            // visual.spec.ts
import { test, expect } from '@playwright/test';

test('homepage has correct visual appearance', async ({ page }) => {
  await page.goto('https://www.example.com');
  expect(await page.screenshot()).toMatchSnapshot('homepage.png');
});

            

              
                Copy
              
            
          

செயல்படுத்துதல் (சைப்ரஸ் பட ஸ்னாப்ஷாட்டுடன் சைப்ரஸ்):

            // cypress.config.js
const { defineConfig } = require('cypress')
const { initPlugin } = require('cypress-plugin-snapshots/plugin');

module.exports = defineConfig({
  e2e: {
    setupNodeEvents(on, config) {
      initPlugin(on, config);
      return config;
    },
  },
})

            

              
                Copy
              
            
          

            // visual.spec.js
import { compareSnapshotCommand } from 'cypress-image-snapshot/command'
addMatchImageSnapshotCommand();

describe('Visual Regression Testing', () => {
    it('Homepage Visual Test', () => {
        cy.visit('https://www.example.com')
        cy.get('body').toMatchImageSnapshot()
    })
})

            

              
                Copy
              
            
          

4. தரவு-இயக்கப்பட்ட சோதனை

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

தரவு-இயக்கப்பட்ட சோதனையின் நன்மைகள்:

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

செயல்படுத்துதல் (JSON தரவுடன் ப்ளேரைட்):

            // data.json
[
  {
    "username": "user1",
    "password": "pass1"
  },
  {
    "username": "user2",
    "password": "pass2"
  }
]

            

              
                Copy
              
            
          

            // data-driven.spec.ts
import { test, expect } from '@playwright/test';
import * as testData from './data.json';

testData.forEach((data) => {
  test(`login with ${data.username}`, async ({ page }) => {
    await page.goto('https://www.example.com/login'); // Replace with your login page
    await page.locator('#username').fill(data.username);
    await page.locator('#password').fill(data.password);
    await page.locator('button[type="submit"]').click();

    // Add assertions to verify successful login
    // Example: await expect(page).toHaveURL(/.*dashboard/);
  });
});

            

              
                Copy
              
            
          

செயல்படுத்துதல் (உள்ளடக்க தரவுடன் சைப்ரஸ்):

            // cypress/fixtures/data.json
[
  {
    "username": "user1",
    "password": "pass1"
  },
  {
    "username": "user2",
    "password": "pass2"
  }
]

            

              
                Copy
              
            
          

            // data-driven.spec.js
describe('Data-Driven Testing', () => {
  it('Login with multiple users', () => {
    cy.fixture('data.json').then((users) => {
      users.forEach((user) => {
        cy.visit('https://www.example.com/login') // Replace with your login page
        cy.get('#username').type(user.username)
        cy.get('#password').type(user.password)
        cy.get('button[type="submit"]').click()

        // Add assertions to verify successful login
        // Example: cy.url().should('include', '/dashboard')
      })
    })
  })
})

            

              
                Copy
              
            
          

5. E2E சோதனைகளுக்குள் API சோதனை

உங்கள் E2E சோதனைகளில் API சோதனையை ஒருங்கிணைப்பது மிகவும் விரிவான மற்றும் நம்பகமான சோதனை உத்தியை வழங்க முடியும். இந்த அணுகுமுறை உங்கள் முன்-முனை பயன்பாட்டை இயக்கும் பின்-முனை செயல்பாட்டைச் சரிபார்க்க உங்களை அனுமதிக்கிறது, தரவு சரியாகப் பாய்வதையும், UI எதிர்பார்க்கப்பட்ட நிலையைக் குறிப்பதையும் உறுதி செய்கிறது.

E2E சோதனைகளுக்குள் API சோதனையின் நன்மைகள்:

• பின்-முனை சிக்கல்களின் ஆரம்பகால கண்டறிதல்: API சோதனைகள் வளர்ச்சி சுழற்சியின் ஆரம்பத்தில் பின்-முனை சிக்கல்களை அடையாளம் காண முடியும், அவை முன்-முனையை பாதிப்பதைத் தடுக்கின்றன.
• சோதனை நம்பகத்தன்மை மேம்படுத்தப்பட்டது: API சோதனைகள் முன்-முனை சோதனைகளை இயக்குவதற்கு முன்பு பின்-முனை அறியப்பட்ட நிலையில் இருப்பதை உறுதி செய்ய முடியும், இது குறைபாட்டைக் குறைக்கிறது.
• எண்ட்-டு-எண்ட் சரிபார்ப்பு: API மற்றும் UI சோதனைகளை இணைப்பது உங்கள் பயன்பாட்டின் செயல்பாட்டின் முழுமையான எண்ட்-டு-எண்ட் சரிபார்ப்பை வழங்குகிறது.

செயல்படுத்துதல் (ப்ளேரைட்):

            // api.spec.ts
import { test, expect } from '@playwright/test';

test('create a new user via API and verify in UI', async ({ page, request }) => {
  // 1. Create a user via API
  const response = await request.post('/api/users', {
    data: {
      name: 'John Doe',
      email: 'john.doe@example.com'
    }
  });
  expect(response.status()).toBe(201); // Assuming 201 Created
  const responseBody = await response.json();
  const userId = responseBody.id;

  // 2. Navigate to the user list in the UI
  await page.goto('/users'); // Replace with your user list page

  // 3. Verify that the new user is displayed
  await expect(page.locator(`text=${'John Doe'}`)).toBeVisible();
});

            

              
                Copy
              
            
          

செயல்படுத்துதல் (சைப்ரஸ்):

            // api.spec.js
describe('API and UI Integration Test', () => {
  it('Creates a user via API and verifies it in the UI', () => {
    // 1. Create a user via API
    cy.request({
      method: 'POST',
      url: '/api/users', // Replace with your API endpoint
      body: {
        name: 'Jane Doe',
        email: 'jane.doe@example.com'
      }
    }).then((response) => {
      expect(response.status).to.eq(201) // Assuming 201 Created
      const userId = response.body.id

      // 2. Navigate to the user list in the UI
      cy.visit('/users') // Replace with your user list page

      // 3. Verify that the new user is displayed
      cy.contains('Jane Doe').should('be.visible')
    })
  })
})

            

              
                Copy
              
            
          

6. அணுகல்தன்மை சோதனை

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

அணுகல்தன்மை சோதனைக்கான கருவிகள்:

• axe-core: ஒரு பிரபலமான திறந்த மூல அணுகல்தன்மை சோதனை நூலகம்.
• axe DevTools: நிகழ்நேர அணுகல்தன்மை பின்னூட்டத்தை வழங்கும் ஒரு உலாவி நீட்டிப்பு.
• Lighthouse: அணுகல்தன்மை சோதனைகளை உள்ளடக்கிய ஒரு வலை செயல்திறன் மற்றும் தணிக்கை கருவி.

செயல்படுத்துதல் (axe-core உடன் ப்ளேரைட்):

            // accessibility.spec.ts
import { test, expect } from '@playwright/test';
import AxeBuilder from '@axe-core/playwright';

test('homepage should pass accessibility checks', async ({ page }) => {
  await page.goto('https://www.example.com');
  const axeBuilder = new AxeBuilder({ page });
  const accessibilityScanResults = await axeBuilder.analyze();
  expect(accessibilityScanResults.violations).toEqual([]); // Or handle violations appropriately
});

            

              
                Copy
              
            
          

செயல்படுத்துதல் (axe-core உடன் சைப்ரஸ்):

            // support/commands.js
import 'cypress-axe'

Cypress.Commands.add('checkA11y', (context, options) => {
  cy.configureAxe(options)
  cy.checkA11y(context, options)
})

            

              
                Copy
              
            
          

            // accessibility.spec.js
describe('Accessibility Testing', () => {
  it('Homepage should be accessible', () => {
    cy.visit('https://www.example.com')
    cy.injectAxe()
    cy.checkA11y()
  })
})

            

              
                Copy
              
            
          

7. அங்கீகாரம் மற்றும் அங்கீகாரத்தை கையாளுதல்

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

அங்கீகாரம் மற்றும் அங்கீகாரத்தை சோதிப்பதற்கான உத்திகள்:

• UI-அடிப்படையிலான அங்கீகாரம்: UI மூலம் பயனர் உள்நுழைவை உருவகப்படுத்தி, பயன்பாடு சரியாக அங்கீகரிக்கப்பட்டு பயனரை அங்கீகரிக்கிறதா என்பதை சரிபார்க்கவும்.
• API-அடிப்படையிலான அங்கீகாரம்: அங்கீகார டோக்கன்களைப் பெற API கோரிக்கைகளைப் பயன்படுத்தவும், பின்னர் பாதுகாக்கப்பட்ட வளங்களை அணுக அந்த டோக்கன்களைப் பயன்படுத்தவும்.
• பங்கு அடிப்படையிலான அணுகல் கட்டுப்பாடு (RBAC) சோதனை: வெவ்வேறு பாத்திரங்களைக் கொண்ட பயனர்கள் பயன்பாட்டின் வெவ்வேறு பகுதிகளுக்கு அணுகுவதற்கான பொருத்தமான அனுமதிகளைக் கொண்டிருக்கிறார்களா என்பதைச் சரிபார்க்கவும்.

எடுத்துக்காட்டு (ப்ளேரைட் - UI-அடிப்படையிலான அங்கீகாரம்):

            // auth.spec.ts
import { test, expect } from '@playwright/test';

test('login and access protected resource', async ({ page }) => {
  await page.goto('/login'); // Replace with your login page
  await page.locator('#username').fill('valid_user');
  await page.locator('#password').fill('valid_password');
  await page.locator('button[type="submit"]').click();
  await expect(page).toHaveURL(/.*dashboard/); // Replace with your dashboard URL

  // Now access a protected resource
  await page.goto('/protected-resource'); // Replace with your protected resource URL
  await expect(page.locator('h1')).toContainText('Protected Resource');
});

            

              
                Copy
              
            
          

எடுத்துக்காட்டு (சைப்ரஸ் - API-அடிப்படையிலான அங்கீகாரம்):

            // auth.spec.js
describe('Authentication Testing', () => {
  it('Logs in via API and accesses a protected resource', () => {
    // 1. Get an authentication token from the API
    cy.request({
      method: 'POST',
      url: '/api/login', // Replace with your login API endpoint
      body: {
        username: 'valid_user',
        password: 'valid_password'
      }
    }).then((response) => {
      expect(response.status).to.eq(200)
      const token = response.body.token

      // 2. Set the token in local storage or cookies
      cy.setLocalStorage('authToken', token)

      // 3. Visit the protected resource, which is now authenticated
      cy.visit('/protected-resource') // Replace with your protected resource URL

      // 4. Verify that the user can access the resource
      cy.contains('Protected Content').should('be.visible')
    })
  })
})

            

              
                Copy
              
            
          

சோதனை தொகுப்புகளைப் பேணுவதற்கான சிறந்த நடைமுறைகள்

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

1. சோதனைகளை மையப்படுத்தவும் மற்றும் சுருக்கமாகவும் வைத்திருங்கள்

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

2. அர்த்தமுள்ள சோதனை பெயர்களைப் பயன்படுத்துங்கள்

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

3. கடினமான குறியீட்டு மதிப்புகளைத் தவிர்க்கவும்

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

4. தவறாமல் சோதனைகளை மதிப்பாய்வு செய்து மறுசீரமைக்கவும்

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

5. CI/CD குழாய்களுடன் ஒருங்கிணைக்கவும்

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

6. சோதனை அறிக்கையிடல் மற்றும் பகுப்பாய்வு கருவிகளைப் பயன்படுத்துங்கள்

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

முடிவு

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