黄瓜 – 快速指南

---

黄瓜 – 概述

为了更好地利用软件测试，组织现在向前迈进了一步。他们在开发过程中实施重要的验收测试场景。这种方法通常称为行为驱动开发(BDD)。

行为驱动开发也让我们有机会从开发人员和客户的角度创建测试脚本。因此，一开始，开发人员、项目经理、QA、用户验收测试人员和产品所有者（股东）都聚在一起，集思广益，讨论应该通过哪些测试场景，才能称此软件/应用程序成功。通过这种方式，他们提出了一组测试场景。所有这些测试脚本都是简单的英语语言，因此它也用于文档目的。

例子

如果我们正在开发用户身份验证功能，那么以下可能是几个关键的测试场景，需要通过才能称其为成功。

• 用户应该能够使用正确的用户名和正确的密码登录。

• 用户应该无法使用错误的用户名和正确的密码登录。

• 用户应该无法使用正确的用户名和错误的密码登录。

这个怎么运作

当代码准备好时，测试脚本也准备好了。代码必须通过 BDD 中定义的测试脚本。如果没有发生，则需要进行代码重构。只有在成功执行定义的测试脚本后代码才会被冻结。

这是一个非常简单的概念，但我们需要什么才能实现这个概念。答案是，行为驱动开发 (BDD) 框架。Cucumber 就是这样一种开源工具，它支持行为驱动的开发。更准确地说，Cucumber 可以定义为一个测试框架，由纯英文文本驱动。它兼具文档、自动化测试和开发辅助功能。

那么黄瓜有什么作用呢？它可以在以下步骤中描述 –

Cucumber 读取特性文件（稍后介绍）中用纯英文文本（Language Gherkin – 本教程稍后介绍）编写的代码。

它在步骤定义中找到每个步骤的精确匹配（一个代码文件 – 本教程稍后提供详细信息）。

要执行的代码片段可以是不同的软件框架，例如Selenium、Ruby on Rails等。并非每个 BDD 框架工具都支持每种工具。

这已经成为 Cucumber 比其他框架（如JBehave、JDave、Easyb等）更受欢迎的原因。

Cucumber 支持十多种不同的软件平台，例如 –

• Ruby on Rails
• 硒
• 微型容器
• 弹簧框架
• 瓦提尔

Cucumber 相对于其他工具的优势

• Cucumber 支持不同的语言，如 Java.net 和 Ruby。

• 它充当业务语言和技术语言之间的桥梁。我们可以通过用纯英文文本创建一个测试用例来实现这一点。

• 它允许在不了解任何代码的情况下编写测试脚本，也允许非程序员参与。

• 与其他工具不同，它服务于端到端测试框架的目的。

• 由于简单的测试脚本架构，Cucumber 提供了代码可重用性。

黄瓜 – 环境

在本章中，我们将看到在 Windows 机器上使用 Selenium WebDriver 和 Java 为 Cucumber 设置环境。

环境设置的先决条件

以下是设置所需的先决条件 –

爪哇

为什么我们需要– Java 是一种健壮的编程语言。Cucumber 支持 Java 平台执行。

如何安装–

步骤 1 – 从以下链接下载 jdk 和 jre http://www.oracle.com/technetwork/java/javase/downloads/index.html

步骤 2 – 接受许可协议。

第 3 步– 安装 JDK 和 JRE。

步骤 4 – 设置环境变量，如下面的屏幕截图所示。

蚀

为什么我们需要– Eclipse 是一个集成开发环境（IDE）。它包含一个基础工作区和一个用于自定义环境的可扩展插件系统。

如何安装–

步骤 1 – 确保您的机器上安装了 JAVA。

第 2 步– 从https://eclipse.org/downloads/下载 Eclipse

步骤 3 – 解压并安装 Eclipse。

马文

为什么我们需要– Maven 是一个主要用于 Java 项目的构建自动化工具。它提供了一个通用平台来执行诸如生成源代码、编译代码、将代码打包到 jar 等活动。稍后如果任何软件版本发生更改，Maven 提供了一种简单的方法来相应地修改测试项目。

如何安装–

步骤 1 – 从以下链接下载 Maven – https://maven.apache.org/download.cgi

步骤 2 – 解压缩文件并记住位置。

步骤 3 – 创建环境变量 MAVEN_HOME，如下面的屏幕截图所示。

Step 4 – 编辑 Path 变量并包含 Maven，如下面的屏幕截图所示。

第 5 步– 从 Eclipse 下载 MAVEN 插件。

步骤 6 – 打开 Eclipse。

第 7 步– 转到帮助 → Eclipse Marketplace → 搜索 Maven → Eclipse 的 Maven 集成 → 安装。

使用 Maven 配置 Cucumber

步骤 1 – 创建一个 Maven 项目。

• 转到文件 → 新建 → 其他 → Maven → Maven 项目 → 下一步。

• 提供组 ID（组 ID 将在所有项目中唯一标识您的项目）。

• 提供 artifact Id（artifact Id 是没有版本的 jar 的名称。您可以选择任何名称，小写）。单击完成。

第 2 步– 打开 pom.xml。

• 转到 Eclipse 左侧的包资源管理器。

• 展开CucumberTest项目。

• 找到pom.xml文件。

• 右键单击并选择该选项，使用“文本编辑器”打开。

第 3 步– 为 selenium 添加依赖项：这将指示 Maven 哪些 Selenium jar 文件将从中央存储库下载到本地存储库。

• 在编辑模式下打开pom.xml，在项目标签内创建依赖标签（<dependencies></dependencies>）。

• 在依赖项标签内，创建依赖项标签 (<dependency></dependency>)。

• 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

第 4 步– 为 Cucumber-Java 添加依赖项：这将指示 Maven，哪些 Cucumber 文件将从中央存储库下载到本地存储库。

• 再创建一个依赖标签。

• 在依赖项标签中提供以下信息

<dependency> 
   <groupId>info.cukes</groupId>
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

第 5 步– 为 Cucumber-JUnit 添加依赖项：这将指示 Maven，哪些 Cucumber JUnit 文件将从中央存储库下载到本地存储库。

• 再创建一个依赖标签。

• 在依赖项标签中提供以下信息

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

第 6 步– 为 JUnit 添加依赖项：这将指示 Maven，哪些 JUnit 文件将从中央存储库下载到本地存储库。

• 再创建一个依赖标签。

• 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

步骤 7 – 验证二进制文件。

• 一旦pom.xml中成功地编辑，保存它。

• 转到项目→清洁 – 这将需要几分钟。

您将能够看到一个 Maven 存储库，如下面的屏幕截图所示。

• 创建一个特征文件（稍后介绍）。

• 创建一个步骤定义文件（稍后会介绍）。

• 创建一个 JUnit 运行器来运行测试（稍后会介绍）。

黄瓜 – 小黄瓜

到目前为止，我们已经了解了 Cucumber 及其作用。它执行已在特性文件中定义的测试脚本（将在后续章节中介绍）。编写此可执行功能文件的语言称为Gherkin。Gherkin 是一种纯英文文本语言，它帮助工具-Cucumber 解释和执行测试脚本。

可能有人会认为，Cucumber 支持简单的英文文本已经讨论过很多次了，那么为什么我们需要一种单独的语言——Gherkins。答案在于行为驱动开发的概念。

如前所述，我们已经看到 BDD 在创建测试脚本时结合了不同的前景。它可以是开发前景、业务前景等。也就是说，我们在开发测试脚本时需要来自不同社区的人，如开发人员、项目经理、产品所有者和测试人员。由于这些人不属于同一类别，因此存在不使用通用语言进行测试脚本概念化的风险。这是小黄瓜的进化点。

Gherkin 在英文文本中提供了一组通用的关键字，不同社区的人们可以使用这些关键字，并以测试脚本的形式获得相同的输出。

例子

功能– 社交网站的登录功能。鉴于我是一个社交网站用户。当我输入用户名作为 username1 时。而我输入密码，密码1。然后我应该被重定向到该站点的主页。

上面提到的场景是一个称为用户登录的功能。所有以粗体突出显示的词都是 Gherkin 关键字。

其他几个关键字的示例 –

• 背景
• 但
• *
• 场景大纲
• 例子

Gherkin 将解析步骤定义文件中编写的每个步骤（稍后会介绍）。所以特征文件中提到的步骤和步骤定义文件（稍后介绍）应该匹配。

您可以在 Package Explorer 的 Maven Dependency 文件夹中找到 Gherkin jar。它与其他 Cucumber jar 一起下载。它看起来像下面的截图 –

