Cucumber 快速指南

---

---

Cucumber - 概述

為了更好地利用軟體測試，如今的組織正在向前邁進一步。他們在開發過程中實施重要的驗收測試場景。這種方法通常被稱為行為驅動開發 (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 - 設定環境變數，如下面的螢幕截圖所示。

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，如下面的螢幕截圖所示。

步驟 4 - 編輯 Path 變數幷包含 Maven，如下面的螢幕截圖所示。

步驟 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。

步驟 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 儲存庫。

• 建立一個特性檔案（稍後介紹）。

• 建立一個步驟定義檔案（稍後介紹）。

• 建立一個 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 的另一個有趣之處在於，它不僅支援英語，還支援許多其他本地語言，例如法語、芬蘭語、印尼語、匈牙利語、印地語、烏爾都語、古吉拉特語等。

Cucumber - 特性 (Features)

特性 (Feature) 可以定義為專案的獨立單元或功能。讓我們以社交網站這個非常常見的例子為例。這個產品/專案的特性是什麼樣的？一些基本特性可以確定為：

• 建立和刪除社交網站的使用者。

• 社交網站的使用者登入功能。

• 在社交網站上分享照片或影片。

• 傳送好友請求。

• 登出。

現在可以清楚地看到，在談論 Cucumber 時，被測產品的每個獨立功能都可以稱為一個特性。最佳實踐是在開始測試之前，確定要測試的特性。

一個特性通常包含一個該特性要測試的場景列表。我們儲存特性、特性描述和要測試的場景的檔案被稱為特性檔案 (Feature File)。我們將在下一章中詳細瞭解特性檔案。

在 Gherkin 中表示被測特性的關鍵字是“Feature”。建議的最佳實踐是在特性檔案中的特性標題下寫一個簡短的特性描述。這也有利於良好的文件記錄。

示例

特性 (Feature) - 社交網站登入功能。

如果使用者名稱和密碼正確，使用者應該能夠登入社交網站。

如果使用者名稱和密碼不正確，則應向用戶顯示錯誤訊息。

如果使用者名稱和密碼正確，使用者應該被導航到主頁。

特性檔案 (Feature Files)

編寫 Cucumber 測試的檔案被稱為特性檔案 (feature files)。建議每個被測特性都應該有一個單獨的特性檔案。特性檔案的副檔名需要是“.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://#/"); 
} 
@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://#/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://#/"); 
   }
	
   @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://#/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://#/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”的包

步驟 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://#/"); 
   } 
	
   @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://#/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://#/"); 
   } 
	
   @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://#/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://#/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          | someone@someone.com |
| Re-enter Email Address | someone@someone.com |
| 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          | someone@someone.com |
| Re-enter Email Address | someone@someone.com |
| 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://#/"); 
   } 
	
   @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://#/")){
         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://#/");
   } 
	
   @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://#/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://#/"); 
   } 
	
   @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://#/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。

• 從連結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。

  • 轉到幫助 → 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 儲存庫。

步驟 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://#/"); 
   } 
	
   @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的資料夾。

報告將命名為“Index.html”。

使用網路瀏覽器開啟Index.html。

您將看到下圖中提到的報告 −

它準確地突出顯示了失敗場景的顏色。此外，您還將看到該場景中失敗步驟的突出顯示。這使得除錯非常容易。

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測試。

• 執行此類檔案時，您將觀察到以下內容。

  • 兩個場景將一個接一個地執行。

• 報告將命名為cucumber.json（如執行器類中提供的那樣）。

• 使用文字編輯器開啟cucumber.json檔案。

• 在新增換行符後，您將看到以下螢幕截圖中提到的報告 −

注意 − 與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 −

• 從以下地址下載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。

  • 轉到幫助→Eclipse Marketplace→搜尋maven→Eclipse的Maven整合→安裝

步驟4 − 使用Maven配置Cucumber。

• 建立一個Maven專案。

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

  • 提供 group Id（group Id 將唯一標識你的專案在所有專案中）。

  • 提供構件 ID（構件 ID 是不帶版本的 jar 檔案的名稱。你可以選擇任何小寫的名稱）。

  • 點選完成。

步驟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://#/"); 
   } 
   @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…”和“關聯…”選項，如下圖所示。

步驟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。

• 轉到頁面http://www.activestate.com/komodo-ide/downloads

• 下載免費試用安裝程式。

• 雙擊下載的exe。

• 按照安裝步驟操作。

• 完成安裝並開啟IDE。

步驟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。

• 將放置搜尋按鈕。

• 搜尋結果將顯示在網頁上。

• 瀏覽器例項將關閉。