Cucumber 快速指南

上一页
下一页

Cucumber - 概述

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

行为驱动开发使我们有机会从开发人员和客户的角度创建测试脚本。因此，在一开始，开发人员、项目经理、质量保证人员、用户验收测试人员和产品负责人（股东）都会聚在一起，集思广益哪些测试场景应该通过才能称这个软件/应用程序为成功。通过这种方式，他们会想出一套测试场景。所有这些测试脚本都使用简单的英语编写，因此它也起到了文档的作用。

示例

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

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

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

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

工作原理

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

BDD

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

那么 Cucumber 做了什么呢？它可以用以下步骤来描述：

Cucumber 读取特性文件（稍后在本教程中介绍）中用纯文本（Gherkin 语言——稍后在本教程中介绍）编写的代码。

它在步骤定义（代码文件——在本教程的后面部分提供详细信息）中找到每个步骤的确切匹配。

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

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

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

  • Ruby on Rails
  • Selenium
  • PicoContainer
  • Spring Framework
  • Watir

Cucumber 相比其他工具的优势

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

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

  • 它允许编写测试脚本而无需任何代码知识，也允许非程序员参与。

  • 它与其他工具不同，它可以作为端到端测试框架。

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

Cucumber - 环境配置

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

环境设置的先决条件

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

Java

为什么我们需要它 - Java 是一种强大的编程语言。Cucumber 支持 Java 平台的执行。

如何安装 -

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

步骤 2 - 接受许可协议。

步骤 3 - 安装 JDK 和 JRE。

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

System Properties

Edit System Variable

Eclipse

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

如何安装 -

步骤 1 - 确保你的机器上已安装 JAVA。

步骤 2 - 从 https://eclipse.org/downloads/ 下载 Eclipse

步骤 3 - 解压缩，Eclipse 就安装好了。

Maven

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

如何安装 -

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

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

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

System Variables

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

Edit Path Variable

步骤 5 - 从 Eclipse 下载 MAVEN 插件。

步骤 6 - 打开 Eclipse。

步骤 7 - 转到 Help → Eclipse Marketplace → 搜索 Maven → Maven Integration for Eclipse → INSTALL。

使用 Maven 配置 Cucumber

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

  • 转到 File → New → Others → Maven → Maven Project → Next。

  • 提供 group Id（group Id 将唯一标识你的项目在所有项目中）。

  • 提供 artifact Id（artifact Id 是 jar 的名称，不包含版本号。你可以选择任何小写名称）。点击 Finish。

New Maven Project

步骤 2 - 打开 pom.xml。

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

  • 展开项目CucumberTest。

  • 找到pom.xml文件。

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

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

  • 打开pom.xml处于编辑模式，在 project 标签内创建 dependencies 标签（<dependencies></dependencies>）。

  • 在 dependencies 标签内，创建 dependency 标签（<dependency></dependency>）。

  • 在 dependency 标签内提供以下信息。

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

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

  • 创建另一个 dependency 标签。

  • 在 dependency 标签内提供以下信息

<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 标签。

  • 在 dependency 标签内提供以下信息

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

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

  • 创建另一个 dependency 标签。

  • 在 dependency 标签内提供以下信息。

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

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

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

  • 转到 Project → Clean - 这需要几分钟。

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

Package Explorer

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

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

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

Cucumber - Gherkin 语法

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

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

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

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

示例

特性 - 社交网站的登录功能。给定 我是一个社交网站用户。当 我输入用户名为 username1。并且 我输入密码为 password1。那么 我应该被重定向到网站的首页。

上述场景是名为用户登录的特性。所有用粗体突出显示的词都是 Gherkin 关键字。

其他一些关键字的示例：

  • 背景 (Background)
  • 但是 (But)
  • *
  • 场景大纲 (Scenario Outline)
  • 示例 (Examples)

Gherkin 将解析步骤定义文件（稍后介绍）中编写的每个步骤。因此，特性文件中提到的步骤和步骤定义文件（稍后介绍）中的步骤应该匹配。

你可以在包资源管理器的 Maven 依赖项文件夹中找到 Gherkin jar 文件。它与其他 Cucumber jar 文件一起下载。它看起来如下面的屏幕截图所示：

Gherkin Jars

Gherkin 的另一个有趣之处在于，它不仅支持英语，还支持许多其他本地语言，例如法语、芬兰语、印尼语、匈牙利语、印地语、乌尔都语、古吉拉特语等。