关于 Gherkin 的另一个有趣事实是，它不仅支持英语，还支持许多其他母语，如法语、芬兰语、印度尼西亚语、匈牙利语、印地语、乌尔都语、古吉拉特语等。

黄瓜 – 特点

甲功能可以被定义为一个项目的一个独立的单元或功能。让我们举一个非常常见的社交网站示例。这个产品/项目的特性如何？很少有基本特征可以确定为 –

• 从社交网站创建和删除用户。

• 社交网站的用户登录功能。

• 在社交网站上分享照片或视频。

• 发送好友请求。

• 登出。

到目前为止，很明显，当我们谈论 Cucumber 时，被测产品的每个独立功能都可以称为一个特性。最佳实践是稍后开始测试时，在派生测试脚本之前，我们应该确定要测试的功能。

一个功能通常包含要为该功能测试的场景列表。我们在其中存储功能、有关要测试的功能和场景的描述的文件称为Feature File。我们将在下一章中看到更多关于特征文件的信息。

在 Gherkins 中表示被测功能的关键字是“功能”。建议的最佳做法是，在功能文件中的功能标题下方写下对该功能的简短描述。这也将满足良好文档的需要。

例子

功能– 社交网站的登录功能。

如果用户名和密码正确，用户应该能够登录到社交网站。

如果用户名和密码不正确，则应向用户显示错误消息。

如果用户名和密码正确，用户应导航到主页。

功能文件

编写 Cucumber 测试的文件称为特征文件。建议每个被测试的功能都有一个单独的功能文件。特征文件的扩展名需要是“.feature”。

可以根据需要创建任意数量的特征文件。为了有一个有组织的结构，每个特征都应该有一个特征文件。

例如 –

Sr.No	特征	特征文件名
1	用户登录	用户登录功能
2	分享帖子	sharePost.feature
3	创建帐号	createAccount.feature
4	删除帐户	删除账户功能

用于特征名称、特征文件名的命名约定取决于个人的选择。Cucumber 中没有关于名称的基本规则。

一个简单的功能文件由以下关键字/部分组成 –

• 功能– 被测功能的名称。

• 描述（可选）- 描述被测功能。

• 场景– 什么是测试场景。

• Given – 执行测试步骤之前的先决条件。

• When – 为了执行下一步而应匹配的特定条件。

• 那么– 如果满足 WHEN 中提到的条件，会发生什么。

例子

功能– 用户登录社交网站。

当用户名和密码正确时，用户应该能够登录到社交网站。

当用户名和密码不正确时，应向用户显示错误消息。

如果用户名和密码正确，用户应该被导航到主页。

大纲– 社交网站的登录功能。

给定的用户导航到 Facebook。当我输入用户名为“<用户名>”和密码为“<密码>”时。然后，登录应该不成功。

| username  | password  |
| username1 | password1 |

* AND关键字用于显示两个条件之间的连接。AND可以与任何其他关键字一起使用，例如GIVEN、WHEN和THEN。

功能文件中没有写入逻辑细节。

步骤定义

我们已经准备好我们的功能文件，并定义了测试场景。然而，这并不是完成的全部工作。Cucumber 并不真正知道要针对功能文件中概述的任何特定场景执行哪一段代码。

这就需要一个中间的——步骤定义文件。步骤定义文件存储特征文件中定义的场景的每个步骤与要执行的功能代码之间的映射。

所以，现在当 Cucumber 执行特征文件中提到的场景的一个步骤时，它会扫描步骤定义文件并找出要调用的函数。

步骤定义文件示例

public void goToFacebook() { 
   driver = new FirefoxDriver(); 
   driver.navigate().to("https://www.facebook.com/"); 
} 
@When "^user logs in using Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$"
public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
   driver.findElement(By.id("email")).sendKeys(arg1);
   driver.findElement(By.id("pass")).sendKeys(arg2);
   driver.findElement(By.id("u_0_v")).click(); 
} 
@Then"^login should be unsuccessful$" 
public void validateRelogin() { 
   if(driver.getCurrentUrl().equalsIgnoreCase(
      "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
         System.out.println("Test Pass");
   } else { 
      System.out.println("Test Failed"); 
   } 
   driver.close(); 
}

因此，对于每个函数，无论您想在每个测试步骤中执行什么代码（即 GIVEN/THEN/WHEN），您都可以在 Step Definition 文件中编写它。确保为每个步骤定义了代码/功能。

这个函数可以是 Java 函数，我们可以在其中使用 Java 和 Selenium 命令来自动化我们的测试步骤。

黄瓜 – 场景

Scenario是 Gherkin 的核心结构之一。每个场景都以关键字“场景：”（或本地化的）开头，后跟可选的场景标题。每个功能可以有一个或多个场景，每个场景都包含一个或多个步骤。一个非常简单的场景示例可以是 –

场景– 验证帮助功能。

给定用户导航到 Facebook。

当用户单击“帮助”时，将打开“帮助”页面。

考虑一个案例，我们需要多次执行一个测试场景。假设，我们需要确保登录功能适用于所有类型的订阅持有者。这需要多次执行登录功能场景。复制粘贴相同的步骤以重新执行代码，似乎不是一个聪明的主意。为此，Gherkin 提供了另一种结构，即场景大纲。

场景大纲类似于场景结构；唯一的区别是提供多种输入。正如您在以下示例中所见，测试用例保持不变且不可重复。在底部，我们为变量“用户名”和“密码”提供了多个输入值。在运行实际测试时，Cucumber 将使用提供的输入值替换变量并执行测试。一旦执行了 pass-1，测试将使用另一个输入值重新运行进行第二次迭代。此类变量或占位符可以用“<>”表示，同时用小黄瓜语句提及。

例子

Scenario Outline – 社交网站的登录功能。给定的用户导航到 Facebook。

当用户使用用户名作为“<username>”和密码作为“<password>”登录时，登录应该成功。

| username | password  | 
| user1    | password1 | 
| user2    | password2 |

有一些技巧和窍门可以巧妙地定义 Cucumber 场景。

• 每个步骤都应该明确定义，以免给读者造成任何混淆。

• 不要重复测试场景，如果需要，使用场景大纲来实现重复。

• 以一种可以在多个场景和场景大纲中使用的方式开发测试步骤。

• 尽可能保持每个步骤完全独立。例如：“鉴于用户已登录”。这可以分为两步

  • 给定用户输入用户名。
  • 点击登录。

黄瓜 – 注释

注释是预定义的文本，具有特定的含义。它让编译器/解释器知道在执行时应该做什么。黄瓜有以下几个注释 –

• 鉴于–

  • 它描述了执行测试的先决条件。

  • 示例 – 鉴于我是 Facebook 用户

• 当–

  • 它定义了任何测试场景执行的触发点。

  • 示例 – 当我输入“<用户名>”

• 然后–

  • 然后保存要执行的测试的预期结果。

  • 示例 – THEN 登录应该成功。

• 和–

  • 它提供任意两个语句之间的逻辑 AND 条件。AND 可以与 GIVEN、WHEN 和 THEN 语句结合使用。

  • 示例 – 当我输入“<username>”并输入“<password>”时

• 但是–

  • 它表示任何两个语句之间的逻辑 OR 条件。OR 可以与 GIVEN、WHEN 和 THEN 语句结合使用。

  • 示例 – THEN 登录应该成功。但是主页不应该丢失。

• 场景–

  • 需要在关键字“Scenario:”后获取被测场景的详细信息

  • 示例 –

    设想：

    鉴于我是 Facebook 用户

    当我输入我的

    然后我输入我的

    那么登录应该就成功了。

    但是主页不应该丢失。

• 场景大纲– （稍后介绍）

• 示例– （稍后介绍）

• 背景–

  • 后台通常有关于在每个场景运行之前设置什么的说明。但是，它会在“Before”钩子之后执行（稍后会介绍）。因此，当我们想要设置 Web 浏览器或想要建立数据库连接时，这是用于代码的理想选择。

    • 示例 –

      背景：

      转到 Facebook 主页。

示例场景

让我们自动化一个场景，以便更好地理解注释。

步骤1

创建一个名为AnnotationTest的 Maven 测试项目。

• 转到文件 → 新建 → 其他 → Maven → Maven 项目 → 下一步。

• 提供组 ID（组 ID 将在所有项目中唯一标识您的项目）。

• 提供 artifact Id（artifact Id 是没有版本的 jar 的名称。您可以选择任何小写的名称）。

• 单击完成。

• 打开pom.xml –

  • 转到 Eclipse 左侧的包资源管理器。

  • 展开项目 AnnotationTest。

  • 找到 pom.xml 文件。

  • 右键单击并选择选项，使用“文本编辑器”打开。

• 为 Selenium 添加依赖项 – 这将指示 Maven，哪些 Selenium jar 文件将从中央存储库下载到本地存储库。

  • 在编辑模式下打开 pom.xml，在项目标签内创建依赖标签（<dependencies></dependencies>）。

  • 在依赖项标签内，创建依赖项标签 (<dependency></dependency>)。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

• 为 Cucumber-Java 添加依赖项 – 这将指示 Maven，哪些 Cucumber 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标签内提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

• 为 Cucumber-JUnit 添加依赖项 – 这将指示 Maven，哪些 Cucumber JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

• 为 JUnit 添加依赖项 – 这将指示 Maven，哪些 JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

• 验证二进制文件。

  • pom.xml 编辑成功后，保存。

  • 转到项目→清洁 – 这将需要几分钟。

第2步

在src/test/java下创建一个名为 Annotation 的包

• 选择新创建的项目。

• 右键单击并选择“新建”。

• 选择选项作为“包”。

• 将其命名为“注释”。

• 保存。

第 3 步

创建一个名为annotation.feature的特征文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 为文件命名，例如outline.feature。

• 在文件中写入以下文本并保存。

Feature: annotation 
#This is how background can be used to eliminate duplicate steps 

Background: 
   User navigates to Facebook Given 
   I am on Facebook login page 

#Scenario with AND 
Scenario: 
   When I enter username as "TOM"
   And I enter password as "JERRY" 
   Then Login should fail 

#Scenario with BUT 
Scenario: 
   When I enter username as "TOM" 
   And I enter password as "JERRY" 
   Then Login should fail 
   But Relogin option should be available

第四步

创建步骤定义文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 将文件名指定为annotation.java

• 在文件中写入以下文本并保存。

package Annotation; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class annotation { 
   WebDriver driver = null; 
   @Given("^I am on Facebook login page$") 
	
   public void goToFacebook() { 
      driver = new FirefoxDriver(); 
      driver.navigate().to("https://www.facebook.com/"); 
   }
	
   @When("^I enter username as \"(.*)\"$") 
   public void enterUsername(String arg1) {   
      driver.findElement(By.id("email")).sendKeys(arg1); 
   }
	
   @When ("^I enter password as \"(.*)\"$") 
   public void enterPassword(String arg1) {
      driver.findElement(By.id("pass")).sendKeys(arg1);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^Login should fail$") 
   public void checkFail() {  
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test1 Pass"); 
      } else { 
         System.out.println("Test1 Failed"); 
      } 
      driver.close(); 
   } 
	
   @Then("^Relogin option should be available$") 
   public void checkRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test2 Pass"); 
      } else { 
         System.out.println("Test2 Failed"); 
      } 
      driver.close(); 
   }
} 

