使用 Playwright 大规模运行自动化测试
0/5 (0投票)
在本文中，我们将了解 Playwright、它的工作原理以及为什么它是使用 Java 进行 Web 自动化的一个不错的选择。
在 Web 开发领域，选择合适的框架进行自动化测试可能是一项艰巨的任务。在快速发展的技术领域，在选择测试自动化框架以与 Selenium 竞争时，明智的决策至关重要。
Playwright 是一个 Node.js 框架，是最近获得普及的此类框架之一。它的普及可以归因于 Node 的流行，Node 帮助 Playwright 吸引了大量的用户。Playwright 是由微软开发的一个强大的开源框架，用于自动化 Web 应用程序。它具有一套独特的功能和特性，使其成为开发人员和测试人员的宝贵框架。
在本文中，我们将探索 Playwright 与 Java 的世界。我们将首先了解 Playwright 以及如何使用它大规模执行测试用例。为此，我们将了解 LambdaTest 平台上的云测试执行，这有助于加速执行并缩短反馈周期。
那么，让我们开始吧。
- 什么是 Playwright？
- 为什么选择 Playwright 与 Java？
- Playwright 和 Java 的框架设置
- 使用 Playwright Java 编写第一个测试用例
- 在 LambdaTest 上使用 Playwright 运行并行测试
- 结论
什么是 Playwright？
Playwright 是一个由微软创建的开源自动化框架，用于测试和自动化 Web 应用程序。该框架与 Windows、macOS 和 Linux 兼容，并支持 Chromium（Google Chrome、Microsoft Edge）、Mozilla Firefox 和 WebKit（Apple Safari）上的跨浏览器自动化测试。
它之所以广泛使用，是因为它与 Java、Python、C# .NET 和 Node.js 兼容。这意味着它可以被使用各种编程语言的开发人员使用，这使其成为一个多功能框架。Playwright 比其他同类产品（例如 Selenium、Cypress 等）更有效地进行跨浏览器测试和 Web 抓取，因为它提供了一个统一的高级 API，用于跨多个浏览器自动化 Web 应用程序。测试人员可以使用这些 API 导航到 URL，并与元素交互，执行诸如填写表单和抓取数据等操作。
Playwright 于 2020 年 1 月首次发布，由于其稳定性、开源性质以及对 C#、Java 和 Python 等多种语言的支持，它迅速获得了普及。这种支持使用户可以轻松地从现有框架迁移到 Playwright。其日益增长的普及体现在 GitHub 上 Microsoft Playwright 的当前数字。
拥有超过 36,000 名活跃用户、3,000 多个分支和 450 多名活跃贡献者，其受欢迎程度将继续增长。
Playwright 的优势
Playwright 的最新版本 1.38 包含了该框架提供的所有多功能特性。它支持多选项卡、多用户和 iframe 测试用例，以及任何定位器操作的内置和自定义等待。
此外，Playwright 在 Web 测试自动化方面相对于其他框架的一些主要优势是。
Playwright 还支持所有主要的编程语言，例如 C#、Python、.NET 和 JavaScript/TypeScript，这使得自动化测试和为各种应用程序添加断言变得简单。这些测试用例可能包括 Web 导航流、表单填写等。
可扩展性
对于具有较大测试套件和并行测试需求的复杂应用程序，可扩展性变得至关重要。Playwright 提供高可扩展性，因为它支持在本地和基于云的平台上的多个浏览器和平台上的并行测试执行。
它允许您使用容器化横向扩展您的测试基础架构，并分布式执行测试用例，从而提供有效的资源管理。它还通过与数据库和其他源集成以进行参数化测试用例以进行数据驱动测试，从而实现测试数据可扩展性。
广泛的集成支持
Playwright 提供对多种工具和技术的集成支持。它可以与以下工具集成：
- CI/CD 工具，如 Jenkins、Gitlab 等。
- 报告工具和测试框架，如 Allure、Extent Reports 或自定义报告以及 JUnit、TestNG、Cucumber 等。
- 性能测试工具和 API 测试框架。
- 基于云的测试平台，如 LambdaTest。
智能内置自动等待
Playwright 具有其他框架中没有的内置自动等待功能。此功能会等到所有元素都准备好进行交互后才对其执行操作或检查。
这种内部方法可用于实现等待时间和条件，例如元素可见性、元素可用于交互、页面导航和网络调用完成。
完全测试隔离的并行测试
Playwright 为每个测试创建一个浏览器上下文，这就像一个新的独立浏览器配置文件。这有助于并行执行多个测试用例并减少执行时间。
由于每个测试都有一个单独的浏览器配置文件，就像 Selenium 中的不同线程一样，所有测试都在完全隔离的情况下运行，互不干扰。这有助于减少测试用例之间的干扰，提高测试可靠性，通过隔离的日志和测试数据更容易调试，减少不稳定性，并获得更干净的测试环境。
为什么选择 Playwright 与 Java？
Playwright Java 组合相互补充，因此允许编写更稳定和可扩展的自动化测试用例。
它支持各种语言，但 Java 因其广泛采用和强大的生态系统而广受欢迎。Java 仍然是前 3 名语言之一，并在最新的 TIOBE 编程语言索引中排名前 5，因此许多程序员都熟悉它，并且易于与 Playwright 一起使用。JDK 21 是 Java SE 平台的最新长期支持版本。
使这种组合强大的其他一些优势是：
无缝配置
Playwright 与 Java 自动化框架的易于设置使其成为 Web 自动化任务的首选。Playwright 作为一组 Maven 模块依赖项捆绑在一起，可以轻松地与 Java 项目集成。
所有可用版本都可以在 Maven 网站上轻松获取，并且可以像下面这样添加到您的项目中。
跨平台兼容性
Java 是一种平台无关的语言，允许您创建可在 Linux、Windows 或 macOS 上运行的 Playwright 脚本。这在使用 Web 自动化时非常有用，并且测试用例需要在所有平台上的浏览器上执行。
通过使用 Java，可以使用相同的用例，并且无需为每个平台用新语言重写它们。
现代语言绑定
Playwright 的 Java API 旨在对 Java 测试人员友好且符合 Java 习惯。它提供结构良好的 API，使编写和维护自动化脚本变得更简单，而无需学习新语言。
全面的文档和支持
Playwright 有关于 Java 的大量文档。再加上庞大的活跃 Java 开发人员社区，使得查找资源并在出现任何问题时获得帮助变得非常容易。
Playwright 和 Java 的框架设置
配置 Playwright Java 项目非常无缝。如前所述，Playwright 作为一组 Maven 模块提供。这使得通过向 Maven 项目的 pom.xml 添加一个依赖项来配置它变得非常容易。
从高层次来看，设置可以分为三个部分
- 安装 Java 11
- 创建 Maven 项目
- 添加 Playwright Maven 依赖项
在编写第一个测试用例之前，让我们逐一查看这些内容。
安装 Java 11
如果您的计算机上尚未安装 Java，请按照以下步骤安装。
步骤 1. 访问 Java 官方网站并根据您的操作系统下载最新的兼容版本。您也可以选择 OpenJDK。它是开源的，在构建和结果方面与 Oracle Java 相同。
步骤 2. 运行下载的安装文件并按照步骤在您的系统上安装 Java。
创建 Maven 项目
在本教程中，为演示目的使用了 Eclipse IDE。但是，您可以使用您选择的任何 IDE，并在其中创建一个新的 Maven 项目，然后继续执行后续步骤。
步骤 1. 启动 Eclipse IDE → 选择新建 → 项目。
步骤 2. 选择 Maven → Maven 项目，然后单击下一步。
步骤 3. 填写所需的项目详细信息并将其命名为 PlaywrightJava。将创建一个如下图所示的新项目。
添加 Playwright Maven 依赖项
适用于 Java 的 Playwright 可作为 Maven 依赖项使用。为了能够在您的项目中使用它，
步骤 1. 访问 Maven 网站并搜索 Playwright。
步骤 2. 选择第一个选项，然后选择可用的最新稳定版本。
步骤 3. 复制依赖项详细信息并将其添加到项目的 pom.xml 文件中。我们使用了 v1.38.0，这是撰写本文时最新版本。
<dependency>
<groupId>com.microsoft.playwright</groupId>
<artifactId>playwright</artifactId>
<version>1.38.0</version>
</dependency>
至此，我们已经完成了基本的项目设置和安装，可以开始编写第一个 Playwright Java Web 自动化测试用例了。
使用 Playwright Java 编写第一个测试用例
现在，我们将开始编写第一个 Playwright Java 测试用例。为此，请考虑以下测试场景：导航到网页，在其上执行操作，并断言结果。
我们将在云网格上执行我们的 Playwright 用例。在云上执行自动化可以提高速度和可伸缩性，使自动化测试更快、更可靠。它还允许我们在各种浏览器和操作系统上执行多个用例。
在本文中，LambdaTest 云网格用于实现此目的。LambdaTest 是一个由 AI 驱动的测试执行平台，使用户能够在 3000 多个真实浏览器和操作系统组合上对 Web 应用程序执行 Playwright 自动化。我们将看到如何利用相同的云平台进行单个测试执行，然后并行执行不同的浏览器。
测试场景
- 导航到 LambdaTest Playground。
- 点击 Input Form Submit。
- 断言 Input Form 页面已加载。
- 填写着陆页上的表单。
- 点击 Submit 按钮。
- 断言确认消息。
要执行测试用例，已使用 TestNG。将 TestNG 依赖项以及 gson 依赖项添加到 pom.xml 中。
Gson，如 Maven 网站上所述，是一个 Java 库，可以将 Java 对象转换为其 JSON 表示。我们将使用它创建一个 JsonObject 来为 LambdaTest 平台添加云属性并连接到云网格。这些属性有助于选择用于执行的浏览器和平台，并识别 LambdaTest Web 自动化仪表板上的执行详细信息，以便更好地进行结果分析和调试。
添加所有依赖项后，最终的 pom.xml 应如下所示
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>PlaywrightJava</groupId>
<artifactId>PlaywrightJava</artifactId>
<version>0.0.1-SNAPSHOT</version>
<build>
<sourceDirectory>src</sourceDirectory>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<release>19</release>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>com.microsoft.playwright</groupId>
<artifactId>playwright</artifactId>
<version>1.38.0</version>
</dependency>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>7.8.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.10.1</version>
</dependency>
</dependencies>
</project>
完成项目设置并创建包含更新依赖项的 pom 文件后，我们现在开始编写第一个使用云执行的 Playwright Java 测试用例。
我们将要编写的测试用例将主要分为两部分
- Java 类文件，其中将包含实际的测试流程，包括导航、对网页执行操作、填写数据和断言结果。
- 测试用例文件，其中将包含连接到 LambdaTest 云网格的代码以及对第一个文件中定义的测试流程执行的调用。
现在开始吧。
在 src 包中添加一个名为 base 的包。在此包中，添加一个新文件并将其命名为 SampleTestFlow.java。此文件将包含前面提到的测试场景执行，如下所示。
package base;
import static com.microsoft.playwright.assertions.PlaywrightAssertions.assertThat;
import com.microsoft.playwright.Locator;
import com.microsoft.playwright.Page;
public class SampleTestFlow {
/*
* This function is to execute the test flow.
* Navigate to the webpage, fill and submit data, and assert confirmation messages.
*/
public static void playwrightTestFlow(Page page) {
try {
// Navigate to the Lambdatest Selenium Playground
page.navigate("https://www.lambdatest.com/selenium-playground/");
// Locate the Input Form Submit a link and click on it.
Locator inputForm = page.locator("text=Input Form Submit");
inputForm.click();
// Assert Input Form Submit page is loaded
assertThat(page.getByText("Input form validations")).isVisible();
// fill data in the form
fillInputFormData(page);
// Click Submit button to submit the form
page.getByText("Submit").click();
// Fetch the success message, print it on console, and assert same.
String successMessage = page.locator("xpath=//p[@class='success-msg hidden']")
.textContent();
System.out.println(successMessage);
assertThat(page.locator("xpath=//p[@class='success-msg hidden']"))
.hasText("Thanks for contacting us, we will get back to you shortly.");
} catch (Exception err) {
err.printStackTrace();
}
}
/*
* This function is to fill all the required input form fields on the webpage
*/
private static void fillInputFormData(Page page)
{
page.locator("id=name").fill("Playwright");
page.locator("id=inputEmail4").fill("Playwright@example.com");
page.locator("id=inputPassword4").fill("Playwright@123");
page.getByPlaceholder("Company").fill("Lambdatest");
page.getByPlaceholder("Website").fill("www.playwright.dev");
page.locator("xpath=//select[@name='country']").selectOption("IN");
page.locator("xpath=//input[@name='city']").fill("Gurgaon");
page.locator("xpath=//*[@name='address_line1']").fill("House 1");
page.locator("css=input#inputAddress2").fill("Sector 1");
page.locator("css=#inputState").fill("Haryana");
page.locator("id=inputState").fill("Haryana");
page.locator("css=input[name='zip']").fill("123456");
}
}
代码演练：SampleTestFlow.java
步骤 1. 导入 playwright 包的 Locator 和 Page 接口。Locator 接口用于随时在网页上查找 Web 元素，而 Page 接口则通过其方法与整个测试流程中的网页进行交互。
此外，您应该静态导入 PlaywrightAssertions 接口的 assertThat 方法，以验证测试流程中的成功消息。
步骤 2. 在此类的内部添加第一个函数 playwrightTestFlow()。此函数将有一个参数 - page，它将用于网页上的交互。
此函数上的 public 访问修饰符以及 static 类型将允许直接使用类名调用它，而无需创建对象。
步骤 3. 导航到 LambdaTest Selenium Playground。
步骤 4. 在加载的网页上找到 Input Form Submit 链接并单击它。
Playwright 提供了几种不同的内置定位器方法，可用于使用 page 实例在网页上定位 Web 元素。
除了这些方法之外，还提供了一个通用的 locator() 方法，我们可以在其中使用常用的方法来定位 Web 元素，例如 XPath、id、name、text、CSS 等，通过将其作为键值对传递到函数参数中。
在此步骤中，使用了 locator() 方法。我们使用 text 类型来定位 Web 元素并将其存储在 Locator 类型的变量中。
然后使用此变量单击它。
步骤 5. 通过验证网页上此文本的可见性，断言 Input Form Demo 页面已加载。
对于断言，我们使用了我们最初导入的 assertThat() 方法。Playwright 的 isVisible() 内置方法用于检查给定的 Web 元素是否在页面上可见。
这次，我们使用 getByText() 元素定位器来获取 Web 元素引用。
步骤 6. 通过使用 page 实例作为参数调用 fillInputFormData() 函数来填写表单中的数据。
我们将在当前函数完成后对该函数进行演练。
步骤 7. 点击 Submit 按钮提交已填写的表单。
为了定位 Submit 按钮，再次使用了 getByText() 定位器。
步骤 8. 使用其 XPath 提交表单后获取成功消息定位器。
使用 Playwright API 的 textContent() 方法获取其真实内容。
在控制台上记录此消息，并使用 assertThat 函数中的 hasText() 方法断言它与给定消息完全匹配。
步骤 9. 添加下一个函数 fillInputFormData()，它将用于填写输入表单中的所有数据。
此函数将获取 page 实例作为参数，以与页面交互并定位 Web 元素以填写数据。
步骤 10. 使用 page.locator() 或其他定位器方法对网页上的字段进行定位并填写表单中的所有数据。为不同字段使用不同的标识符以展示用法。
要在表单上的所有文本框字段中输入数据，请使用 fill() 方法，该方法接受要输入的数据作为字符串参数。
10.1) 要填写姓名、电子邮件和密码，我们使用带有 id 标识符的 locator() 方法。
10.2) 对于公司和网站，使用 getByPlaceholder() 定位器方法。
10.3) 由于 Country 选项是一个下拉列表，因此要从下拉列表中选择值，请使用 selectOption() 方法以及 XPath 来定位元素。
除此之外，您还可以使用下拉值的 label 或 index 来选择它。
10.4) 对于城市和地址行 1，演示了 page.locator() 与 XPath 的用法。
10.5) 最后，对于所有剩余字段，在 locator() 方法内部使用 CSS 标识符来定位元素并填写数据。
至此，我们已经完成了使用 Playwright Java 编写和理解测试用例流程的代码。让我们继续进入测试类文件，该文件将包含 LambdaTest 平台上云测试执行的代码。
首先在 src 中添加一个新包，并将其命名为 test.cloud_execution。在其中，添加一个 Java 测试文件 PlaywrightTestSingle.java。
package test.cloud_execution;
import java.net.URLEncoder;
import org.testng.annotations.Test;
import com.google.gson.JsonObject;
import com.microsoft.playwright.*;
import base.SampleTestFlow;
public class PlaywrightTestSingle {
@Test
public void playwrightTestSingle()
{
String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" :
System.getenv("LT_USERNAME");
String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>" :
System.getenv("LT_ACCESS");
try (Playwright playwright = Playwright.create()) {
JsonObject capabilities = new JsonObject();
JsonObject ltOptions = new JsonObject();
capabilities.addProperty("browsername", "Chrome");
capabilities.addProperty("browserVersion", "latest");
ltOptions.addProperty("platform", "Windows 10");
ltOptions.addProperty("name", "Playwright Single Cloud Test");
ltOptions.addProperty("build", "Playwright Java");
ltOptions.addProperty("user", username);
ltOptions.addProperty("accessKey", accessKey);
capabilities.add("LT:Options", ltOptions);
String cdpUrl = "wss://cdp.lambdatest.com/playwright?capabilities=" +
URLEncoder.encode(capabilities.toString(), "utf-8");
Browser browser = playwright.chromium().connect(cdpUrl);
// Create BrowserContext object and use it to create a Page object to execute cases in isolation
BrowserContext browserContext = browser.newContext();
Page page = browserContext.newPage();
SampleTestFlow.playwrightTestFlow(page);
page.close();
browserContext.close();
browser.close();
playwright.close();
}
catch (Exception err) {
err.printStackTrace();
}
}
}
代码演练：PlaywrightTestSingle.java
步骤 1. 将以下导入添加到测试类中，以访问这些包中的方法。
TestNG 注解以能够使用 @Test 注解，gson 库以创建 JsonObject，playwright 包以使用其接口，以及 SampleTestFlow 类以调用测试流程方法。
步骤 2. 将测试用例方法添加为 playwrightTestSingle() 并用 @Test 注解对其进行注解，以便执行测试用例。
步骤 3. 如前所述，我们将在 LambdaTest 云网格上执行用例，以利用云网格并能够编写更健壮和可伸缩的自动化用例。为此，您必须在 LambdaTest 平台上创建一个帐户。
创建帐户后，从 LambdaTest 个人资料的“密码和安全”部分获取您的用户名和访问密钥。
或者，您也可以将这些配置为环境变量并直接在代码中获取它们。
适用于 macOS 和 Linux
export LT_USERNAME=LT_USERNAME
export LT_ACCESS_KEY=LT_ACCESS_KEY
适用于 Windows
set LT_USERNAME=LT_USERNAME
set LT_ACCESS_KEY=LT_ACCESS_KEY
步骤 4. 初始化 Playwright 的新实例以访问 Playwright API。
步骤 5. 创建 2 个 JsonObject 变量，并将其命名为 capabilities 和 ltOptions。
5.1) 我们使用这些变量来定义 Playwright 的 LambdaTest 云网格的属性。其中包括定义浏览器及其版本和平台。
用例的 name 和 build 详细信息可用于在 LambdaTest 平台上过滤执行日志。
并且，提及用于创建连接的 LambdaTest 帐户的 username 和 password。
步骤 6. 将 capabilities 对象传递给用于连接到 Playwright 测试执行的 LambdaTest 云网格的 URL。
步骤 7. 使用最初创建的 Playwright 对象，连接到具有 Chromium 浏览器类型的 LambdaTest 云网格。将其分配给 Browser 接口的对象。
我们在这里使用浏览器类型 Chromium，因为我们将在 Chrome 浏览器上执行用例，这在 步骤 5.1 的 browserName 属性中提到了。
步骤 8. 创建一个新的 browserContext 实例，为每次测试运行创建一个单独的线程，以便每个测试用例都可以隔离运行。BrowserContext 可以操作多个独立的浏览器会话，通常用于并行执行。
这相当于在使用 Selenium 进行 Web 自动化时，为每次测试运行创建单独线程的 ThreadLocal。
步骤 9. 在 browserContext 中，创建一个 page。测试用例流程中所有相应的操作都使用此 page 实例执行。
每个 BrowserContext 可以有多个页面。Page 是在浏览器上下文中打开的单个浏览器窗口或选项卡。它提供了许多用于与网页交互的方法。这些方法包括创建新页面、导航到 URL、在网页上定位 Web 元素以及与页面元素交互以执行操作。
步骤 10. 使用 page 实例调用 SampleTestFlow 类中的 playwrightTestFlow() 函数。这将执行测试场景并执行 Web 元素交互和断言。
步骤 11. 测试执行后，使用 close() 方法关闭 Playwright、BrowserContext、Browser 和 Page 实例以清理资源。
代码执行
通过将其作为 TestNG 测试运行来执行上述 Playwright 测试用例。
为此，右键单击并选择 Run As → TestNG Test。执行结果将在本地显示如下。
您还可以通过导航到 Automation → Web Automation 部分来查看 LambdaTest 仪表板上的执行结果。
在 LambdaTest 上使用 Playwright 运行并行测试
通过之前的执行，我们已经了解了 Playwright Java 项目的设置步骤，如何使用该组合编写第一个自动化测试用例，以及如何在云端执行它。
那么，让我们看看需要进行哪些额外更改才能在 2 个浏览器中并行执行相同的测试场景。
为此，我们将使用 TestNG 的 @DataProvider 注解的 parallel = true 属性。
在现有的 test.cloud_execution 包中，添加 2 个 Java 类文件
- PlaywrightTestParallel.java 用于并行执行的测试用例
- LambdaTestCapabilities.java 用于通过
DataProvider传递 2 种不同浏览器配置的执行能力。
包含用于在云上并行执行的 2 种浏览器能力的更新 LambdaTestCapabilities.java 文件如下所示。
package test.cloud_execution;
import org.testng.annotations.DataProvider;
import com.google.gson.JsonObject;
public class LambdaTestCapabilities
{
@DataProvider(name = "BrowserCapabilities", parallel = true)
public static Object[] getDefaultTestCapability()
{
String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" :
System.getenv("LT_USERNAME");
String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>"
: System.getenv("LT_ACCESS");
//capabilities for first browser - Chrome
JsonObject capabilities1 = new JsonObject();
JsonObject ltOptions1 = new JsonObject();
capabilities1.addProperty("browserName", "Chrome");
capabilities1.addProperty("browserVersion", "latest");
ltOptions1.addProperty("platform", "Windows 10");
ltOptions1.addProperty("name", "Playwright Parallel Test - Chrome");
ltOptions1.addProperty("build", "Playwright Java Parallel Cloud");
ltOptions1.addProperty("user", username);
ltOptions1.addProperty("accessKey", accessKey);
capabilities1.add("LT:Options", ltOptions1);
//capabilities for second browser - Edge
JsonObject capabilities2 = new JsonObject();
JsonObject ltOptions2 = new JsonObject();
capabilities2.addProperty("browserName", "MicrosoftEdge");
capabilities2.addProperty("browserVersion", "latest");
ltOptions2.addProperty("platform", "Windows 10");
ltOptions2.addProperty("name", "Playwright Parallel Test - Edge");
ltOptions2.addProperty("build", "Playwright Java Parallel Cloud");
ltOptions2.addProperty("user", username);
ltOptions2.addProperty("accessKey", accessKey);
capabilities2.add("LT:Options", ltOptions2);
return new Object[] { capabilities1, capabilities2 };
}
}
代码演练：LambdaTestCapabilities.java
步骤 1. 在类中，添加一个新方法 getDefaultTestCapability()。用 TestNG 的 @DataProvider 注解此方法。
此方法将用于传递测试数据，在本例中是浏览器能力，以便在 Lambdatest Playwright 云上针对 2 个浏览器（Chrome 和 Edge）执行。测试用例将在这两个浏览器上并行执行。
您会注意到，@DataProvider 注解使用了名称为 BrowserCapabilities 的 name 属性。这是我们在测试用例中用于定义要使用哪个数据提供程序的名称。
这里最重要的一点是注解中的 parallel = true 属性。这告诉 TestNG 所有数据都将传递给测试用例，然后用于在云上并行执行。
步骤 2. 由于我们正在 LambdaTest 云网格上执行 Playwright Java 用例，因此在您创建 LambdaTest 平台帐户后，从“密码和安全”部分获取您的用户名和访问密钥。
或者，您也可以将这些配置为环境变量并从中获取值，就像我们在之前的测试用例中讨论的那样。
步骤 3. 为两个不同的浏览器创建浏览器能力，我们将在其上并行执行 Playwright 用例。
3.1) 为第一个浏览器 Chrome 的配置创建 2 个 JsonObject capabilities1 和 ltOptions1。
3.2) 将所有浏览器和 LambdaTest 平台相关的配置添加到这些对象中，就像我们进行单个云执行时一样。
3.3) 类似地，为第二个浏览器 Edge 的配置创建 capabilities2 和 ltOptions2。
3.4) 与 Chrome 类似，在新的 JsonObject 中添加所有配置详细信息，并根据 Edge 进行必要的更改。这里需要注意的一个重要区别是 browserName 值。
步骤 4. 返回将由测试用例用于并行 Playwright 测试执行的两个能力对象。
完成此操作后，转到测试类文件以执行测试用例。
package test.cloud_execution;
import java.net.URLEncoder;
import org.testng.annotations.Test;
import com.google.gson.JsonObject;
import com.microsoft.playwright.*;
import base.SampleTestFlow;
public class PlaywrightTestParallel
{
@Test(dataProvider = "BrowserCapabilities", dataProviderClass = LambdaTestCapabilities.class)
public void playwrightTestParallel(JsonObject capability)
{
try (Playwright playwright = Playwright.create())
{
String cdpUrl = "wss://cdp.lambdatest.com/playwright?capabilities=" +
URLEncoder.encode(capability.toString(), "utf-8");
Browser browser = playwright.chromium().connect(cdpUrl);
// Create BrowserContext object and use it to create a Page object to execute cases in isolation
BrowserContext browserContext = browser.newContext();
Page page = browserContext.newPage();
SampleTestFlow.playwrightTestFlow(page);
page.close();
browserContext.close();
browser.close();
playwright.close();
}
catch (Exception err) {
err.printStackTrace();
}
}
}
代码演练：PlaywrightTestParallel.java
步骤 1. 创建一个名为 playwrightTestParallel() 的新测试方法。此方法将以 JsonObject 能力对象作为参数，其中包含从上一步中创建的测试数据提供程序传递的浏览器能力。
用 TestNG 的 @Test 注解此测试用例。在注解中，添加属性
dataProvider = "BrowserCapabilities"，用于指定此测试用例要使用的数据提供程序的名称。dataProviderClass = LambdaTestCapabilities.class，用于指定此数据提供程序所在的 Java 类名。
步骤 2. 初始化 Playwright 的新实例以访问 Playwright API。
步骤 3. 使用测试参数中的 capability 对象创建用于连接到 Playwright Java 测试执行的 LambdaTest 云网格的 URL。
步骤 4. 使用最初创建的 playwright 对象，调用带 URL 的 chromium() 函数以启动浏览器，并将其分配给 Browser 接口对象。
我们在此并行执行用例中使用 chromium() 浏览器类型，因为使用了 Chrome 和 MicrosoftEdge 浏览器，并且这两种浏览器类型都支持它们。
步骤 5. 使用 browser 对象创建 browserContext，这将有助于并行执行两个用例，但完全隔离，互不影响。
步骤 6. 使用 browserContext，创建一个新的 page 实例，该实例表示浏览器窗口/选项卡，在这种情况下它将被执行。
步骤 7. 调用先前创建的 SampleTestFlow 类的 playwrightTestFlow() 方法以执行测试场景。这是用于单个和并行执行的通用函数，无需进行任何修改。
步骤 8. 最后，使用 close() 方法关闭所有实例并释放内存。
代码执行
将测试用例作为 TestNG 测试执行，以检查执行结果。
您可以从下面的屏幕截图中注意到，总共执行了 2 个用例。
执行结果可以在 LambdaTest 仪表板的 Automation → Web Automation 部分查看，如下所示。
如果您想确认并行执行是否正常工作，请将 @DataProvider 注解中 parallel 属性的值更新为 false 并再次执行。
在这些执行结果中，您会注意到 IDE 和 LambdaTest 仪表板结果上的总执行时间显着增加。这证实了之前的执行是并行的，而这次用例是串行执行的。
至此，我们已经学会了大规模编写 Playwright 自动化并在 LambdaTest 云网格上并行执行它。
结论
本文总结了使用 Playwright Java 运行自动化测试。在本文中，我们了解了 Playwright、它的工作原理以及为什么它是使用 Java 进行 Web 自动化的一个不错的选择。我们还学习了如何使用 LambdaTest 云网格大规模执行 Playwright 自动化用例。您现在应该具备坚实的基础，能够使用 Playwright 解决复杂的自动化挑战。所以，是时候开始使用 Playwright 和 Java 编写您的第一个自动化脚本了！