Cucumber - 特性 (Features)

特性 (Feature) 可以定义为项目的独立单元或功能。让我们以社交网站这个非常常见的例子为例。这个产品/项目的特性是什么样的？一些基本特性可以确定为：

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

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

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

  • 发送好友请求。

  • 注销。

现在可以清楚地看到，在谈论 Cucumber 时，被测产品的每个独立功能都可以称为一个特性。最佳实践是在开始测试之前，确定要测试的特性。

一个特性通常包含一个该特性要测试的场景列表。我们存储特性、特性描述和要测试的场景的文件被称为特性文件 (Feature File)。我们将在下一章中详细了解特性文件。

在 Gherkin 中表示被测特性的关键字是“Feature”。建议的最佳实践是在特性文件中的特性标题下写一个简短的特性描述。这也有利于良好的文档记录。

示例

特性 (Feature) - 社交网站登录功能。

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

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

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

特性文件 (Feature Files)

编写 Cucumber 测试的文件被称为特性文件 (feature files)。建议每个被测特性都应该有一个单独的特性文件。特性文件的扩展名需要是“.feature”。

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

例如：

序号 特性 (Feature) 特性文件名 (Feature File name)
1 用户登录 (User Login) userLogin.feature
2 分享帖子 (Share the Post) sharePost.feature
3 创建账户 (Create Account) createAccount.feature
4 删除账户 (Delete Account) deleteAccount.feature

特性名称和特性文件名的命名约定取决于个人的选择。Cucumber 对名称没有硬性规定。

一个简单的特性文件包含以下关键字/部分：

  • 特性 (Feature) - 被测特性的名称。

  • 描述 (Description) (可选) - 对被测特性的描述。

  • 场景 (Scenario) - 测试场景是什么。

  • 前提 (Given) - 测试步骤执行之前的先决条件。

  • 当 (When) - 为了执行下一步而应该匹配的特定条件。

  • 那么 (Then) - 如果 WHEN 中提到的条件满足，将会发生什么。

示例

特性 (Feature) - 社交网站用户登录。

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

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

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

概要 (Outline) - 社交网站的登录功能。

给定用户导航到 Facebook。当我输入用户名为“<username>”和密码为“<password>”时。然后，登录应该失败。

| username  | password  |
| username1 | password1 |

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

特性文件中没有编写逻辑细节。

步骤定义 (Steps Definitions)

我们已经准备好包含已定义测试场景的特性文件。但是，这还不是全部工作。Cucumber 实际上并不知道要为特性文件中概述的任何特定场景执行哪一部分代码。

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

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

步骤定义文件示例 (Example of Step Definition File)

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）执行什么代码，你都可以在步骤定义文件中编写它。确保为每个步骤都定义了代码/函数。

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

Cucumber - 场景 (Scenarios)

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

场景 (Scenario) - 验证帮助功能。

给定用户导航到 Facebook。

当用户点击帮助时，帮助页面打开。

考虑一个需要多次执行测试场景的情况。假设，我们需要确保登录功能对所有类型的订阅者都有效。这需要多次执行登录功能场景。为了仅仅重新执行代码而复制粘贴相同的步骤，似乎不是一个好主意。为此，Gherkin 提供了另一种结构，即场景概要 (scenario outline)。

场景概要与场景结构类似；唯一的区别是提供了多个输入。正如你在下面的例子中看到的，测试用例保持不变且不可重复。在底部，我们为变量“用户名”和“密码”提供了多个输入值。在运行实际测试时，Cucumber 将用提供的输入值替换变量，然后执行测试。第一次通过后，测试将使用另一个输入值重新运行第二次迭代。在使用 Gherkin 语句时，可以使用“<>”来表示此类变量或占位符。

示例

场景概要 (Scenario Outline) - 社交网站登录功能。给定用户导航到 Facebook。

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

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

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

  • 每个步骤都应该清晰定义，以免给读者造成混淆。

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

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

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

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