第 5 步

创建一个跑步者类文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 为文件命名，例如runTest.java

• 在文件中写入以下文本并保存。

package Annotation; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})
 
public class runTest { 
}

第 6 步

使用选项运行测试 –

• 从包资源管理器中选择 runTest.java 文件。

• 右键单击并选择“运行方式”选项

• 选择 JUnit 测试。

运行此类文件时，您将观察到以下内容 –

• Facebook 在新的 Firefox 网络浏览器实例中打开。

• TOM 将作为输入传递给用户名字段。

• JERRY 将作为输入传递给密码字段。

• 登录将被点击。

• 浏览器将显示有关登录失败的消息。

• 在控制台中，您将看到打印出“Test Pass”

• 步骤结果 1. 到 5. 将重新执行用户名为“”和密码为“”。

黄瓜 – 情景大纲

场景大纲基本上用表中的值替换变量/关键字。表中的每一行都被认为是一个场景。

让我们继续使用 Facebook 登录功能的相同示例。到目前为止，我们一直在执行一个场景：提供正确的用户名后，登录成功。现在，假设我们要检查所有三种可能的输入类型（用户名、电子邮件地址或电话号码）的登录是否成功。为了实现这一点，我们需要编写三个不同的场景，其中每个场景都会随着输入的类型而变化，登录成功。在这种情况下，场景将如下所示。

设想：

给定用户导航到 Facebook

当我输入正确的用户名和密码时

那么登录应该就成功了

设想：

给定用户导航到 Facebook

当我输入正确的电子邮件地址和密码时

那么登录应该就成功了

设想：

给定用户导航到 Facebook

当我输入正确的电话号码和密码时

那么登录应该就成功了

在这里，如果我们仔细观察，对于上述三种情况：语句相同，只是输入参数（用户名/电子邮件地址/电话号码）发生了变化。这就是场景大纲的重要性体现出来的地方。

当我们使用场景大纲定义任何场景时，我们可以指定一个测试场景，并在其底部提供多个输入。该场景将执行与提供的输入数量一样多的次数。

例子

让我们创建一个场景大纲的例子 –

步骤 1 – 创建一个名为ScenarioOutlineTest的 Maven 测试项目

• 转到文件 → 新建 → 其他 → Maven → Maven 项目 → 下一步。

• 提供组 ID（组 ID 将在所有项目中唯一标识您的项目）。

• 提供 artifact Id（artifact Id 是没有版本的 jar 的名称。您可以选择任何小写的名称）。

• 单击完成。

• 打开pom.xml –

  • 转到 Eclipse 左侧的包资源管理器。

  • 展开 CucumberTest 项目。

  • 找到 pom.xml 文件。

  • 右键单击并选择选项，使用“文本编辑器”打开。

• 为 Selenium 添加依赖项 – 这将指示 Maven，哪些 Selenium jar 文件将从中央存储库下载到本地存储库。

  • 在编辑模式下打开 pom.xml，在项目标签内创建依赖标签（<dependencies></dependencies>）。

  • 在依赖项标签内，创建依赖项标签 (<dependency></dependency>)。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

• 为 Cucumber-Java 添加依赖项：这将指示 Maven，哪些 Cucumber 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标签内提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

• 为 Cucumber-JUnit 添加依赖项：这将指示 Maven，哪些 Cucumber JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

• 为 JUnit 添加依赖项 – 这将指示 Maven，哪些 JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

• 为 JUnit 添加依赖项 – 这将指示 Maven，哪些 JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

• 验证二进制文件。

  • pom.xml 编辑成功后，保存。

  • 转到项目→清洁 – 这将需要几分钟。

第 2 步– 在src/test/java下创建一个名为“outline”的包

步骤 3 – 创建一个名为“outline.feature”的特征文件

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 提供文件名，例如“outline.feature”

  • 在文件中写入以下文本并保存。

    功能– 场景大纲

    Scenario Outline – 社交网站的登录功能。

    给定用户导航到 Facebook

    当我输入用户名为“<用户名>”和密码为“<密码>”时

    那么登录应该是不成功的

示例–

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

注意– 此处，示例注释描述了在场景执行时提供的输入范围。将为提供的每个输入执行测试场景。因此，在给定的示例中，测试场景将执行 3 次。

步骤 4 – 创建一个步骤定义文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 将文件名指定为stepdefinition.java

• 在文件中写入以下文本并保存。

package Outline;
 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class stepdefinition { 
   WebDriver driver = null; 
	
   @Given("^user navigates to facebook$") 
   public void goToFacebook() { 
      driver = new FirefoxDriver(); 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
	
   @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") 
   public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
      driver.findElement(By.id("email")).sendKeys(arg1);
      driver.findElement(By.id("pass")).sendKeys(arg2);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
      "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){
         System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   }    
}

注意– 在上面的代码中，我们必须定义一个具有两个输入参数的函数：一个用户名，另一个用于密码。因此，对于示例标签中提供的每组输入，将执行 Set of GIVEN、WHEN 和 THEN。

第 5 步– 创建一个跑步者类文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 给出文件名，例如runTest.java

• 在文件中写入以下文本并保存。

package Outline; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})

public class runTest { }

• 使用选项运行测试 –

  • 从包资源管理器中选择runTest.java文件。

  • 右键单击并选择选项‘Run as’。

  • 选择 JUnit 测试。

运行这个类文件你会观察到以下几点

• Facebook 在新的 Firefox 网络浏览器实例中打开。

• Username1 和 password1 将作为输入传递给用户名和密码字段。

• 登录将被点击。

