אוטומציה של בדיקות פרונטאנד: תבניות מתקדמות ב-Playwright ו-Cypress

            // 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
              
            
          

            // 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
              
            
          

            // 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
              
            
          

            // 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
              
            
          

            // 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
              
            
          

            // 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
              
            
          

            // 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
              
            
          

            // 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
              
            
          

            // 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