Cucumber - 注解 (Annotations)

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

  • 前提 (Given) -

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

    • 示例 - GIVEN 我是 Facebook 用户

  • 当 (When) -

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

    • 示例 - WHEN 我输入“<username>”

  • 那么 (Then) -

    • Then 包含要执行的测试的预期结果。

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

  • 并且 (And) -

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

    • 示例 - WHEN 我输入我的“<username>” AND 我输入我的“<password>”

  • 但是 (But) -

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

    • 示例 - THEN 登录应该成功。BUT 主页不应丢失。

  • 场景 (Scenario) -

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

    • 示例：

      场景 (Scenario)

      GIVEN 我是 Facebook 用户

      WHEN 我输入我的

      AND 我输入我的

      THEN 登录应该成功。

      BUT 主页不应丢失。

  • 场景概要 (Scenario Outline) - （稍后介绍）

  • 示例 (Examples) - （稍后介绍）

  • 背景 (Background) -

    • 背景通常包含每个场景运行之前的设置说明。但是，它在“Before”钩子之后执行（稍后介绍）。因此，当我们想要设置 web 浏览器或建立数据库连接时，这非常适合用于代码。

      • 示例：

        背景 (Background)

        转到 Facebook 首页。

场景示例 (Example Scenario)

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

步骤 1

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

  • 转到 File → New → Others → Maven → Maven Project → Next。

  • 提供 group Id（group Id 将唯一标识你的项目在所有项目中）。

  • 提供构件 ID（构件 ID 是不带版本的 jar 文件的名称。你可以选择任何小写的名称）。

  • 点击完成。

  • 打开pom.xml -

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

    • 展开项目 AnnotationTest。

    • 找到 pom.xml 文件。

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

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

    • 打开 pom.xml 并处于编辑模式，在 project 标签内创建 dependencies 标签（<dependencies></dependencies>）。

    • 在 dependencies 标签内，创建 dependency 标签（<dependency></dependency>）。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

  • 验证二进制文件。

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

    • 转到 Project → Clean - 这需要几分钟。

步骤 2

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

  • 选择新创建的项目。

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

  • 选择“包”选项。

  • 将其命名为“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

步骤 4

创建一个步骤定义文件。

  • 选择包概要，然后右键单击。

  • 单击“新建”文件。

  • 将文件名命名为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 Web浏览器实例中打开。

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

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

  • 将单击登录。

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

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

  • 步骤结果1到5. 将针对用户名为空字符串和密码为空字符串重新执行。

Cucumber - 场景大纲 (Scenario Outline)

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

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

场景 (Scenario)

给定用户导航到Facebook

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

则登录应成功

场景 (Scenario)

给定用户导航到Facebook

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

则登录应成功

场景 (Scenario)

给定用户导航到Facebook

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

则登录应成功

在这里，如果我们仔细观察，对于上述三个场景：语句相同，只有输入参数（用户名/电子邮件地址/电话号码）在变化。这就是场景大纲的重要性所在。

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

示例

让我们创建一个场景大纲示例：

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

  • 转到 File → New → Others → Maven → Maven Project → Next。

  • 提供 group Id（group Id 将唯一标识你的项目在所有项目中）。

  • 提供构件 ID（构件 ID 是不带版本的 jar 文件的名称。你可以选择任何小写的名称）。

  • 点击完成。

  • 打开pom.xml -

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

    • 展开项目CucumberTest。

    • 找到 pom.xml 文件。

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

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

    • 打开 pom.xml 并处于编辑模式，在 project 标签内创建 dependencies 标签（<dependencies></dependencies>）。

    • 在 dependencies 标签内，创建 dependency 标签（<dependency></dependency>）。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

  • 验证二进制文件。

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

    • 转到 Project → Clean - 这需要几分钟。

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

Java Package

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

  • 选择包概要，然后右键单击。

  • 单击“新建”文件。

  • 将文件名命名为“outline.feature”

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

      功能 - 场景大纲

      场景大纲 - 社交网站的登录功能。

      给定用户导航到Facebook

      当我输入用户名为"<username>"和密码为"<password>"时

      则登录应失败

示例 -

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

注意 - 在这里，example注解描述了场景执行时要提供的输入范围。测试场景将针对提供的每个输入执行。因此，在给定的示例中，测试场景将执行三次。

步骤 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(); 
   }    
}

注意 - 在上面的代码中，我们必须定义一个具有两个输入参数的函数：一个用于用户名，另一个用于密码。因此，对于在example标签中提供的每一组输入，将执行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文件。

    • 右键单击并选择“以...运行”选项。

    • 选择JUnit测试。

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

  • Facebook将在新的Firefox Web浏览器实例中打开。

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

  • 将单击登录。

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

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

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

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

Cucumber - 标签 (Tags)