• 浏览器将显示有关登录失败的消息。

• 在控制台中，您将看到打印的“测试通过”。

• 对username2 和password2 将重新执行步骤结果1 到5。

简而言之，当场景没有变化而只是数据值发生变化时，建议使用场景大纲数据表。

黄瓜 – 标签

当我们在一个特性文件中只有一个、两个或五个场景时，这看起来很简单。然而，在现实生活中它不会发生。对于每个被测试的特性，我们可能在一个特性文件中有 10 个、20 个或更多的场景。它们可能代表不同的目的（冒烟测试/回归测试）、不同的预期（开发人员/QA/BA）、不同的状态（准备执行/正在进行的工作）等。如何管理如此大量的执行？

为此，Cucumber 已经提供了一种通过在特征文件中使用标签来组织场景执行的方法。我们可以用一个有用的标签定义每个场景。稍后，在 runner 文件中，我们可以决定我们希望 Cucumber 执行哪个特定标签（以及场景）。标签以“@”开头。在“@”之后，您可以使用任何相关文本来定义您的标签。让我们通过一个例子来理解这一点。

假设在一个特征文件中有两个或多个场景。我们只想执行一个场景作为冒烟测试的一部分。因此，第一件事是识别该场景，第二件事是在场景开头用“@SmokeTest”文本标记它。让我们深入研究一下 –

第 1 步– 创建一个 Maven 项目，命名为ucucumberTag。

第 2 步–在src/test/java下创建一个名为CucumberTag的包

步骤 3 – 创建一个名为ucumberTag.feature的特征文件。

在文件中写入以下文本并保存。此功能文件包含两个场景，其中只有一个被标记为SmokeTest标签。

功能– 黄瓜标签

Scenario Outline – 社交网站的登录功能。

给定用户导航到 Facebook

当我输入用户名为“<用户名>”和密码为“<密码>”时

那么登录应该是不成功的

例子

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

#following 场景已被标记为 SmokeTest，这应该被执行。@SmokeTest

设想：

给定用户导航到 Facebook

当我输入用户名“<>”和密码“<>”时

然后用户应该被重定向到登录重试

步骤 4 – 创建一个步骤定义文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 给文件起一个名字，比如cucumberTag.java

• 在文件中写入以下文本并保存。

package cucumberTag;
 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class cucumberTag { 
   WebDriver driver = null; 
	
   @Given("^user navigates to facebook$") 
   public void goToFacebook() { 
      driver = new FirefoxDriver(); 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
	
   @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") 
   public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
      driver.findElement(By.id("email")).sendKeys(arg1);
      driver.findElement(By.id("pass")).sendKeys(arg2);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      }
      driver.close(); 
   } 
	
   @Then("^User should be redirected to login retry$") 
   public void loginRetry() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

第 5 步– 创建一个跑步者类文件。

• 在包内创建一个名为runTest.java 的运行器类。

• 编写以下代码。

• 保存文件。

package cucumberTag; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 

public class runTest { }

• 运行测试选项。

• 右键单击并选择选项‘Run as’。

• 选择 JUnit 测试。

当您运行这个类文件时，您将观察到以下情况。

• Facebook 在新的 Firefox 网络浏览器实例中打开。

• 不会为用户名和密码字段提供任何值。

• 登录将被点击。

• 将加载登录重试页面。

在特征文件中定义标签没有限制。根据您的需要，您可以导出要使用的标签和要执行的场景。

主要有两种类型的标签 –

• 默认标签– 默认标签具有其预定义的含义。示例@Dev,@Ignore

• 自定义标签– 自定义标签为您提供了充分的灵活性来选择合适的文本来定义您的标签。

标签也可以在功能级别定义。在功能级别定义标签后，它确保该功能文件中的所有场景都继承该标签。根据场景的性质，我们可以为单个功能使用多个标签。每当 Cucumber 找到合适的调用时，就会执行特定的场景。

Cucumber 还提供了一种反转标签选择的方法。考虑到在 25 个定义的场景中，10 个被标记为冒烟测试。我们只需要执行回归测试场景。

为此，我们可以在 JUnit runner 类中使用“~”来排除冒烟测试场景。它将如下所示。

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}, 
   tags = {"~@SmokeTest"})
	
public class runTest { }

在定义多个标签的同时，我们还可以定义逻辑或/和逻辑与操作。

• 定义逻辑或在 runner 类中 – @dev,@wip – 它表示需要执行匹配任何此标签的场景。

• 定义逻辑或运行器类 – [@dev,~@wip] –它表示需要执行匹配这两个标签的场景。

黄瓜 – 数据表

在进行自动化工作时，我们可能会面临各种场景。每个场景都有不同的含义和需求。

从一开始，我们就以社交网站的登录功能为例，我们只需要传递两个输入参数。让我们想一些更多的可能性。“新用户注册”功能怎么样？通常，为社交网站注册新用户时的输入参数是什么？类似于以下内容 –

• 用户名
• 电子邮件地址
• 密码
• 重新输入密码
• 出生日期
• 性别
• 电话号码

功能– 新用户注册。

验证通过错误输入后新用户注册不成功。

鉴于我在新用户注册页面上。

当我输入用户名和电子邮件地址作为电子邮件地址和密码，并重新输入密码和出生日期和性别和电话号码时，用户注册应该不成功。

乍一看有点乱。那么，有没有更好的方法来管理这些输入？答案可以是“数据表”。数据表是为单个标签提供的一组输入。此标签可以是 GIVEN、WHEN 或 THEN。

让我们在数据表的帮助下编写上述场景，它将如下所示 –

鉴于我在新用户注册页面上

当我在页面上输入有效数据时

| Fields                 | Values              |
| First Name             | Tom                 |
| Last Name              | Kenny               |
| Email Address          | [email protected] |
| Re-enter Email Address | [email protected] |
| Password               | Password1           |
| Birthdate              | 01                  |

那么用户注册应该就成功了。

例子

让我们自动化一个数据表的例子。

步骤 1 – 创建一个名为“DataTableTest”的 Maven 测试项目。

• 转到文件 → 新建 → 其他 → Maven → Maven 项目 → 下一步。

• 提供组 ID（组 ID 将在所有项目中唯一标识您的项目）。

• 提供artifact Id（artifact Id 是没有版本的 jar 的名称。您可以选择任何小写的名称）。

• 单击完成。

• 打开 pom.xml –

  • 转到 Eclipse 左侧的包资源管理器。

  • 展开 CucumberTest 项目。

  • 找到 pom.xml 文件。

  • 右键单击并选择选项，使用“文本编辑器”打开。

• 为 Selenium 添加依赖项：这将指示 Maven，哪些 Selenium jar 文件将从中央存储库下载到本地存储库。

  • 在编辑模式下打开 pom.xml，在项目标签内创建依赖标签（<dependencies></dependencies>）。

  • 在依赖项标签内，创建依赖项标签。(<dependency></dependency>)。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

• 为 Cucumber-Java 添加依赖项 – 这将指示 Maven，哪些 Cucumber 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

• 为 Cucumber-JUnit 添加依赖项 – 这将指示 Maven，哪些 Cucumber JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

• 为 JUnit 添加依赖项 – 这将指示 Maven，哪些 JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标签中提供以下信息

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

• 验证二进制文件。

  • pom.xml 编辑成功后，保存。

  • 转到项目→清洁 – 这将需要几分钟。

Step 2 –在src/test/java下创建一个名为dataTable的包

步骤 3 – 创建一个功能文件。

• 在包 dataTable 中创建一个名为dataTable .feature的功能文件（有关更详细的步骤，请参阅场景大纲部分）。

• 写出下面的文字。

  功能– 数据表

  验证在传递错误输入后新用户注册不成功。

  设想：

  鉴于我在新用户注册页面

  当我在页面上输入无效数据时

| Fields                 | Values              |
| First Name             | Tom                 |
| Last Name              | Kenny               |
| Email Address          | [email protected] |
| Re-enter Email Address | [email protected] |
| Password               | Password1           |
| Birthdate              | 01                  |

那么用户注册应该是不成功的

• 保存文件。

步骤 4 – 创建步骤定义文件。

• 在包 dataTable 中创建名为“dataTable.java”的步骤定义文件（有关更详细的步骤，请参阅场景大纲部分）。

• 编写以下代码。

package dataTable; 

import java.util.List; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.WebElement; 
import org.openqa.selenium.firefox.FirefoxDriver; 
import org.openqa.selenium.support.ui.Select;

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 
import cucumber.table.DataTable; 

