<lightning-input class="slds-form-element">
  #shadow-root (open)
    <div class="slds-form-element__control">
      <input id="input-42" type="text" class="slds-input" />
    </div>
</lightning-input>

// Playwright ignores the Shadow root completely and targets the LWC element or the input directly!
await page.locator('lightning-input input').fill('John Doe');

// A much more resilient role-based selector (which also pierces shadow DOM):
await page.getByLabel('First Name').fill('John Doe');

import { test as setup, expect } from '@playwright/test';

setup('login to salesforce and save session', async ({ page }) => {
  await page.goto('https://test.salesforce.com');
  await page.locator('#username').fill(process.env.SF_USERNAME!);
  await page.locator('#password').fill(process.env.SF_PASSWORD!);
  await page.locator('#Login').click();
  
  // Wait for home page dashboard loading to ensure auth fully completes
  await expect(page).toHaveURL(/lightning/);
  
  // Write the authenticated state to storage JSON
  await page.context().storageState({ path: 'playwright/.auth/salesforce-user.json' });
});

import { defineConfig } from '@playwright/test';

export default defineConfig({
  projects: [
    // Step 1: Execute global auth setup
    {
      name: 'setup',
      testMatch: '**/*.setup.ts',
    },
    // Step 2: Main test suite reusing the saved auth
    {
      name: 'chromium',
      use: {
        browserName: 'chromium',
        storageState: 'playwright/.auth/salesforce-user.json',
      },
      dependencies: ['setup'],
    },
  ],
});

import { Locator, Page } from '@playwright/test';

export class OpportunityPage {
  private readonly page: Page;
  private readonly newButton: Locator;
  private readonly nameInput: Locator;
  private readonly stageCombobox: Locator;
  private readonly saveButton: Locator;

  constructor(page: Page) {
    this.page = page;
    this.newButton = page.getByRole('button', { name: 'New' });
    this.nameInput = page.getByLabel('*Opportunity Name'); // Salesforce adds '*' to mandatory fields
    this.stageCombobox = page.locator('lightning-combobox').filter({ hasText: 'Stage' }).locator('button');
    this.saveButton = page.getByRole('button', { name: 'Save', exact: true });
  }

  async createSimpleOpportunity(name: string, stage: string) {
    await this.newButton.click();
    await this.nameInput.fill(name);
    
    // Open combobox and select target stage option
    await this.stageCombobox.click();
    await this.page.getByRole('option', { name: stage }).click();
    
    await this.saveButton.click();
  }
}

import { test, expect } from '@playwright/test';

test.describe('Speed Optimized Salesforce UI Test', () => {
  let accountId: string;

  // 1. Seed data before UI execution
  test.beforeAll(async ({ request }) => {
    const tokenResponse = await request.post('https://login.salesforce.com/services/oauth2/token', {
      form: {
        grant_type: 'password',
        client_id: process.env.SF_CONSUMER_KEY!,
        client_secret: process.env.SF_CONSUMER_SECRET!,
        username: process.env.SF_USERNAME!,
        password: process.env.SF_PASSWORD!
      }
    });
    const { access_token, instance_url } = await tokenResponse.json();

    // Create record via SObjects REST API
    const account = await request.post(`${instance_url}/services/data/v60.0/sobjects/Account`, {
      headers: {
        'Authorization': `Bearer ${access_token}`,
        'Content-Type': 'application/json'
      },
      data: {
        Name: 'Playwright Automation Account Inc.',
        Industry: 'Technology'
      }
    });
    const accountData = await account.json();
    accountId = accountData.id; // Capture the ID!
  });

  // 2. Run UI Test directly visiting the record ID!
  test('UI validation on created record', async ({ page }) => {
    await page.goto(`/lightning/r/Account/${accountId}/view`);
    
    // Validate UI loaded matching the API details
    await expect(page.getByText('Playwright Automation Account Inc.')).toBeVisible();
  });
});

# Initialize a clean Playwright project
npm init playwright@latest

# Install dotenv to securely load sandbox credentials
npm install dotenv --save-dev

SF_URL=https://test.salesforce.com
SF_USERNAME=qa-sdet-bot@example.com.sandbox
SF_PASSWORD=MySecurePassword123!

import { defineConfig, devices } from '@playwright/test';
import * as dotenv from 'dotenv';
dotenv.config();

export default defineConfig({
  testDir: './tests',
  fullyParallel: false, // Keep sequential per file to avoid record row locks
  workers: 1, // Restrict sandbox concurrency
  reporter: 'html',
  use: {
    baseURL: process.env.SF_URL,
    trace: 'on-first-retry',
  },
  projects: [
    {
      name: 'setup',
      testMatch: '**/*.setup.ts',
    },
    {
      name: 'e2e',
      dependencies: ['setup'],
      use: {
        ...devices['Desktop Chrome'],
        // Load the session cookies dynamically
        storageState: 'playwright/.auth/salesforce-user.json',
      },
    },
  ],
});

import { test as setup, expect } from '@playwright/test';

const authFile = 'playwright/.auth/salesforce-user.json';

setup('authenticate salesforce', async ({ page }) => {
  await page.goto('/');
  await page.locator('#username').fill(process.env.SF_USERNAME!);
  await page.locator('#password').fill(process.env.SF_PASSWORD!);
  await page.locator('#Login').click();

  // Confirm home page has successfully loaded
  await expect(page).toHaveURL(/lightning/);

  // Cache the authenticated storage state
  await page.context().storageState({ path: authFile });
});

import { Locator, Page } from '@playwright/test';

export class LeadPage {
  private readonly page: Page;
  private readonly lastNameInput: Locator;
  private readonly companyInput: Locator;
  private readonly leadStatusCombobox: Locator;
  private readonly saveButton: Locator;

  constructor(page: Page) {
    this.page = page;
    this.lastNameInput = page.getByLabel('*Last Name'); // Standard LWC label matching
    this.companyInput = page.getByLabel('*Company');
    this.leadStatusCombobox = page.locator('lightning-combobox').filter({ hasText: 'Lead Status' }).locator('button');
    this.saveButton = page.getByRole('button', { name: 'Save', exact: true });
  }

  async createLead(lastName: string, company: string, status: string) {
    // Fill text inputs
    await this.lastNameInput.fill(lastName);
    await this.companyInput.fill(company);

    // Expand LWC picklist and select value role
    await this.leadStatusCombobox.click();
    await this.page.getByRole('option', { name: status }).click();

    // Save Opportunity Record
    await this.saveButton.click();
  }
}

import { test, expect } from '@playwright/test';
import { LeadPage } from '../pages/LeadPage';

test.describe('Salesforce Lead Management Suite', () => {
  test('should successfully create a new Lead in Sandbox org', async ({ page }) => {
    const leadPage = new LeadPage(page);

    // Go directly to Lead Creation page layout using Salesforce direct routing
    await page.goto('/lightning/o/Lead/new');

    // Wait for the modal popup elements to be visible
    await expect(page.getByText('New Lead')).toBeVisible();

    // Interact using Page Object methods
    await leadPage.createLead('Smith', 'Acme Corp', 'Working - Contacted');

    // Assert that the success Toast alert displays correctly
    const toast = page.locator('.toastMessage');
    await expect(toast).toContainText('Lead "Smith" was created.');
  });
});