当特征文件中只有一个、两个或五个场景时，它看起来很简单。然而，在现实生活中并非如此。对于每个被测功能，我们可能在一个特征文件中拥有10、20甚至更多数量的场景。它们可能代表不同的目的（冒烟测试/回归测试）、不同的视角（开发人员/测试人员/业务分析师）、不同的状态（准备执行/进行中）等等。如何管理如此大量的执行？

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

假设特征文件中存在两个或多个场景。我们只想执行一个场景作为冒烟测试的一部分。所以首先要识别该场景，其次是在场景开头用“@SmokeTest”文本标记它。让我们仔细研究一下：

步骤 1 - 创建一个名为cucumberTag的Maven项目。

步骤 2 - 在src/test/java下创建一个名为cucumberTag的包

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

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

功能 - 黄瓜标签

场景大纲 - 社交网站的登录功能。

给定用户导航到Facebook

当我输入用户名为"<username>"和密码为"<password>"时

则登录应失败

示例 (Examples)

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

#以下场景已标记为SmokeTest，并且应该执行。@SmokeTest

场景 (Scenario)

给定用户导航到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 { }

  • 运行测试选项。

  • 右键单击并选择“以...运行”选项。

  • 选择JUnit测试。

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

  • Facebook将在新的Firefox Web浏览器实例中打开。

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

  • 将单击登录。

  • 将加载登录重试页面。

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

主要有两种类型的标签：

  • 默认标签 - 默认标签具有预定义的含义。例如@Dev,@Ignore

  • 自定义标签 - 自定义标签为您提供了完全的灵活性，可以选择合适的文本来定义您的标签。

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

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

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

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

在定义多个标签时，我们还可以定义逻辑或/和逻辑与运算。

  • 在运行器类中定义逻辑或 - @dev,@wip - 这表示需要执行与任何这些标签匹配的场景。

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

Cucumber - 数据表 (Data Tables)

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

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

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

功能 - 新用户注册。

验证在传递不正确的输入后，新用户注册是否失败。

给定我位于新用户注册页面。

当我输入用户名和电子邮件地址为电子邮件地址，密码为，并再次输入密码为，出生日期为，性别为，电话号码为时，则用户注册应失败。

乍一看有点混乱。那么，有没有更好的方法来管理这些输入块？答案可能是“数据表”。数据表是一组要为单个标签提供的输入。此标签可以是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测试项目。

  • 转到 File → New → Others → Maven → Maven Project → Next。

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

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

  • 点击完成。

  • 打开pom.xml -

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

    • 展开项目CucumberTest。

    • 找到 pom.xml 文件。

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

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

    • 打开 pom.xml 并处于编辑模式，在 project 标签内创建 dependencies 标签（<dependencies></dependencies>）。

    • 在dependencies标签内，创建dependency标签。（<dependency></dependency>）。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息

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

  • 验证二进制文件。

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

    • 转到 Project → Clean - 这需要几分钟。

步骤 2 - 在src/test/java下创建一个名为dataTable的包

步骤 3 - 创建一个特征文件。

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

  • 编写以下文本。

    功能 - 数据表

    验证在传递不正确的输入后，新用户注册是否失败。

    场景 (Scenario)

    给定我位于新用户注册页面

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

| 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文件。

    • 右键单击并选择“以...运行”选项。

    • 选择JUnit测试。

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

  • Facebook 网站加载。

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

  • 单击提交按钮。

  • 我们将看到主页未显示，并且控制台会输出“Test Pass”。

Cucumber - 注释 (Comments)

注释 基本上是一段用于文档目的而非执行的代码。无论是步骤定义文件还是功能文件，为了使其更易读和易懂，因此在文件中适当的位置使用/添加注释非常重要。这也有助于调试代码。Cucumber 功能文件可以在任何位置添加注释。要添加注释，只需在语句前面加上“#”号即可。

不同的编程语言对定义注释有不同的规范。让我们看看 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

Cucumber 的钩子(hook) 允许我们更好地管理代码工作流，并帮助我们减少代码冗余。我们可以说它是一个隐藏的步骤，它允许我们执行我们的场景或测试。

为了更好地理解这个概念，让我们来看一个功能文件和步骤定义文件的例子。

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

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

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

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

让我们自动化一个 before 和 after 钩子的示例。

步骤 1 - 创建一个名为 hookTest 的 Maven 项目，在 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>"时

则登录应失败

示例 (Examples)

| username  | password  | 
| username1 | password1 |