public class stepdefinition { 
   WebDriver driver = null;
	
   @Given("^I am on new user registration page$") 
   public void goToFacebook() { 
      //Intiate web browser instance. driver = new FirefoxDriver();
      driver.navigate().to("https://www.facebook.com/"); 
   } 
	
   @When("^I enter invalid data on the page$") 
   public void enterData(DataTable table){ 
      //Initialize data table 
      List<list> data = table.raw();
      System.out.println(data.get(1).get(1)); 
      
      //Enter data
      driver.findElement(By.name("firstname")).sendKeys(data.get(1).get(1));
      driver.findElement(By.name("lastname")).sendKeys(data.get(2).get(1));
      driver.findElement(By.name("reg_email__")).sendKeys(data.get(3).get(1));     
      driver.findElement(By.name("reg_email_confirmation__")).
         sendKeys(data.get(4).get(1)); 
      driver.findElement(By.name("reg_passwd__")).sendKeys(data.get(5).get(1)); 
      
      Select dropdownB = new Select(driver.findElement(By.name("birthday_day"))); 
      dropdownB.selectByValue("15"); 
		
      Select dropdownM = new Select(driver.findElement(By.name("birthday_month")));
      dropdownM.selectByValue("6"); 
		
      Select dropdownY = new Select(driver.findElement(By.name("birthday_year")));
      dropdownY.selectByValue("1990"); 
		
      driver.findElement(By.className("_58mt")).click(); 
      // Click submit button driver.findElement(By.name("websubmit")).click(); 
   } 
	
   @Then("^User registration should be unsuccessful$") 
   public void User_registration_should_be_unsuccessful() {
      if(driver.getCurrentUrl().equalsIgnoreCase("https://www.facebook.com/")){
         System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

• 保存文件。

第 5 步– 创建一个跑步者类文件。

• 在包内创建名为 runTest.java 的运行器类。

• 编写以下代码。

package dataTable; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})
 
public class runTest { }

• 保存文件。

• 使用选项运行测试

  • 从包资源管理器中选择 runTest.java 文件。

  • 右键单击并选择选项 Run as。

  • 选择 JUnit 测试。

成功执行后，您可能会观察到以下情况。

• Facebook 网站已加载。

• 将在注册页面上输入数据。

• 提交按钮将被点击。

• 我们会看到主页不会显示，并且“Test Pass”会写在控制台上。

黄瓜 – 评论

注释基本上是一段用于文档目的而不是执行的代码。无论是步骤定义文件还是特征文件，都可以使其更具可读性和可理解性。因此，在文件中的适当位置使用/放置注释很重要。这也有助于调试代码。黄瓜特征文件可以在任何地方有注释。要添加注释，我们只需要以“#”号开始语句。

不同的编程语言有不同的定义注释的规范。让我们看看 Cucumber 如何处理它。

• 步骤定义文件 – 如果您使用 Java 作为平台，请用“//”标记您的注释。

• 功能文件 – 如果是功能文件，我们只需要在开始评论之前输入 #。

例子

程序中突出显示的文本是指代码中的注释。

Feature: annotation 

#This is how background can be used to eliminate duplicate steps 
Background: 
User navigates to Facebook 
Given I am on Facebook login page 

#Scenario with AND 
Scenario: 
When I enter username as "TOM" 
And I enter password as "JERRY" 
Then Login should fail 

#Scenario with BUT 
Scenario: 
When I enter username as "TOM" 
And I enter password as "JERRY" 
Then Login should fail 
But Relogin option should be available

黄瓜 – 挂钩

Cucumber hook可以让我们更好地管理代码工作流，帮助我们减少代码冗余。我们可以说这是一个看不见的步骤，它允许我们执行我们的场景或测试。

为了更好地理解这个概念，让我们以特征文件和步骤定义文件为例。

给定语句中突出显示的部分实际上完成了设置 webdriver 和结束 webdriver 会话的工作。因此，它实际上与“给定语句”的本质无关，而更像是测试的设置。此外，如果我们从更广泛的角度考虑，那么在此功能的多个场景的情况下，此 webdriver 设置和清理将与每个给定的语句一起运行。从逻辑上讲，设置和清理只执行一次是有意义的。

所以为了带来优化，可以利用钩子。我们更经常使用两种类型的钩子：“Before”钩子和“After”钩子。在 Before 和 After 钩子中定义的方法/函数/代码段始终运行，即使场景通过或失败。

顾名思义，before hook 在任何其他测试场景之前执行，而 after hook 在执行所有场景之后执行。

挂钩仅在步骤定义文件中定义。

让我们自动化一个前后钩子的例子。

步骤 1 – 创建 Maven 项目作为 hookTest，在 pom.xml 中添加必要的依赖项。

第 2 步– 在src/test/java下创建一个名为 hookTest 的 Java 包

步骤 3 –在包下创建一个名为hookTest.java的步骤定义文件。

package hookTest; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class hookTest {
   WebDriver driver = null; 
	
   @Before public void setUp(){ 
      driver = new FirefoxDriver(); 
   } 
	
   @Given("^user navigates to facebook$") 
   public void goToFacebook() { 
      driver.navigate().to("https://www.facebook.com/");
   } 
	
   @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") 
   public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
      driver.findElement(By.id("email")).sendKeys(arg1);
      driver.findElement(By.id("pass")).sendKeys(arg2);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
	
   @After public void cleanUp(){ 
      driver.close(); 
   } 
}

第 4 步– 在包下创建一个名为“hookTest.feature”的功能文件。

功能– 场景大纲。

场景大纲– 钩子测试

给定用户导航到 Facebook

当我输入用户名为“<用户名>”和密码为“<密码>”时

那么登录应该是不成功的

例子

| username  | password  | 
| username1 | password1 |

第 5 步– 创建一个跑步者类文件。

• 在包 dataTable 中创建 runner 类作为 runTest.java（有关更详细的步骤，请参阅场景大纲部分）。

• 编写以下代码。

package hookTest; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"})  

public class runTest { }

• 保存文件。

• 使用选项运行测试 –

  • 从包资源管理器中选择 runTest.java 文件。

  • 右键单击并选择选项 Run as。

  • 选择 JUnit 测试。

所以现在当我们运行它时，以下将是执行顺序。

• Before hook – 设置 webdriver 和其他先决条件来运行测试。

• 给定语句

• 当语句

• 然后声明

• After hook – 关闭 webdriver 并执行清理过程。

标记的钩子

我们还可以指示我们是否希望仅使用特定标签执行 before 和 after 钩子。示例– @Before(‘@Web’)。标签逻辑和/或的相同概念也可以应用于钩子。示例– @Before(@dev,@wip), @Before(@dev,~@wip)

黄瓜 – 命令行选项

Cucumber 可用于测试几乎任何计算机系统。到目前为止，我们已经了解了如何使用 Eclipse IDE 运行测试。还有另一种方法可以通过命令行界面运行 Cucumber 测试。那么这样做有什么好处呢？

从终端运行任何测试框架都有其自身的优势，例如覆盖代码中提到的运行配置。

要在命令提示符下执行 Cucumber 测试，请在系统配置后使用以下步骤。

第 1 步– 创建一个名为commandLine的 Maven 测试项目。

• 转到文件 → 新建 → 其他 → Maven → Maven 项目 → 下一步。

• 提供组 ID（组 ID 将在所有项目中唯一标识您的项目）。

• 提供 artifact Id（artifact Id 是没有版本的 jar 的名称。您可以选择任何小写的名称）。

• 单击完成。

• 打开 pom.xml –

  • 转到 Eclipse 左侧的包浏览器。

  • 展开 CucumberTest 项目。

  • 找到pom.xml文件。

  • 右键单击并选择选项，使用“文本编辑器”打开。

• 为 Selenium 添加依赖项 – 这将指示 Maven，哪些 Selenium jar 文件将从中央存储库下载到本地存储库。

  • 在编辑模式下打开 pom.xml，在项目标签内创建依赖标签（<dependencies></dependencies>）。

  • 在依赖项标签内，创建依赖项标签。(<dependency></dependency>)。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

• 为 Cucumber-Java 添加依赖项 – 这将指示 Maven，哪些 Cucumber 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

• 为 Cucumber-JUnit 添加依赖项 – 这将指示 Maven，哪些 Cucumber JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

• 为 JUnit 添加依赖项 – 这将指示 Maven，哪些 JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标签内提供以下信息。

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

• 验证二进制文件。

  • pom.xml 编辑成功后，保存。

  • 转到项目→清洁 – 这将需要几分钟。

第 2 步– 在 src/test/java 下创建一个名为“outline”的包

第 3 步– 创建一个名为“commandLine.feature”的功能文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 为文件命名，例如“commandLine.feature”

• 在文件中写入以下文本并保存。

  功能– 场景大纲

  Scenario Outline – 社交网站的登录功能。

  鉴于用户导航到 Facebook

  当我输入用户名为“<用户名>”和密码为“<密码>”时

  那么登录应该是不成功的

例子

| username  | password  | 
| username1 | password1 | 
| username2 | password2 |

注意– 此处，示例注释描述了在场景执行时提供的输入范围。将为提供的每个输入执行测试场景。因此，在给定的示例中，测试场景将执行 3 次。

步骤 4 – 创建一个步骤定义文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 将文件命名为commandLine.java

• 在文件中写入以下文本并保存。

package Outline; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; i
import cucumber.annotation.en.When; 

public class stepdefinition { 
   WebDriver driver = null;
	
   @Given("^user navigates to facebook$") 
   public void goToFacebook() { 
      driver = new FirefoxDriver(); 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
	
   @When("^I enter Username as \"([^\"]*)\" and Password as \"([^\"]*)\"$") 
   public void I_enter_Username_as_and_Password_as(String arg1, String arg2) {
      driver.findElement(By.id("email")).sendKeys(arg1);
      driver.findElement(By.id("pass")).sendKeys(arg2);
      driver.findElement(By.id("u_0_v")).click(); 
   } 
	
   @Then("^login should be unsuccessful$") 
   public void validateRelogin() { 
      if(driver.getCurrentUrl().equalsIgnoreCase(
         "https://www.facebook.com/login.php?login_attempt=1&lwv=110")){ 
            System.out.println("Test Pass"); 
      } else { 
         System.out.println("Test Failed"); 
      } 
      driver.close(); 
   } 
}

注意– 在代码中，我们必须定义一个具有两个输入参数的函数：一个用户名，另一个用于密码。因此，对于示例标签中提供的每组输入，将执行一组 GIVEN、WHEN 和 THEN。

第 5 步– 创建一个跑步者类文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 为文件命名，例如runTest.java

• 在文件中写入以下文本并保存。

package Outline; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 

public class runTest { }

• 打开命令提示符。

• 转到此包“commandLine”所在的目录。e:\Workspace\LoginTest\src>cd test\java

• 运行命令 mvn test：您将看到功能文件中描述的所有场景都已执行（如果没有任何错误）。最后，您会在底部找到以下信息。

结果

This describes the total test run, along with failure if any.

前面的命令运行 JUnit Runner 类中提到的所有内容。但是，如果我们想覆盖 Runner 中提到的配置，以下是一些示例。

• 现在在命令提示符下运行命令 mvn test – Dcucumber.options=”–help”。运行这将打印所有可用的选项。

• 要仅运行特定标签，请在命令提示符下运行命令 mvn test -Dcucumber.options=”–tags @SmokeTest”。它将只运行标记为@SmokeTest 的标签。

• 为了改变结果的格式，在命令提示符下运行命令 E:\Workspace\LoginTest>mvn test -Dcucumber.options=”–plugin junit:target/cucumber-junit-report.xml” 它改变了报告格式为 JUnit 报告生成器。

黄瓜 – JUnit Runner

在我们开始讨论 Cucumber JUnit Runner 之前，了解 Junit 是什么很重要。JUnit是 Java 编程语言的开源单元测试框架。JUnit 在测试驱动开发的发展中一直很重要，是单元测试框架家族中的一员，它统称为 xUnit，起源于 SUnit。

使用 JUnit 的好处

• Unit 具有图形用户界面(GUI)，可以快速轻松地编写和测试源代码。

• JUnit 允许开发人员逐步构建测试套件以衡量进度并检测意外的副作用。

• 测试可以连续运行。

• JUnit 在通常为绿色但在测试失败时变为红色的栏中显示测试进度。

到目前为止，我们已经看到了使用 JUnit 的好处，但我们现在讨论它的原因是 Cucumber 框架。一方面，Cucumber 为非技术人员提供了一种为产品定义测试用例的方法，另一方面，我们期望这些测试用例能够顺利、及时地执行。

JUnit 充当了这两者之间的桥梁。因此，执行流程如下所示 –

• 利益相关者写下特征文件。

• 将相应地创建步骤定义文件。

• 指定 JUnit 运行器类来运行一系列测试用例。

• 一旦我们运行 JUnit runner 类 –

  • 它将解析 Gherkin 特征文件。

  • 它将根据特征文件语句执行步骤定义文件中编写的函数。

  • JUnit 将合并测试用例结果。

  • 它将以指定的格式（可以是 html/JSON）构建测试报告。

这里的重点是如何配置 JUnit 来完成所有这些事情？以下是步骤 –

步骤 1 – 安装 Java。

• 从链接http://www.oracle.com/technetwork/java/javase/downloads/index.html下载 jdk 和 jre

• 接受许可协议。

• 安装 JDK 和 JRE。

• 设置环境变量，如下面的屏幕截图所示。

步骤 2 – 安装 Eclipse。

• 为什么我们需要– Eclipse 是一个集成开发环境（IDE）。它包含一个基础工作区和一个用于自定义环境的可扩展插件系统。

• 如何安装–

  • 确保您的机器上安装了 JAVA。

  • 从http://www.eclipse.org/downloads下载 Eclipse

  • 解压并安装 Eclipse。

第 3 步– 安装 Maven。

• 为什么我们需要– Maven 是一个主要用于 Java 项目的构建自动化工具。它提供了一个通用平台来执行诸如生成源代码、编译代码、将代码打包到 jar 等活动。此外，如果任何软件版本发生更改，Maven 提供了一种简单的方法来相应地修改测试项目。

• 如何安装–

  • 下载 Maven – https://maven.apache.org/download.cgi

  • 解压缩文件并记住位置。

  • 创建环境变量 MAVEN_HOME，如下面的屏幕截图所示。

• 编辑 Path 变量并包含 Maven，如下面的屏幕截图所示。

• 从 Eclipse 下载 MAVEN 插件。

  • 打开日食。

  • 获得帮助 → Eclipse Marketplace → 搜索 maven → Eclipse 的 Maven 集成 → 安装。

第 4 步– 如何使用 Maven 配置 Cucumber

• 在 Eclipse 中创建一个 Maven 项目。

  • 转到文件 → 新建 → 其他 → Maven → Maven 项目 → 下一步。

  • 提供组 ID（组 ID 将在所有项目中唯一标识您的项目）。

  • 提供 artifact Id（artifact Id 是没有版本的 jar 的名称。您可以选择任何小写的名称）。

  • 单击完成。

• 打开 pom.xml

  • 转到 Eclipse 左侧的包资源管理器。

  • 展开 CucumberTest 项目。

  • 找到 pom.xml 文件。

  • 右键单击并选择选项，使用“文本编辑器”打开。

• 为 Selenium 添加依赖项 – 这将指示 Maven，哪些 Selenium jar 文件将从中央存储库下载到本地存储库。

  • 在编辑模式下打开 pom.xml，在项目标签内创建依赖标签（<dependencies></dependencies>）。

  • 在依赖项标签内，创建依赖项标签。(<dependency></dependency>)。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

• 为 Cucumber-Java 添加依赖项 – 这将指示 Maven，哪些 Cucumber 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

• 为 Cucumber-JUnit 添加依赖项：这将指示 Maven，哪些 Cucumber JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

• 为 JUnit 添加依赖项 – 这将指示 Maven，哪些 JUnit 文件将从中央存储库下载到本地存储库。

  • 再创建一个依赖标签。

  • 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

• 验证二进制文件

  • 一旦pom.xml中成功地编辑，保存它。

  • 转到项目→清洁 – 这将需要几分钟。