步骤 5 - 创建一个运行器类文件。

  • 在 dataTable 包内创建运行器类 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文件。

    • 右键单击并选择“以...运行”选项。

    • 选择JUnit测试。

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

  • Before 钩子 - 设置 webdriver 和运行测试的其他先决条件。

  • Given 语句

  • When 语句

  • Then 语句

  • After 钩子 - 关闭 webdriver 并执行清理过程。

带标签的钩子

我们还可以指示是否只想用特定标签执行 before 和 after 钩子。示例 - @Before('@Web')。标签逻辑与/或的概念也可以应用于钩子。示例 - @Before(@dev,@wip), @Before(@dev,~@wip)

Cucumber - 命令行选项

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

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

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

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

  • 转到 File → New → Others → Maven → Maven Project → Next。

  • 提供 group Id（group Id 将唯一标识你的项目在所有项目中）。

  • 提供构件 ID（构件 ID 是不带版本的 jar 文件的名称。你可以选择任何小写的名称）。

  • 点击完成。

  • 打开pom.xml -

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

    • 展开项目CucumberTest。

    • 找到pom.xml文件。

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

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

    • 打开 pom.xml 并处于编辑模式，在 project 标签内创建 dependencies 标签（<dependencies></dependencies>）。

    • 在dependencies标签内，创建dependency标签。（<dependency></dependency>）。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    功能 - 场景大纲

    场景大纲 - 社交网站的登录功能。

    假设用户导航到 Facebook

    当我输入用户名为"<username>"和密码为"<password>"时

    则登录应失败

示例 (Examples)

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

注意 - 在这里，example注解描述了场景执行时要提供的输入范围。测试场景将针对提供的每个输入执行。因此，在给定的示例中，测试场景将执行三次。

步骤 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 报告生成器。

Cucumber - JUnit 运行器

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

使用 JUnit 的好处

  • JUnit 具有图形用户界面 (GUI)，使编写和测试源代码变得快速而容易。

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

  • 测试可以连续运行。

  • JUnit 在通常为绿色的条形图中显示测试进度，但当测试失败时会变为红色。

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

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

  • 利益相关者写下功能文件。

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

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

  • 一旦我们运行 JUnit 运行器类 -

    • 它将解析 Gherkin 功能文件。

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

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

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

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

步骤 1 - 安装 Java。

Install Java

步骤 2 - 安装 Eclipse。

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

  • 如何安装 -

步骤 3 - 安装 Maven。

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

  • 如何安装 -

Maven Home

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

Path Variable

  • 从 Eclipse 下载 MAVEN 插件。

    • 打开 Eclipse。

    • 转到帮助 → Eclipse 市场 → 搜索 maven → Eclipse 的 Maven 集成 → 安装。

步骤 4 - 如何使用 Maven 配置 Cucumber

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

    • 转到 File → New → Others → Maven → Maven Project → Next。

    • 提供 group Id（group Id 将唯一标识你的项目在所有项目中）。

    • 提供构件 ID（构件 ID 是不带版本的 jar 文件的名称。你可以选择任何小写的名称）。

    • 点击完成。

  • 打开 pom.xml

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

    • 展开项目CucumberTest。

    • 找到 pom.xml 文件。

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

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

    • 打开 pom.xml 并处于编辑模式，在 project 标签内创建 dependencies 标签（<dependencies></dependencies>）。

    • 在dependencies标签内，创建dependency标签。（<dependency></dependency>）。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

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

    • 创建另一个 dependency 标签。

    • 在 dependency 标签内提供以下信息。

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

  • 验证二进制文件

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

    • 转到 Project → Clean - 这需要几分钟。

    • 之后，你将能够看到如下面的屏幕截图所示的 Maven 存储库。

Maven Repository

步骤 5 - 创建功能文件（稍后介绍）。

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

步骤 7 - 创建 Junit 运行器来运行测试（稍后介绍）。

Cucumber - 报告

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

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

让我们详细了解可用的和易于使用的不同报告格式 -

漂亮格式（HTML 报告）

漂亮格式以 HTML 格式生成 Cucumber 测试报告，即一个 HTML 文件。这是最易读的报告格式。它以与功能文件相同的方式生成报告，因此跟踪也变得容易。此外，您还可以指定要在测试执行后放置此报告的位置。它可以是 -

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

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

示例

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

步骤 1 - 在 Eclipse 中创建一个名为cucumberReport的 Maven 项目。

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