  • 之后，您将能够看到如下图所示的 Maven 存储库。

步骤 5 – 创建特征文件（稍后介绍）。

步骤 6 – 创建步骤定义文件（稍后介绍）。

Step 7 – 创建 Junit runner 来运行测试（稍后会介绍）。

黄瓜 – 报告

我们进行测试执行是为了了解产品的稳定性，因此无论是手动测试还是自动化测试，生成能够描述产品稳定性的简明报告是非常重要的。因此，当我们使用 Cucumber 自动化我们的测试场景时，有必要知道如何更好地生成我们的 Cucumber 测试报告。正如我们所知，Cucumber 是一个 BDD 框架，它没有花哨的报告机制。

为了实现这一点，我们需要将 Cucumber 与 Ant/Junit 等其他开源工具集成。在这里，我们将进一步举例说明 JUnit，因为它提供对 Java 语言的支持。

让我们来看看不同报告格式的详细信息，这些报告格式可用且易于使用 –

漂亮的格式（HTML 报告）

Pretty Format 生成 HTML 格式的 Cucumber 测试报告，即一个 HTML 文件。它是最易读的报告格式。它以与生成特征文件相同的方式生成报告，因此跟踪也变得容易。此外，您可以指定您希望在测试执行后放置此报告的位置。它可以是 –

• 本地目录– 我们可以将报告的目标目录指定为运行测试的机器的任何本地目录。

• 服务器目录– 我们还提供了将目标目录指定为服务器上可公开访问的任何目录的规定。当我们希望我们的客户/利益相关者在任何给定时间点查看测试结果时，这通常会有所帮助。

例子

让我们自动化一个漂亮格式的例子。

第 1 步–在 Eclipse 中创建一个名为CucumberReport的 Maven 项目。

第 2 步–在src/test/java下创建一个名为CucumberReport的包

Step 3 – 创建一个名为cucumberReport.feature的特征文件

在文件中写入以下文本并保存。

功能– 黄瓜报告

#这是检查Pass测试用例的测试结果

场景：存在登录功能

鉴于我已经打开浏览器

当我打开 Facebook 网站时

然后登录按钮应该存在

#这是为了检查失败的测试用例的测试结果

场景：忘记密码存在

鉴于我已经打开浏览器

当我打开 Facebook 网站时

那么忘记密码链接应该存在

注意– 此处第一个场景将通过，而第二个场景将失败。这样我们就可以见证通过和失败报告的样子。

步骤 4 – 创建一个步骤定义文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 将文件名指定为cucumberReport.java

• 在文件中写入以下文本并保存。

package CucumberReport; 

import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class cucumberReport { 
   WebDriver driver = null;
	
   @Given("^I have open the browser$") 
   public void openBrowser() { 
      driver = new FirefoxDriver();
   } 
	
   @When("^I open Facebook website$") 
   public void goToFacebook() { 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
	
   @Then("^Login button should exits$") 
   public void loginButton() { 
      if(driver.findElement(By.id("u_0_v")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else { 
         System.out.println("Test 1 Fail");
      }
   } 
	
   @Then("^Forgot password link should exist$") 
   public void forgotPWD() { 
      if(driver.findElement(By.id("")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else {
         System.out.println("Test 1 Fail");
      } 
   } 
}

第 5 步– 创建一个跑步者类文件。

• 在包中创建一个名为runTest.java 的运行器类。

• 编写以下代码。保存文件。

package CucumberReport; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options( 
   format = {"pretty", "html:target/Destination"} ) 
//Specifying pretty as a format option ensure that HTML report will be generated. 
//When we specify html:target/Destination - It will generate the HTML report 

inside the Destination folder, in the target folder of the maven project.
 
public class runTest { }

• 使用选项运行测试

  • 从包资源管理器中选择runTest.java文件。

  • 右键单击并选择选项Run as。

  • 选择 JUnit 测试。

运行该类文件时，您将观察到以下情况。

这两个场景都将一一执行。

将在目标目录中创建一个名为 Destination 的文件夹。

该报告将在那里命名为“Index.html”。

使用网络浏览器打开 Index.html。

您将看到下图中提到的报告 –

它准确地突出了失败场景的颜色。此外，您将在该场景中看到失败步骤的突出显示。这使得调试非常容易。

JSON 报告

到目前为止，我们已经看到 HTML 报告是多么简单。但是，如果我们想将此报告信息传递给任何其他应用程序，在 HTML 报告的情况下这有点棘手。这就需要另一种报告格式。JSON-Java 脚本对象表示法是另一种生成 Cucumber 测试报告的格式。JSON 是一个包含大量以文本格式存储的信息的对象。JSON 报告为表带来了不同的值。JSON 报告还可以用作要在不同服务器之间传输的信息的有效负载。此外，它可以用于显示为网页。简而言之，其他应用程序可以使用 JSON 报告。

什么是有效载荷信息？当通过 Internet 发送数据时，传输的每个单元都包含标头信息和正在发送的实际数据。标头标识数据包的来源和目的地，而实际数据称为有效载荷。为了生成 JSON 报告，我们只需要在 runner 文件中进行更改。

• 如下更改运行文件中的格式选项。

package CucumberReport; 

import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options( format={"json:target/Destination/cucumber.json"}) 

//When we specify json:target/Destination/cucumber.json - It will generate the JSON  
report inside the Destination folder, in the target folder of the maven project.

public class runTest {}

• 使用选项运行测试 –

  • 从包资源管理器中选择runTest.java文件。

  • 右键单击并选择选项Run as。

  • 选择 JUnit 测试。

• 运行该类文件时，您将观察到以下情况。

  • 这两个场景都将一一执行。

• 该报告将在那里命名为cucumber.json（在runner 类中提供）。

• 使用文本编辑器打开cucumber.json文件。

• 放置换行符后，您将看到以下屏幕截图中提到的报告 –

注意– 与 HTML 报告格式相比，JSON 的可读性较差。

黄瓜 – 调试

由于未知原因，您的测试很可能会失败。找出故障原因并加以纠正非常重要。此过程称为调试。以下是一些提示和技巧，它们使 Cucumber 调试变得容易一些。

调试选项可用于 Eclipse。放置断点。单击文件并使用以下步骤进行调试 –

步骤 1 – 在 Ruby 步骤定义文件中放置手动断点。

例子

require 'ruby-debug' 
Then /^the process should exit cleanly$/ do 
breakpoint 
assert @exited_cleanly, "Process did not exit cleanly: #{@stdout}" 
end

Step 2 – 我们还可以在步骤定义文件中定义一个单独的调试步骤，如下所示。

Then /^I debug$/ do 
breakpoint 
0 
end

第 3 步– Webrat是使用 Rails 进行黄瓜测试的默认工具。它允许您执行诸如单击链接、键入和提交表单等操作。

例如，有时您会尝试单击某物，但它并不存在。你会得到一大堆 HTML 代码，弄清楚这到底意味着什么可能会很麻烦。

save_and_open_page

Webrat 提供了一个方法 save_and_open_page 捕获当前的 HTML，保存它，然后在浏览器中为你打开它。非常有用。

When /^I follow "(.*)"$/ do |link| 
save_and_open_page 
click_link(link) 
end

黄瓜 – Java 测试

要使用 Java 运行 Cucumber 测试，请执行以下步骤。

步骤 1 – 安装 Java –

• 下载 jdk 和 jre 从

  http://www.oracle.com/technetwork/java/javase/downloads/index.html

• 接受许可协议。

• 安装 JDK 和 JRE。

• 设置环境变量，如下图所示。

第 2 步– 安装 Eclipse IDE –

• 确保您的机器上安装了 JAVA。

• 从https://eclipse.org/downloads/下载 Eclipse

• 解压并安装 Eclipse。

第 3 步– 安装 Maven –

• 下载 Maven – https://maven.apache.org/download.cgi

• 解压缩文件并记住位置。

• 创建环境变量 MAVEN_HOME，如下图所示。

• 编辑 Path 变量并包含 Maven。

• 从 Eclipse 下载 MAVEN 插件

  • 打开日食。

  • 得到帮助 → Eclipse Marketplace → 搜索 maven → Eclipse 的 Maven 集成 →安装

第 4 步– 使用 Maven 配置 Cucumber。

• 创建一个 Maven 项目。

  • 转到文件 → 新建 → 其他 → Maven → Maven 项目 → 下一步。

  • 提供组 ID（组 ID 将在所有项目中唯一标识您的项目）。

  • 提供 artifact Id（artifact Id 是没有版本的 jar 的名称。您可以选择任何小写的名称）。

  • 单击完成。

第 5 步– 打开 pom.xml –

• 转到 Eclipse 左侧的包浏览器。

• 展开 CucumberTest 项目。

• 找到 pom.xml 文件。

• 右键单击并选择选项，使用“文本编辑器”打开。

第 6 步– 添加 Selenium 的依赖项 – 这将指示 Maven，哪些 Selenium jar 文件将从中央存储库下载到本地存储库。

• 在编辑模式下打开 pom.xml，在项目标签内创建依赖标签（<dependencies></dependencies>）。

• 在依赖项标签内，创建依赖项标签。(<依赖></依赖>)

• 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>org.seleniumhq.selenium</groupId> 
   <artifactId>selenium-java</artifactId> 
   <version>2.47.1</version> 
</dependency>

第 7 步– 添加 Cucumber-Java 的依赖项 – 这将指示 Maven，哪些 Cucumber 文件将从中央存储库下载到本地存储库。

• 再创建一个依赖标签。

• 在依赖项标签内提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-java</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

第 8 步– 为 Cucumber-JUnit 添加依赖项 – 这将指示 Maven，哪些 Cucumber JUnit 文件将从中央存储库下载到本地存储库。

• 再创建一个依赖标签。

• 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>info.cukes</groupId> 
   <artifactId>cucumber-junit</artifactId> 
   <version>1.0.2</version> 
   <scope>test</scope> 
</dependency>

第 9 步– 为 JUnit 添加依赖项 – 这将指示 Maven，哪些 JUnit 文件将从中央存储库下载到本地存储库。

• 再创建一个依赖标签。

• 在依赖项标记中提供以下信息。

<dependency> 
   <groupId>junit</groupId> 
   <artifactId>junit</artifactId> 
   <version>4.10</version> 
   <scope>test</scope> 
</dependency>

步骤 10 – 验证二进制文件。

• pom.xml 编辑成功后，保存。

• 转到项目→清洁 – 这将需要几分钟。

• 您将能够看到 Maven 存储库。

第 11 步– 在src/test/java下创建一个包，命名为CucumberJava。

步骤 12 – 创建特征文件

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 给文件起一个名字，比如cucumberJava.feature。

• 在文件中写入以下文本并保存。

  功能： CucumberJava

  场景：存在登录功能

  鉴于我已经打开浏览器

  当我打开 Facebook 网站时

  然后登录按钮应该退出

步骤 13 – 创建步骤定义文件 –

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 为文件名指定一个名称，例如annotation.java。

• 在文件中写入以下文本并保存。

package CucumberJava; 
import org.openqa.selenium.By; 
import org.openqa.selenium.WebDriver; 
import org.openqa.selenium.firefox.FirefoxDriver; 

import cucumber.annotation.en.Given; 
import cucumber.annotation.en.Then; 
import cucumber.annotation.en.When; 

public class cucumberJava { 
   WebDriver driver = null; 
   @Given("^I have open the browser$") 
   public void openBrowser() { 
      driver = new FirefoxDriver(); 
   } 
   @When("^I open Facebook website$") 
   public void goToFacebook() { 
      driver.navigate().to("https://www.facebook.com/"); 
   } 
   @Then("^Login button should exits$") 
   public void loginButton() { 
      if(driver.findElement(By.id("u_0_v")).isEnabled()) { 
         System.out.println("Test 1 Pass"); 
      } else { 
         System.out.println("Test 1 Fail"); 
      } 
      driver.close(); 
   } 
}

步骤 14 – 创建一个跑步者类文件。

• 选择并右键单击包轮廓。

• 单击“新建”文件。

• 将文件名指定为runTest.java。

• 在文件中写入以下文本并保存。

package cucumberJava; 
import org.junit.runner.RunWith; 
import cucumber.junit.Cucumber; 

@RunWith(Cucumber.class) 
@Cucumber.Options(format = {"pretty", "html:target/cucumber"}) 
public class runTest { 
}

步骤 15 – 使用选项运行测试 –

• 从包资源管理器中选择 runTest.java 文件。

• 右键单击并选择选项Run as。

• 选择 JUnit 测试。

您将在执行时观察以下事项 –

• 将打开一个 Firefox Web 浏览器实例。

• 它将在浏览器上打开 Facebook 登录页面。

• 它将检测登录按钮。

• 浏览器将关闭。

• 在 JUnit 窗口中，您将看到一个带有绿色勾号的场景，这表示测试执行成功。

黄瓜 – Ruby 测试

Ruby 语言具有以下优点 –

• 这很容易理解。

• 它是一种面向对象的语言。

• 它是一个强大的类库。

• 它有大量的在线支持。

以下是 Cucumber 如何与 Ruby 一起工作的分步过程。

步骤 1 – 安装 Ruby。

• 转到 RubyInstaller 下载页面。

• 下载最适合您的操作系统的版本（即 32 位或 64 位）。

• 运行下载的exe。

• 在安装过程中，勾选“Add Ruby…”和“Associate…”选项，如下图所示。

第 2 步– 下载并提取开发工具包。

• 转到 RubyInstaller 下载页面。

• 下载最适合您的操作系统（即 32 或 64 位）的 Devkit 版本。

• 在 c:\Ruby\Devkit 文件夹中提取 devkit。

• 打开命令提示符。

• 在 Ruby devkit 中，运行以下命令。

C:\Ruby\devkit> ruby dk.rb init 
C:\Ruby\devkit> ruby dk.rb install

第 3 步– 安装 Cucumber 和其他 Ruby gem。

• 要安装 Cucumber，首先更新当前的 gem 设置

C:\Users\Admin> gem update –system

• 接下来，安装 Cucumber Web 测试所需的 gem。

C:\Users\Admin> gem install --no-ri --no-rdoc rspec 
C:\Users\Admin> gem install --no-ri --no-rdoc win32console 
C:\Users\Admin> gem install --no-ri --no-rdoc watir-webdriver 
C:\Users\Admin> gem install --no-ri --no-rdoc cucumber

• 运行黄瓜

C:\Users\Admin\Documents>cucumber –init 
C:\Users\Admin\Documents>cucumber

第 4 步– 安装 IDE – KMODO。

• 转到页面http://www.activestate.com/komodo-ide/downloads

• 下载免费试用安装程序。

• 双击下载的 exe。

• 按照安装步骤操作。

• 完成安装并打开IDE。

第 5 步– 安装Watir – 转到命令提示符并运行以下命令，“gem install watir”

第 6 步– 安装rspec – 转到命令提示符并运行以下命令，“gem install rspec”

步骤 7 – 创建特征文件。

• 打开科莫多编辑器。

• 单击新文件图标。

• 写出下面的文字。

  功能：用户必须能够使用 Google 搜索内容。

  场景：搜索一个词。

  鉴于我在查询中输入了“watir”。

  当我点击“搜索”

  然后我应该看到一些结果

• 单击保存图标。

• 将名称命名为 CucumberRuby.feature。

• 选择任意文件夹，例如：“e:\WithRuby”

• 保存文件。

步骤 8 – 创建步骤定义文件。

• 打开科莫多编辑器。

• 单击“新建”文件图标。

• 编写以下代码。

require "watir-webdriver" 
require "rspec/expectations" 

Given /^I have entered "([^"]*)" into the query$/ do |term| 
@browser ||= Watir::Browser.new :firefox 
@browser.goto "google.com" 
@browser.text_field(:name => "q").set term 
end 

When /^I click "([^"]*)"$/ do |button_name| 
@browser.button.click 
end 

Then /^I should see some results$/ do 
@browser.div(:id => "resultStats").wait_until_present 
@browser.div(:id => "resultStats").should exist 
@browser.close 
End

• 单击保存图标。

• 命名为CucumberRuby.rb

• 选择任何文件夹，例如：“e:\WithRuby”

• 保存文件。

步骤 9 – 创建测试文件。

• 打开科莫多编辑器。

• 单击“新建”文件图标。

• 编写以下代码。

require "rubygems" 
require "test/unit" 
require "watir-webdriver" 

class GoogleSearch < Test::Unit::TestCase 
def setup 
@browser ||= Watir::Browser.new :firefox 
end 

def teardown 
@browser.close 
end 

def test_search 
@browser.goto "google.com" 
@browser.text_field(:name => "q").set "watir" 
@browser.button.click 
@browser.div(:id => "resultStats").wait_until_present assert 
@browser.title == "watir - Google Search" 
end 
end

• 单击保存图标。

• 将文件命名为test.rb并选择任何文件夹，例如：“e:\WithRuby”

• 保存文件。

步骤 10 – 运行功能文件。

• 转到命令提示符。

• 转到目录e:\WithRuby

• 运行以下命令。

e:\With Ruby>ruby test.rb

您将在执行时观察以下事项 –

• 将打开一个 Web 浏览器实例。

• Google.com 网页将被加载。

• 将输入搜索文本watir。

• 将放置搜索按钮。

• 搜索结果应显示在网页上。

• 浏览器实例将被关闭。