步骤 3 - 创建一个名为cucumberReport.feature的功能文件

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

功能 - Cucumber 报告

#这是为了检查通过测试用例的测试结果

场景：登录功能存在

假设我已经打开了浏览器

当我打开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文件。

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

    • 选择JUnit测试。

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

两个场景将一个接一个地执行。

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

Cucumber Json

报告将命名为“Index.html”。

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

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

Cucumber Report

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

JSON报告

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

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

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

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文件。

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

    • 选择JUnit测试。

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

    • 两个场景将一个接一个地执行。

Folder Name

  • 报告将命名为cucumber.json（如运行器类中提供的那样）。

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

  • 在添加换行符后，您将看到以下屏幕截图中提到的报告 −

Text Editor

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

Cucumber - 调试

您的测试很可能由于未知原因而失败。识别故障原因并进行纠正非常重要。此过程称为调试。以下是一些技巧，可以使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

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

Then /^I debug$/ do 
breakpoint 
0 
end

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

有时您尝试单击某些内容（例如），但它不存在。您将获得一大块HTML回显，而弄清楚这到底意味着什么可能非常困难。

save_and_open_page

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

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

Cucumber - Java 测试

要使用Java运行Cucumber测试，请按照以下步骤操作。

步骤1 − 安装Java −

Environment Variable

步骤2 − 安装Eclipse IDE −

步骤3 − 安装Maven −

Apache Maven

  • 编辑Path变量并包含Maven。

  • 从Eclipse下载MAVEN插件

    • 打开 Eclipse。

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

步骤4 − 使用Maven配置Cucumber。

  • 创建一个Maven项目。

    • 转到 File → New → Others → Maven → Maven Project → Next。

    • 提供 group Id（group Id 将唯一标识你的项目在所有项目中）。

    • 提供构件 ID（构件 ID 是不带版本的 jar 文件的名称。你可以选择任何小写的名称）。

    • 点击完成。

Maven Project

步骤5 − 打开pom.xml −

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

  • 展开项目CucumberTest。

  • 找到 pom.xml 文件。

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

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

  • 打开 pom.xml 并处于编辑模式，在 project 标签内创建 dependencies 标签（<dependencies></dependencies>）。

  • 在dependencies标签内，创建dependency标签。（<dependency></dependency>)

  • 在 dependency 标签内提供以下信息。

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

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

  • 创建另一个 dependency 标签。

  • 在 dependency 标签内提供以下信息。

<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 标签。

  • 在 dependency 标签内提供以下信息。

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

步骤9− 添加JUnit的依赖项 − 这将指示Maven，要从中央存储库下载到本地存储库的JUnit文件。

  • 创建另一个 dependency 标签。

  • 在 dependency 标签内提供以下信息。

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

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

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

  • 转到 Project → Clean - 这需要几分钟。

  • 您将能够看到一个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文件。

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

  • 选择JUnit测试。

执行后，您将观察到以下内容 −

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

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

  • 它将检测登录按钮。

  • 浏览器将关闭。

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

Cucumber - Ruby 测试

Ruby语言具有以下优点 −

  • 易于理解。

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

  • 它是一个强大的类库。

  • 它拥有大量的在线支持。

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

步骤1 − 安装Ruby。

  • 转到RubyInstaller下载页面。

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

  • 运行下载的exe。

  • 在安装过程中，选中“添加Ruby…”和“关联…”选项，如下图所示。

Setup Ruby

步骤2 − 下载并解压Dev kit。

  • 转到RubyInstaller下载页面。

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

  • 将devkit解压到c:\Ruby\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

  • 运行Cucumber

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

步骤4 − 安装IDE – KOMODO。

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

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

步骤7 − 创建功能文件。

  • 打开KOMODO编辑器。

  • 单击新建文件图标。

  • 编写以下文本。

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

    场景：搜索一个术语。

    假设我在查询中输入了“watir”。

    当我单击“搜索”时

    那么我应该看到一些结果

  • 单击保存图标。

  • 将名称命名为CucumberRuby.feature。

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

  • 保存文件。

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

  • 打开KOMODO编辑器。

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

  • 编写以下代码。

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 − 创建测试文件。

  • 打开KOMODO编辑器。

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

  • 编写以下代码。

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。

  • 将放置搜索按钮。

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

  • 浏览器实例将关闭。

打印页面
上一页
下一页
广告