Behave 快速指南

Behave - 簡介

Behave 是一個用於在Python程式語言中進行行為驅動開發 (BDD) 的工具。在敏捷開發框架中，BDD 創造了一種文化，在這種文化中，測試人員、開發人員、業務分析師以及專案的其他利益相關者都可以為軟體開發做出貢獻。

簡而言之，技術人員和非技術人員都在整個專案中發揮作用。Behave 的測試是用純文字開發的，實現邏輯是用 Python 編寫的。

BDD 格式始於類似故事的軟體特性描述。

然後繼續開發並執行以下任務：

為特性開發失敗的測試用例。
實現透過測試的邏輯。
程式碼重構以滿足專案指南。

有很多 BDD 庫，例如支援 JavaScript 的 Mocha，支援 Java/Ruby 的 Cucumber，支援 Python 的 Behave，等等。

在本教程中，我們將詳細討論 Behave。

讓我們看看 BDD 的基本結構。它主要包括特性檔案、步驟定義檔案等。

特性檔案

Behave 中的特性檔案可以如下所示：

Feature − Verify book name added in Library.
Scenario − Verify Book name.
Given − Book details.
Then − Verify book name.

相應的步驟定義檔案

以下是 Behave 工具中相應的定義檔案：

from behave import *
@given('Book details')
def impl_bk(context):
   print('Book details entered')
@then('Verify book name')
def impl_bk(context):
   print('Verify book name')

輸出

執行特性檔案後獲得的輸出如下：

輸出顯示特性和場景名稱，以及測試結果和各個測試執行的持續時間。

Behave - 安裝

Behave 的安裝可以透過以下幾種方式完成：

使用 pip

要安裝 Behave，我們應該在系統中安裝pip – Python 語言的包安裝程式。如果 Python 版本大於 2（直到 2.7.9），則預設安裝 pip。

要安裝 pip，請執行以下命令：

pip install pip

要使用Behave安裝 pip，請執行以下命令：

pip install behave

您的計算機上將出現以下螢幕：

我們可以使用以下命令更新現有版本的 Behave：

pip install –U behave

我們也可以使用easy_install安裝 Behave。

要安裝 Setuptools，請執行以下命令：

pip install setuptools

現在，要安裝 Behave，請執行以下命令

easy_install behave

我們可以使用以下命令更新現有版本的 behave：

easy_install –U behave

使用原始碼分發

解壓 Behave 的原始碼分發包後，鍵入新生成的目錄'behave-<version>' 並執行以下命令：

python setup.py install

使用 Git 倉庫

我們首先應該在系統中安裝 pip。

之後，要使用 Git 倉庫安裝最新版本的 Behave，請執行以下命令：

pip install git+https://github.com/behave/behave

如果我們使用PyCharm 編輯器編寫 Behave 程式碼，則應該安裝專業版的 PyCharm 以及與之一起安裝的 Gherkin 外掛。

Behave - 命令列

Behave 有一組命令列引數，也可以從配置檔案中概述。配置檔案中設定的值會自動使用，但是可以透過命令列引數覆蓋。

命令列引數

讓我們討論一些命令列引數：

–c, --no-color

削弱 ANSI 顏色轉義符的使用。

--color -

使用 ANSI 顏色轉義符。這是一個內建特性，可以覆蓋配置檔案中的設定。

–d, --dry-run

呼叫格式化程式而不執行步驟。

-D, --define

宣告 config.userdata 字典的自定義資訊。

–e, --exclude Pattern

從執行中排除與正則表示式模式相同的特性檔案。

–i, --include Pattern

在執行期間包含與正則表示式模式相同的特性檔案。

--no-junit

省略 JUnit 報告作為輸出。

--junit

新增 JUnit 報告作為輸出。啟用 JUnit 時，每個 stdout 和 stderr 都會成為 junit 報告的一部分。（與 -capture/-no-capture 選項無關）。

–f, --format

定義格式化程式。如果省略，則使用內建格式化程式。–format-help 命令將顯示所有可用的格式。

-steps-catalog

顯示所有現有步驟定義的目錄。

–k, --no-skipped

從控制檯列印中排除跳過的步驟。

no-snippets

從控制檯列印中排除尚未實現的步驟的程式碼片段。

--snippets

在控制檯列印中包含尚未實現的步驟的程式碼片段。這是一個內建特性，可以覆蓋配置檔案設定。

–m, --no-multiline

排除步驟下的多行表和字串。

--multiline

包含步驟下的多行表和字串。這是一個內建特性，可以覆蓋配置檔案設定。

–n, --name

包含在執行中與指定名稱相同的特性元素。如果多次提供此選項，它將與所有名稱匹配。

--no-capture

排除捕獲 stdout。

--capture

包含 stdout。這是一個內建特性，可以覆蓋配置檔案設定。

--no-capture-stderr

排除捕獲 stderr。

--capture-stderr

包含 stderr。這是一個內建特性，可以覆蓋配置檔案設定。

--no-logcapture

排除捕獲日誌。

--logcapture

包含日誌捕獲。步驟的每個日誌都將在失敗時出現並可用。這是一個內建特性，可以覆蓋配置檔案設定。

--logging-level

提及要捕獲的日誌記錄級別。預設值為 INFO。

--logging-format

提及用於列印語句的使用者定義格式。預設值為 %(levelname)s:%(name)s:%(message)s。

--logging-datefmt

提及用於列印語句的使用者定義日期和時間格式。

--logging-filter

提及是否要過濾語句。預設情況下捕獲所有語句。如果輸出太長，我們可以使用此選項過濾掉不必要的輸出。

--logging-clear-handlers

刪除所有用於日誌記錄的處理程式。

--no-summary

排除執行後的摘要。

-summary

包含執行後的摘要。

–o, --outfile

寫入給定檔案而不是使用 stdout。

–q, --quiet

是 –no-snippets –no-source 的別名。

–s, --no-source

排除列印步驟定義的檔案和行以及步驟。

--show-source

包含列印步驟定義的檔案和行以及步驟。這是一個內建特性，可以覆蓋配置檔案設定。

--stage

描述測試的當前階段。階段名稱用作環境檔案的名稱字尾，以及步驟的目錄。

--stop

遇到第一個失敗後終止執行測試。

–t, --tags

包含在執行中具有與 TAG_EXPRESSION 相同的標籤的特性/場景。

–T, --no-timings

排除列印每個步驟的執行持續時間。

--show-timings

捕獲每個步驟在控制檯中完成所需的時間（以秒為單位）。這是一個內建特性，可以覆蓋配置檔案設定。

–v, --verbose

顯示載入的特性和檔案。

–w, --wip

執行具有 wip 標籤的場景。此外，我們必須使用純格式化程式，並且不記錄 stdout 或日誌輸出，並在第一次失敗後終止。

–x, --expand

在輸出中展平場景大綱的表。

--lang

使用除英語以外的語言的關鍵字。

--lang-list

顯示 –lang 中的所有語言。

--lang-help

顯示為單一語言獲取的所有翻譯。

--tags-help

顯示標籤語句的幫助。

--version

顯示版本。

junit –directory

這是儲存 Junit 報告的目錄位置。

--show-skipped

在控制檯列印中包含跳過的步驟。這是一個內建特性，可以覆蓋配置檔案設定。

Behave - 配置檔案

Behave 配置檔案被稱為.behaverc/behave.ini/setup.cfg/tox.ini（任選其一，由使用者選擇）。

這些檔案可以位於以下位置：

當前工作目錄。
使用者主目錄。
對於 Windows 使用者，位於 %APPDATA% 目錄下。

命令behave –v將顯示所有配置詳細資訊。配置檔案應以關鍵字[behave]開頭，並遵循Windows INI樣式格式。

例如：

[behave]
format = plain
dry_run = false

引數型別

Behave中的配置引數型別包括以下幾種：

文字 (Text) - 為配置設定賦值文字。
布林值 (Bool) - 為配置設定賦布林值。文字定義行為（真值包括1、true、yes和on）。假值包括0、false、no和off）。
序列<文字> (Sequence<text>) - 在換行符上接受多個值。

例如，標籤表示式可以如下所示：

tags=@a, ~@b
         @c

這等效於以下標籤表示式：

--tags @a, ~@b --tags @c

配置引數

下面解釋Behave中的一些配置引數：

color - bool

使用ANSI顏色轉義符。這是一個內建特性，可以覆蓋配置檔案中的設定。

dry_run - bool

呼叫格式化程式但不執行步驟。

userdata_defines - sequence<text>

宣告config.userdata字典的自定義資料。

exclude_re - text

從執行中排除與正則表示式模式相同的特徵檔案。

include_re - text

在執行期間包含與正則表示式模式相同的特徵檔案。

junit - bool

新增 JUnit 報告作為輸出。啟用 JUnit 時，每個 stdout 和 stderr 都會成為 junit 報告的一部分。（與 -capture/-no-capture 選項無關）。

junit_directory - text

這是儲存JUnit報告的目錄位置。

default_format - text

宣告預設格式化程式。預設值為pretty。

format: sequence<text>

定義格式化程式。如果省略，則使用內建格式化程式。–format-help 命令將顯示所有可用的格式。

steps_catalog - bool

顯示所有現有步驟定義的目錄。

scenario_outline_annotation_schema: text

指定場景輪廓的註釋模式。

show_skipped - bool

在控制檯中列印時包含跳過的步驟。這是一個內建特性，可以覆蓋配置檔案設定。

show_snippets - bool

在控制檯中列印尚未實現的步驟的程式碼片段。這是一個內建特性，可以覆蓋配置檔案設定。

show_multiline - bool

包含步驟下的多行表和字串。這是一個內建特性，可以覆蓋配置檔案設定。

name - sequence<text>

包含在執行中與指定名稱相同的特徵元素。如果多次提供此選項，它將匹配所有指定的名稱。

stdout_capture - bool

包含 stdout。這是一個內建特性，可以覆蓋配置檔案設定。

stderr_capture - bool

包含 stderr。這是一個內建特性，可以覆蓋配置檔案設定。

log_capture - bool

包含日誌捕獲。步驟的每個日誌都將在失敗時出現並可用。這是一個內建特性，可以覆蓋配置檔案設定。

logging_level - text

指定要捕獲的日誌級別。預設值為INFO。

logging_format - text

指定列印語句的使用者自定義格式。預設值為%(levelname)s:%(name)s:%(message)s。

logging_datefmt - text

指定列印語句的使用者自定義日期和時間格式。

logging_filter - text

指定要過濾的語句。預設情況下捕獲所有語句。如果輸出過長，我們可以使用此選項過濾掉不必要的輸出。

logging_clear_handlers : bool

刪除所有用於日誌記錄的處理程式。

summary - bool

執行後包含摘要。

outfiles - sequence<text>

寫入給定檔案而不是使用 stdout。

paths - sequence<text>

指定特徵檔案的預設路徑。

quiet - bool

別名為 –no-snippets –no-source。

show-source - bool

包含列印步驟的步驟定義檔案和行號。這是一個內建特性，可以覆蓋配置檔案設定。

stage - text

描述測試的當前階段。階段名稱用作環境檔案和步驟目錄的名稱字尾。

stop - bool

遇到第一個失敗後終止執行測試。

tags - sequence<text>

包含在執行中具有與TAG_EXPRESSION相同的標籤的特性/場景。

default_tags - text

如果沒有給出，則宣告預設標籤。

show_timings - bool

捕獲每個步驟在控制檯中完成所需的時間（以秒為單位）。這是一個內建特性，可以覆蓋配置檔案設定。

verbose - bool

顯示載入的特性和檔案。

wip - bool

執行具有 wip 標籤的場景。此外，我們必須使用純格式化程式，並且不記錄 stdout 或日誌輸出，並在第一次失敗後終止。

expand - bool

在輸出中展平場景大綱的表。

lang - text

使用除英語以外的語言的關鍵字。

Behave - 特性測試設定

Behave 使用三種不同的檔案型別，如下所示：

特徵檔案 (Feature files) 由業務分析師或任何專案干係人建立，包含與行為相關的用例。
步驟實現檔案 (Step Implementation file) 用於特徵檔案中定義的場景。
環境設定檔案 (Environment Setup files) 在這裡，在步驟、特性、場景等之前和之後執行前後條件。

特性檔案

特徵檔案應該在一個名為features的資料夾中。此外，features目錄中應該有一個名為steps的子目錄。

啟動特徵檔案

我們可以使用各種命令列引數啟動特徵檔案。這些將在下面解釋：

如果沒有可用資訊，則將載入features目錄中的所有特徵檔案以在Behave中執行。
如果提供了features目錄的路徑，則必須至少有一個特徵檔案（副檔名為.feature）和一個名為steps的子目錄。
此外，如果存在environment.py，它應該位於包含steps目錄的目錄中，而不是steps目錄內。
如果提供了特徵檔案的路徑，則它指示Behave搜尋該檔案。為了獲得該特徵檔案的相應步驟目錄，將搜尋父目錄。
如果在當前父目錄中找不到，則搜尋其父目錄。這將持續進行，直到到達檔案系統根目錄。此外，如果存在environment.py，它應該位於包含steps目錄的目錄中，而不是steps目錄內。

Behave - Gherkin 關鍵字

Behave中的Gherkin關鍵字列在下面：

特性 (Features)
場景 (Scenario)
步驟 (Steps)
背景 (Background)
場景輪廓 (Scenario Outline)
文字 (Text)
表格 (Table)
標籤 (Tags)
給定 (Given)
當 (When)
然後 (Then)
但是 (But)
並且 (And)

特徵檔案是用Gherkin語言編寫的。它是純文字，由團隊的非技術成員（業務分析師）建立。特徵檔案可用於自動化測試和文件。

換行符結束語句包含在Behave中。我們可以使用製表符/空格進行縮排。大多數行以關鍵字開頭，例如Scenario、Given、Then等。可以在檔案的任何位置添加註釋。它們以/不以空格開頭，後跟#符號和文字。

讓我們討論一些關鍵的Gherkin關鍵字。

特性 (Feature)

一個特性包含場景。它們可以包含/不包含描述、背景和一組標籤。

特徵檔案的結構如下：

Feature − Verify book name added in Library
Scenario − Verify Book name
Given Book details
Then Verify book name

特性的名稱應該對正在測試的特性進行描述。但是，冗長的描述不是強制性的，只新增描述是為了消除特性名稱中的歧義。

背景 (Background)

新增背景是為了有一組步驟。它類似於一個場景。我們可以使用背景為多個場景新增上下文。它在每個場景之前執行，但在before hooks執行之後執行。

背景通常用於執行前提條件，例如登入場景或資料庫連線等。

可以新增背景描述以提高人類的可讀性。背景只能在一個特徵檔案中出現一次，並且必須在場景或場景輪廓之前宣告。

不應使用背景來建立複雜的狀態（只有在無法避免的情況下）。此部分應簡短且真實。此外，我們應該避免在一個特徵檔案中包含大量場景。

包含背景的特徵檔案

包含Background關鍵字的特徵檔案如下：

Feature: Payment Process
   Background:
      Given launch application
      Then Input credentials
   Scenario: Credit card transaction
      Given user is on credit card payment screen
      Then user should be able to complete credit card payment
   Scenario: Debit card transaction
      Given user is on debit card payment screen
      Then user should be able to complete debit card payment

場景 (Scenario)

場景定義了正在測試的應用程式的行為。它有一個標題來描述其目標。可以新增其描述以提高人類的可讀性。

場景可以有多個步驟，這些步驟以關鍵字Given、Then、When等開頭。建議使用場景來檢查單個特性或預期結果。

包含場景的特徵檔案

包含Scenario關鍵字的特徵檔案如下：

Feature − Payment Process
      Scenario − Credit card transaction
   Given user is on credit card payment screen
   Then user should be able to complete credit card payment

場景輪廓 (Scenario Outline)

如果我們有一組類似的條件和要在場景中傳遞的結果，則使用場景輪廓。場景輪廓附帶一個示例表，並且可以有多個示例表。

對於示例表標題行後的每一行，測試都會執行一次。要測試的值由括號<>中包含的名稱表示。這些名稱應與示例表標題匹配。

它有助於減少程式碼行數，因為它消除了重複的步驟並對我們的測試進行排序。

包含場景輪廓的特徵檔案

包含Scenario Outline關鍵字的特徵檔案如下：

Feature − User information
Scenario Outline: Check login functionality
   Given user enters <email> and <password>
   Then user should be logged in

示例

以下是包含Scenario Outline的特徵檔案的示例：

Examples: Credentials
   | email        | password  |
   | qa@gmail.com | pwd1      |
   | qe@gmail.com | pwd2      |

使用不同的引數集執行相同的測試。

給定 (Given)

以關鍵字Given開頭的步驟用於在使用者與系統互動之前將系統置於熟悉的環境中（類似於前提條件）。建議不要在Given步驟中描述使用者操作。

可以新增Given步驟來設定資料庫中的配置、登入應用程式等。

包含Given的特徵檔案

包含Given關鍵字的特徵檔案如下：

Feature − Payment Process
            Scenario − Credit card transaction
   Given user is on credit card payment screen
   Then user should be able to complete credit card payment

當 (When)

以關鍵字When開頭的步驟用於新增使用者需要執行的基本任務。這樣，使用者與系統進行通訊，從而導致系統狀態發生變化或對其他地方產生影響。

包含When的特徵檔案

包含When關鍵字的特徵檔案如下：

Feature − Payment Process
            Scenario − Credit card transaction
   Given user is on credit card payment screen
      When user clicks on the Payment with Credit Card button
   Then user should be able to complete credit card payment

然後 (Then)

以關鍵字Then開頭的步驟用於獲得預期結果。在此步驟中觀察到的結果（理想情況下為輸出形式 - 訊息、報告等）應與業務場景和包含它的特徵檔案相關聯。

建議不要將Then步驟用於資料庫場景，因為它基本上用於描述終端使用者可見的後果。

包含Then的特徵檔案

包含When關鍵字的特徵檔案如下：

Feature − Payment Process
            Scenario − Credit card transaction
   Given user is on credit card payment screen
   When user clicks on the Payment with Credit Card button
   Then user should be able to complete credit card payment

And, But

如果我們有多個連續的Given、When、Then步驟，我們可以使用And和But步驟。它為使用者帶來了更好的可讀性。

包含多個連續Then/Given步驟的特徵檔案

Behave中包含多個連續Then/Given步驟的特徵檔案如下：

Feature − Verify book names added in Library
   Scenario − Verify Book name
      Given Book1 details
      Given Book2 details
      Then Verify book names
      Then Verify newly added book names should not be in Delete History

不包含多個Then/Given步驟的特徵檔案

不包含多個Then/Given步驟的特徵檔案如下：

Feature − Verify book names added in Library
   Scenario − Verify Book name
      Given Book1 details
      And Book2 details
      Then Verify book names
         But Verify newly added book names should not be in Delete History

步驟資料 - 表格 (Step Data – Table)

步驟可以包含與其關聯的文字和資料表。我們可以使用步驟新增資料表。建議將表格資料縮排，並且必須為每一行具有相等的列數。

列資料應由|符號分隔。

包含表格的特徵檔案

包含table關鍵字的特徵檔案如下：

Feature − User Registration
Scenario − User enters registration details
   When User enters name and password
      | name |password |
      | t1   | pwd     |
      | t2   | pwd1    |
Then user should be able to complete registration

表格可透過上下文變數中的.table屬性（傳遞到步驟函式中）訪問Python程式碼。表格是Table的一個例項。

表格的實現邏輯

以下是表格中.table屬性的實現邏輯：

@when('User enters name and password')
def step_impl(context):
   for r in context.table:
      model.delete_usr(name=r['name'], password=r['password'])

步驟資料 - 文字 (Step Data – Text)

步驟後用"""括起來的文字塊將與該步驟關聯。此處將解析縮排。文字開頭的所有空格都將被移除。此外，後續所有行的開頭都必須至少有一個空格。

文字可以透過上下文變數（在步驟函式中傳遞）中的.text屬性訪問實現Python程式碼。

包含文字的特性檔案

包含文字關鍵字的特性檔案如下：

Feature − Verify book name added in Library
   
   Scenario − Verify Book name
      Given Book details
         """
          Text added for a step
         """
      Then Verify book name

標籤 (Tags)

可以標記特性檔案的一部分，以便Behave能夠僅驗證特性檔案中的特定部分。僅可以標記場景、特性和場景大綱。

此外，用於特性的標籤將被其所有場景和場景大綱繼承。標籤放置在我們要標記的場景或特性之前。我們也可以在一行中用空格分隔多個標籤。標籤以@開頭，後跟標籤名稱。

包含標籤的特性檔案

包含標籤關鍵字的特性檔案如下：

@payment
@high
Feature − Payment Process
      Scenario − Credit card transaction
   Given user is on credit card payment screen
   Then user should be able to complete credit card payment

標籤透過根據標籤排除/包含特定場景或特性來幫助管理測試執行。

Behave - 特性檔案

如前所述，Behave 使用三種不同的檔案型別。這些檔案如下：

特性檔案由業務分析師或任何專案干係人建立，包含與行為相關的用例。
步驟實現檔案 (Step Implementation file) 用於特徵檔案中定義的場景。
環境設定檔案在其中執行步驟、特性、場景等的預/後置條件。

特性檔案應位於名為features的資料夾中。此外，features目錄中還應該有一個名為steps的子目錄。

您的計算機上將出現以下螢幕：

啟動特徵檔案

我們可以使用各種命令列引數啟動特性檔案，如下所述：

如果沒有任何可用資訊，則將載入features目錄中的所有特性檔案以供Behave執行。
如果提供了features目錄的路徑，則必須至少有一個特徵檔案（副檔名為.feature）和一個名為steps的子目錄。
此外，如果存在environment.py，它應該位於包含steps目錄的目錄中，而不是steps目錄內。
如果提供了特徵檔案的路徑，則它指示Behave搜尋該檔案。為了獲得該特徵檔案的相應步驟目錄，將搜尋父目錄。
如果在當前父目錄中找不到，則搜尋其父目錄。這將持續進行，直到到達檔案系統根目錄。此外，如果存在environment.py，它應該位於包含steps目錄的目錄中，而不是steps目錄內。

特性檔案的結構

一個特性包含場景。它們可以包含/不包含描述、背景和一組標籤。

特性檔案的結構如下：

特性檔案

特性檔案的格式如下：

Feature − Verify book name added in Library
   Scenario − Verify Book name
      Given Book details
      Then Verify book name

對應的步驟實現檔案。

對應的步驟實現檔案如下所示：

from behave import *
@given('Book details')
def impl_bk(context):
      print('Book details entered')
@then('Verify book name')
def impl_bk(context):
      print('Verify book name')

輸出

執行特性檔案後獲得的輸出如下：

輸出顯示特性和場景名稱，以及測試結果和測試執行持續時間。

Behave - 步驟實現

Behave中特性檔案中場景的步驟應具有用Python編寫的實現邏輯。這被稱為實現/步驟定義檔案（.py副檔名），應位於steps目錄中。

此檔案中包含所有必要的匯入。steps目錄應是features目錄的一部分。

您的計算機上將出現以下螢幕：

步驟定義檔案包含定義特性檔案中步驟的Python函式。在Python函式的開頭，必須使用以@given、@when等開頭的裝飾器。這些裝飾器將與特性檔案中的Given、Then、When和其他步驟進行比較和匹配。

特性檔案

特性檔案如下：

Feature − Verify book name added in Library
   Scenario − Verify Book name
      Given Book details
      Then Verify book name

對應的步驟實現檔案

對應的步驟實現檔案如下所示：

from behave import *
@given('Book details')
def impl_bk(context):
      print('Book details entered')
@then('Verify book name')
def impl_bk(context):
      print('Verify book name')

輸出

執行特性檔案後獲得的輸出如下：

輸出顯示特性和場景名稱，以及測試結果和測試執行持續時間。

Behave - 初級步驟

讓我們建立一個基本的Behave測試。

特性檔案

標題為“支付型別”的特性的特性檔案如下：

Feature − Payment Types
   
   Scenario − Verify user has two payment options
      Given User is on Payment screen
      When User clicks on Payment types
      Then User should get Types Cheque and Cash

對應的步驟實現檔案

上述特性的對應步驟實現檔案如下：

from behave import *
@given('User is on Payment screen')
def impl_bkpy(context):
      print('User is on Payment screen')
@when('User clicks on Payment types')
def impl_bkpy(context):
      print('User clicks on Payment types')
@then('User should get Types Cheque and Cash')
def impl_bkpy(context):
      print('User should get Types Cheque and Cash')

專案結構

特性“支付型別”的專案結構如下：

輸出

執行特性檔案後獲得的輸出如下所示，此處使用的命令為behave

輸出顯示特性和場景名稱，以及測試結果和測試執行持續時間。

Python控制檯輸出如下：

Behave - 支援的語言

我們可以選擇在特性檔案中使用英語以外的其他語言。這是因為大多數BDD工具都支援國際化。重要的是，關鍵字Then、When、Given可以用其他本地語言（如西班牙語、法語等）來描述。

在這種情況下，開發人員也可以使用其他語言實現步驟定義。可以使用以下命令獲取所有語言的列表：behave --lang-list。

使用命令behave --lang-list後，您的計算機上將顯示以下螢幕：

Behave中包含的其他一些語言如下：

特性檔案可以與特定語言關聯。此時，BDD框架將為該特定語言選擇關鍵字。可以在配置檔案中將語言設定為預設語言。

Behave配置檔案可以是.behaverc或behave.ini檔案。如果我們希望語言為丹麥語，則應在配置檔案中將引數lang的值設定為da。

配置檔案設定

選擇特定語言的特性檔案設定如下所示，示例中使用的語言為丹麥語 (da)。

[behave]
lang = da

Behave - 步驟引數

我們可以將引數傳遞給Behave中的步驟。讓我們來看一個包含具有多個引數的步驟的特性檔案，其中設定了不同的值。這有助於簡化自動化實現，因為減少了步驟定義的總數。

特性檔案

請考慮以下特性檔案示例：

Feature − Schedule
   Scenario − Verify Day and Night Schedule
   Given I reach office at "day" shift
   And I reach office at "night" shift

特性檔案包含與Given和And步驟中幾乎相同的步驟。唯一的區別在於晝夜班的時間。無需為幾乎相同的步驟重複實現，我們可以將引數傳遞給步驟定義檔案中的步驟。

請注意：我們在特性檔案中將晝夜引數放在雙引號文字中（也可以使用單引號文字）。在步驟實現中，我們將傳遞用{}括起來的引數。

此外，引數作為引數之一傳遞給實現方法。

對應的步驟實現檔案

對應的步驟實現檔案如下：

from behave import *
@given('I reach office at "{time}" shift')
def step_implpy(context, time):
      print("Shift is: {}".format(time))

輸出

執行特性檔案後獲得的輸出如下所示，使用的命令為behave --no-capture -f plain：

輸出顯示列印了Shift is: day和Shift is: night。此處，引數day和night是從步驟中傳遞的。

Behave - 場景輪廓

如果我們有一組類似的標準並且結果要傳遞到場景中，則使用場景大綱。場景大綱附帶一個示例表。場景大綱可以有多個示例表。

對於示例表中（標題行之後）找到的每一行，測試都會執行一次。要測試的值由括號<>中包含的名稱表示。這些名稱應與示例表標題匹配。

它有助於減少程式碼行數（消除重複步驟）並組織我們的測試。

特性檔案

場景大綱的特性檔案如下：

Feature − User information
Scenario Outline: Check login functionality
   Given user enters "<name>" and "<password>"
   Then user should be logged in
   Examples: Credentials
      | name   | password |
      | user1  | pwd1     |
      | user2  | pwd2     |

請注意：我們將名稱和密碼引數括在“<>”中。這些引數是示例部分下方提供的列標題。在步驟實現中，我們將傳遞用“{}”括起來的引數。

此外，這些引數需要作為引數傳遞給實現方法。

對應的步驟實現檔案

對應的步驟實現檔案如下：

from behave import *
@given('user enters "{name}" and "{password}"')
def step_implpy(context, name, password):
      print("Username for login: {}".format(name))
         print("Password for login: {}".format(password))
@then('user should be logged in')
def step_implpy(context):
      pass

輸出

執行特性檔案後獲得的輸出，使用的命令為behave --no-capture -f plain。

輸出顯示列印了Username for login: user1, Password for login: pwd1和Username for login: user2, Password for login: pwd2。此處，從示例中傳遞了兩個資料集。

Behave - 多行文字

步驟後用"""括起來的文字塊將與該步驟關聯。此處將解析縮排。文字開頭的所有空格都將被移除，後續所有行的開頭都必須至少有一個空格。

文字可以透過上下文變數（在步驟函式中傳遞）中的.text屬性訪問實現Python程式碼。

特性檔案

標題為使用者資訊的特性的特性檔案如下：

Feature − User information
Scenario − Check login functionality
   Given user enters name and password
         """
         Tutorialspoint Behave
          Topic – Multiline Text
         """
   Then user should be logged in

對應的步驟實現檔案

特性的對應步驟實現檔案如下：

from behave import *
@given('user enters name and password')
def step_impl(context):
#access multiline text with .text attribute
      print("Multiline Text: " + context.text)
@then('user should be logged in')
def step_impl(context):
      pass

輸出

執行特性檔案後獲得的輸出如下所示，使用的命令為behave --no-capture -f plain。

輸出顯示列印了多行文字。

Behave - 設定表

步驟可以包含與其關聯的文字和資料表。我們可以使用步驟新增資料表。建議將表格資料縮排，並且必須為每一行具有相等的列數。

列資料應由|符號分隔。

包含表格的特性檔案 (Login.feature)

特性檔案如下所示：

Feature − User Information
Scenario − Check login functionality
   Given Collection of credentials
      | username |password |
      | user1    | pwd1    |
      | user2    | pwd2    |
   Then user should be logged in

表可以透過上下文變數（在步驟函式中傳遞）中的.table屬性訪問實現Python程式碼。表是Table的例項。我們可以使用設定表來促進測試設定。

Python 程式碼

訪問表 (login_module.py) 的Python程式碼如下：

class Deprt(object):
   def __init__(self, username, ms=None):
      if not ms:
         ms = []
      self.username = username
      self.ms = ms
   def m_addition(self, usernane):
      assert usernane not in self.ms
      self.ms.append(usernane)
class LModel(object):
   def __init__(self):
      self.loginusrs = []f
      self.passwords = {}
   def usr_addition(self, username, password):
      assert username not in self.loginusrs
      if password not in self.passwords:
         self.passwords[password] = Deprt(password)
      self.passwords[password].m_addition(username)

對應的步驟實現檔案 (step_implg.py)

檔案如下：

from behave import *
from features.steps.login_module import LModel
@given('Collection of credentials')
def step_impl(context):
   model = getattr(context, "model", None)
   if not model:
      context.model = LModel()
   #iterate rows of table
    for r in context.table:
      context.model.usr_addition(r["username"], password=r["password"])
@then('user should be logged in')
def step_impl(context):
   pass

專案設定

Python專案中檔案的專案設定如下：

輸出

執行特性檔案後獲得的輸出如下所示，使用的命令為behave --no-capture -f plain。

輸出顯示列印了設定表。

Behave - 步驟中的步驟

我們可以用一個宏步驟替換場景中的多個步驟。這有助於我們不必在步驟定義檔案中重複相同的程式碼。BDD框架能夠從步驟定義中呼叫多個步驟。

包含相似步驟的特性檔案

包含相似步驟的特性檔案如下：

Feature − Payment Module
   Scenario − Verify message after payment
      Given User is on payment screen
      When User enters payment details
      And User completes payment
      Then User should get success message
   Scenario − Verify new users can process payment
      Given User keys in payment info and submits
      Then success message should get displayed

在特性檔案中，我們有兩個具有相似步驟的場景。在Behave中，我們可以在單個步驟中執行多個步驟。這可以透過步驟實現檔案中的context.execute_steps方法來實現。

對應的步驟實現檔案

上述特性檔案的對應步驟實現檔案如下：

from behave import *
@given('User is on payment screen')
def is_on_payment_screen(context):
   print('User is on payment screen')
@when('User enters payment details')
def enters_payment_details(context):
   print('When User enters payment details')
@when('User completes payment')
def completes_payment(context):
   print('When User completes payment')
@then('User should get success message')
def get_success_message(context):
   print('Then User should get success message')
   @given('User keys in payment info and submits')
def payment_info_and_submits(context):
#passing steps within steps with context.execute_steps
   context.execute_steps(u"""
      Given User is on payment screen
      When User enters payment details
      And User completes payment
      """)
@then('success message should get displayed')
def success_message(context):
   print('Then success message should get displayed')

輸出

執行特性檔案後獲得的輸出如下所示，使用的命令為behave --no-capture -f plain。

後續輸出如下：

輸出顯示，場景“驗證”的新使用者可以透過執行場景“驗證新使用者可以處理支付”中的步驟來處理支付。

Behave - 背景

新增背景是為了擁有步驟組。它接近於場景。我們可以使用背景向多個場景新增上下文。它在每個特性的每個場景之前執行，但在before鉤子執行之後。

背景通常用於執行前提條件，例如登入場景或資料庫連線等。

可以新增背景描述以提高人類可讀性。它在一個特性檔案中只能出現一次，並且必須在場景或場景大綱之前宣告。

背景不應該用於建立複雜的狀態（只有在無法避免的情況下才可以使用）。此部分應簡潔且真實。此外，我們應該避免在一個特性檔案中包含大量的場景。

包含背景的特徵檔案

名為“支付流程”的特性檔案的背景如下：

Feature − Payment Process
   Background:
      Given launch application
      Then Input credentials
   Scenario − Credit card transaction
      Given user is on credit card payment screen
      Then user should be able to complete credit card payment
   Scenario − Debit card transaction
      Given user is on debit card payment screen
      Then user should be able to complete debit card payment

對應的步驟實現檔案

檔案如下所示：

from behave import *
@given('launch application')
def launch_application(context):
   print('launch application')
@then('Input credentials')
def input_credentials(context):
   print('Input credentials')
@given('user is on credit card payment screen')
def credit_card_pay(context):
   print('User is on credit card payment screen')
@then('user should be able to complete credit card payment')
def credit_card_pay_comp(context):
   print('user should be able to complete credit card pay')
@given('user is on debit card payment screen')
def debit_card_pay(context):
   print('User is on debit card payment screen')
@then('user should be able to complete debit card payment')
def debit_card_pay_comp(context):
   print('user should be able to complete debit card payment')

輸出

執行特性檔案後獲得的輸出如下所示，此處使用的命令為behave --no-capture -f plain。

後續輸出如下：

輸出顯示背景步驟（Given Launch applications & Then Input Credentials）在每個場景之前都運行了兩次。

Behave - 資料型別

Behave 中有兩種資料型別，分別是預定義型別和使用者自定義型別。讓我們首先了解預定義資料型別。

預定義資料型別

Behave 利用 parse 模組來解析步驟定義中的引數。讓我們探索一些受步驟定義支援並且不需要像使用者自定義資料型別那樣註冊的解析型別。

w（字串型別） - 下劃線 & 字母。
W（字串型別） - 下劃線 & 非字母。
s（字串型別） - 空格。
S（字串型別） - 非空格。
d（整數型別） - 數字。
D（字串型別） - 非數字。
n（整數型別） - 帶有千位分隔符的數字。
%（浮點型別） - 百分比。（轉換為 value/100.0）
f（浮點型別） - 定點數字。
e（浮點型別） - 帶指數的浮點數字。
g（浮點型別） - 數字格式。
b（整數型別） - 二進位制數。
o（整數型別） - 八進位制數。
x（整數型別） - 十六進位制數。
ti（日期時間型別） - ISO 8601 日期/時間格式的時間。
te（日期時間型別） - RFC 2822 電子郵件日期/時間格式的時間。
tg（日期時間型別） - 全域性日期/時間格式的時間。
ta（日期時間型別） - 美國日期/時間格式的時間。
tc（日期時間型別） - ctime() 日期/時間格式。
th（日期時間型別） - HTTP 日誌日期/時間格式的時間。
tt（時間型別）

在步驟實現中，我們將傳遞引數：用“{}”括起來的資料型別。

包含 % 資料型別的特性檔案

包含 % 資料型別的特性檔案如下：

Feature − Payment Process
   Scenario Outline: Credit card transaction
   Given user is on credit card payment screen
   When user makes a payment of "<p>" percent of total
   Examples: Amounts
      | p      |
      |80%     |
      |90%     |

對應的步驟實現檔案

檔案如下：

from behave import *
@given('user is on credit card payment screen')
def credit_card_pay(context):
   print('User is on credit card payment screen')
#passing parameter in % datatype enclosed in {}
@when('user makes a payment of "{p:%}" percent of total')
def step_impl(context, p):
   print('Number is: ')
   print(p)

輸出

執行特性檔案後獲得的輸出，使用的命令為behave --no-capture -f plain。

後續輸出如下：

輸出顯示 0.8 和 0.9，這是從 % 資料型別獲得的，用於表示從特性檔案中傳遞的 80% 和 90% 值。

使用者自定義資料型別

Behave 也具有使用者自定義資料型別。register_type 方法用於註冊使用者自定義型別，該型別可在匹配步驟時用於任何型別轉換。

特性檔案

名為“支付流程”的特性檔案如下：

Feature − Payment Process
   Scenario Outline: Credit card transaction
      Given user is on credit card payment screen
      When user makes a payment of "<amount>" of total
      Examples: Amounts
         |amount  |
         |75      |
         |85      |

在步驟實現中，我們將傳遞引數：用“{}”括起來的使用者自定義資料型別。register_type 方法用於註冊使用者自定義型別，該型別可在匹配步驟時用於任何型別轉換。

對應的步驟實現檔案

檔案如下：

from behave import *
from behave import register_type
#convert parsed text to float
def parse_percent(t):
   return float(t)
#register user-defined type
register_type(Float=parse_percent)
@given('user is on credit card payment screen')
def credit_card_pay(context):
   print('User is on credit card payment screen')
@when('user makes a payment of "{amount:Float}" of total')
def step_impl(context, amount):
   print('Number is: ')
   print(amount)

輸出

執行特性檔案後獲得的輸出，使用的命令為behave --no-capture -f plain。

後續輸出如下：

輸出顯示75.0和85.0，它們已轉換為浮點值（藉助使用者自定義轉換）。這些引數作為整數型別從特性檔案中傳遞。

Behave - 標籤

可以標記特性檔案的一部分，以便Behave能夠僅驗證特性檔案中的特定部分。僅可以標記場景、特性和場景大綱。

此外，用於特性的標籤將被其所有場景和場景大綱繼承。標籤放置在我們想要標記的場景或特性之前。我們也可以有多個標籤，這些標籤在同一行中用空格隔開。

標籤以 @ 開頭，後跟標籤名稱。

包含標籤的特性檔案 (Payment.feature)

包含標籤的特性檔案如下：

@high
Feature − Payment Process
@creditpayment
            Scenario − Credit card transaction
   Given user is on credit card payment screen
   Then user should be able to complete credit card payment
@debitpayment
            Scenario − Debit card transaction
   Given user is on debit card payment screen
   Then user should be able to complete debit card payment

標籤透過根據標籤排除/包含特定場景或特性來幫助管理測試執行。

在上面的示例中，要執行帶有 creditpayment 標籤的特定場景，我們必須執行以下命令：

behave payment.feature --tags=creditpayment

要執行帶有 high 標籤的特性並執行所有場景，我們必須執行以下命令：

behave payment.feature --tags=high

如果執行以下命令，則表示該命令將執行帶有 creditpayment 或 debitpayment 標籤的場景。

behave payment.feature --tags= creditpayment, debitpayment

如果執行以下命令，則表示該命令將執行帶有 creditpayment 和 debitpayment 標籤的兩個場景。

behave payment.feature --tags= creditpayment --tags=debitpayment

如果執行以下命令，則表示該命令將不執行帶有 creditpayment 標籤的場景。

behave payment.feature --tags= ~ creditpayment

因此，包含標籤的特性檔案 (Payment.feature) 將如下所示：

@high
Feature − Payment Process
@creditpayment @payment
   Scenario − Credit card transaction
      Given user is on credit card payment screen
@debitpayment @payment
      Scenario − Debit card transaction
      Given user is on debit card payment screen
   Scenario − Cheque transaction
      Given user is on cheque payment screen

對應的步驟實現檔案

檔案如下：

from behave import *
@given('user is on credit card payment screen')
def credit_card_pay(context):
   print('User is on credit card payment screen')
@given('user is on debit card payment screen')
def debit_card_pay(context):
   print('user is on debit card payment screen')
@given('user is on cheque payment screen')
def cheque_pay(context):
   print('user is on cheque payment screen')

輸出

執行特性檔案後獲得的輸出如下所示。在這裡，我們使用了命令behave --no-capture Payment.feature --tags=payment。

輸出顯示兩個場景透過，因為特性檔案中具有 payment 場景標籤的場景有兩個。

當我們使用命令behave --no-capture Payment.feature --tags=~creditpayment時，輸出如下所示：

輸出顯示兩個場景透過，因為特性檔案中沒有 creditpayment 場景標籤的場景有兩個。

當我們使用命令behave --no-capture Payment.feature --tags=high時，輸出如下所示：

輸出顯示三個場景透過，因為特性檔案中沒有帶有 high 標籤的特性的場景有三個。

使用命令behave --no-capture Payment.feature --tags=payment,creditpayment可獲得以下輸出：

輸出顯示兩個場景透過，因為特性檔案中沒有帶有 payment 或 creditpayment 標籤的場景有兩個。

Behave - 列舉

列舉用於將多個不同的基於字串的單詞對映到值。

我們可能需要一個使用者自定義資料型別，其具有以下特性：

必須匹配少量單詞。
在測試執行之前預定義值。

對於上述場景，可以使用基於字串的列舉。

特性檔案

考慮一下名為“支付流程”的特性的特性檔案，如下所示：

Feature − Payment Process
Scenario − Response
      When User asks "Is payment done?"
      Then response is "No"

在步驟實現檔案中，TypeBuilder.make_enum 函式評估為提供的單詞或字串列舉的正則表示式模式。register_type 方法用於註冊使用者自定義型別，該型別可在匹配步驟時用於任何型別轉換。

此外，我們將傳遞引數：用“{}”括起來的使用者自定義列舉資料型別。

對應的步驟實現檔案

上述特性的步驟實現檔案如下所示：

from behave import *
from behave import register_type
from parse_type import TypeBuilder
# -- ENUM: Yields True (for "yes"), False (for "no")
parse_response = TypeBuilder.make_enum({"yes": True, "no": False})
register_type(Response=parse_response)
@when('User asks "{q}"')
def step_question(context, q):
   print("Question is: ")
   print(q)
@then('response is "{a:Response}"')
def step_answer(context, a):
   print("Answer is: ")
   print(a)

輸出

執行特性檔案後獲得的輸出如下所示。在這裡，我們使用了命令behave --no-capture -f plain。

輸出顯示Is payment done?和False。False 輸出來自列舉資料型別。

Behave - 步驟匹配器

Behave 中有三種步驟匹配器。它們解釋如下：

ParseMatcher (parse) - 基於 parse 模組。
擴充套件的 ParseMatcher (cfparse) - 允許基數語法。
RegexMatcher (re) - 基於正則表示式來匹配模式。

Parse 匹配器

這是內建的步驟匹配器，具有以下特性：

易於使用和理解。
預定義和使用者自定義資料型別支援此匹配器。
藉助資料型別重新利用正則表示式。
隱藏正則表示式的複雜性。

擴充套件的 Parse 匹配器

它擴充套件了 Parse 匹配器。除了 Parse 匹配器的特性外，它還具有其他特性。

附加特性包括：

理解基數字段語法。
為具有基數字段部分的欄位生成缺失的型別轉換器。
基於 parse-type 構建。

Regex 匹配器

它具有以下特性：

向後相容 Cucumber。
比 parse 匹配器更易於使用。

讓我們詳細瞭解 parse 匹配器。

Parse 匹配器

特性檔案中可能存在具有幾乎相同短語的步驟。Behave 具有解析能力。為此使用use_step_parser方法，我們必須將解析器型別作為引數傳遞給該方法。

對於 parse 匹配器，我們必須傳遞引數 parse。它利用 parse 進行正則表示式解析和匹配。

特性檔案（幾乎相同的 Given 步驟）

類似步驟的特性檔案如下所示：

Feature − Payment Process
Scenario − Check Debit transactions
      Given user is on "debit" screen
      When user makes a payment
Scenario − Check Credit transactions
      Given user is on "credit" screen

對應的步驟實現檔案

步驟實現檔案如下所示：

from behave import *
#define parser type
use_step_matcher("parse")
@given('user is on "{p}" screen')
def step_impl(context, p):
   print(p)
@when('user makes a payment')
def step_pay_complete(context):
   pass

輸出

執行特性檔案後獲得的輸出如下所示。在這裡，我們使用了命令behave --no-capture -f plain。

輸出顯示debit和credit。這兩個值已透過特性檔案中幾乎相同的 Given 步驟傳遞。在步驟實現中，我們已經解析了這兩個步驟。

Behave - 正則表示式

讓我們總體瞭解正則表示式的語法：

點 (.) - 等效於任何字元。
插入符號 (^) - 等效於字串的開頭。（^…）
美元符號 ($) - 等效於字串的結尾。（…$）
| - 表示式 x|y，匹配 x 或 y。
\ - 跳脫字元。
\. - 匹配點 (.)
\\ - 匹配反斜槓 (\)
[...] - 宣告一組字元。([A-Za-z])
\d - 匹配數字。([0-9])
\D - 匹配非數字。
\s - 匹配空格字元。
\S - 匹配非空格字元。
\w - 匹配字母數字。
\W - 匹配非字母數字。
(...) - 對正則表示式的模式進行分組。
\number - 透過索引匹配先前組的文字。（\1）
(?P...) - 匹配模式並將其儲存在 name 引數中。
(?P=name) - 匹配先前組名稱匹配的所有文字。
(?:...) - 匹配模式，但無法捕獲文字。
(?#...) - 註釋（不考慮）。敘述模式的細節。

如果字元、字元集或組需要重複多次，則必須提供正則表示式模式的基數。

? : 基數為 0...1 的模式：非必需（問號）
* : 基數為 0 或更多的模式，0..(星號)
+ : 基數為 1 或更多的模式，1..(加號)
{n}：匹配 n 次重複的模式。
{a,b}：匹配模式從 a 到 b 次重複。
[A-Za-z]+ : 匹配多個字母字元。

特性檔案（Feature File）中可能存在具有幾乎相同短語的步驟。Behave 具有解析能力。為此，使用 `use_step_parser` 方法，並且必須將解析器型別作為引數傳遞給該方法。

對於正則表示式匹配器，必須傳遞引數 `re`。引數 `(?P...)` 用於從步驟定義中獲取引數。

特性檔案（幾乎相同的步驟）

包含相似步驟的特性檔案如下所示：

Feature − Payment Process
Scenario − Check Debit transactions
      Given user is on "debit" screen
   Scenario − Check Credit transactions
      Given user is on "credit" screen

對應的步驟實現檔案

步驟實現檔案如下所示：

from behave import *
#define parser type
use_step_matcher("re")
#regular expression parsing
@given('user is on "(?P<payment>.*)" screen')
def step_impl(context, payment):
   print("Screen type: ")
   print(payment)

輸出

執行特性檔案後獲得的輸出如下所示。這裡，我們使用了命令 `behave --no-capture -f plain`。

輸出顯示借方和貸方。這兩個值已透過特性檔案中幾乎相同的步驟傳遞。在步驟實現中，我們使用正則表示式解析了這兩個步驟。

Behave - 可選部分

特性檔案可能包含具有幾乎相同短語的步驟。Behave 具有解析能力，因此一個步驟定義可以涵蓋這些步驟。為此，使用 `use_step_parser` 方法，並且必須將解析器型別作為引數傳遞給該方法。

對於擴充套件的解析匹配器，必須傳遞引數 `cfparse`。它具有基數字段 (CF) 支援。預設情況下，它會為連線的基數生成缺失的型別轉換器（如果給出了基數等於一的型別轉換器）。

它可以支援以下解析表示式：

`{values:Type+}` – 基數 = 1..N，多
`{values:Type*}` – 基數 = 0..N，多0
`{values:Type?}` – 基數 = 0..1，可選

特性檔案（幾乎相同的步驟）

包含幾乎相同步驟的特性檔案如下所示：

Feature − Payment Process
Scenario − Check Debit transactions
      Given user is on "debit" screen
   Scenario − Check Credit transactions
      Given user is on "credit" screen

`register_type` 方法用於註冊使用者自定義型別，該型別可以在匹配步驟時用於任何型別轉換。

對應的步驟實現檔案

步驟實現檔案如下所示：

from behave import *
import parse
#define parse type
use_step_matcher("cfparse")
# for whitespace characters
@parse.with_pattern(r"x\s+")
def parse_string(s):
#type converter for "x" succeeded by single/multiple spaces
   return s.strip()
#register user-defined datatype
register_type(x_=parse_string)
#optional part :x_? cardinality field in parse expression
@given('user is on {:x_?}{payment} screen')
def step_payment(context, x_, payment):
   print("Payment type: ")
   print(payment)

輸出

執行特性檔案後獲得的輸出如下所示，使用的命令為behave --no-capture -f plain。

輸出顯示 `debit` 和 `credit`。這兩個值已透過特性檔案中幾乎相同的步驟傳遞。在步驟實現中，我們使用解析表示式中的基數字段解析了這兩個步驟。

Behave - 多方法

特性檔案可能包含具有幾乎相同短語的步驟。例如：

Given user makes payment of 100 INR
And user makes payment of 10 Dollar

這裡，我們可以使用不同的步驟定義來區分印度盧比和美元。為此，我們可以使用多方法法，其中必須為不同的資料型別使用不同的正則表示式。

特性檔案（幾乎相同的步驟）

特性檔案如下所示：

Feature − Multi-Methods
   Scenario − Purchase
      Given User is on shop
      When user purchases 3 shirts
      And user purchases 4 pants

在步驟實現檔案中，`TypeBuilder.make_choice` 函式會評估為提供的選項提供的正則表示式模式。`register_type` 方法用於註冊使用者自定義型別，該型別可以在匹配步驟時用於任何型別轉換。

此外，我們還應傳遞引數：用“{}”括起來的使用者自定義資料型別。

對應的步驟實現檔案

步驟實現檔案如下所示：

from behave import *
from behave import register_type
from parse_type import TypeBuilder
parse_dress = TypeBuilder.make_choice(["shirts", "t-shirts"])
#register user-defined datatype
register_type(Dress=parse_dress)
parse_pant = TypeBuilder.make_choice(["pants", "gowns"])
#register user-defined datatype
register_type(Pant=parse_pant)
@given("User is on shop")
def step_user_shop(context):
      pass
# multiple methods being used .
@when(u"user purchases {count:n} {d:Dress}")
def step_dress(context, count, d):
      print("User purchased: ")
      print(d)
      print("Count is:")
      print(count)
@when(u"user purchases {count:n} {p:Pant}")
def step_pant(context, count, p):
      print("User purchased: ")
      print(p)
      print("Count is:")
      print(count)

輸出

執行特性檔案後獲得的輸出如下所示，使用的命令為behave --no-capture -f plain。

輸出顯示購買的商品及其數量。這兩個值已透過特性檔案中幾乎相同的步驟（但資料型別不同）傳遞。在步驟實現中，我們使用了多種方法來獲取這些值。

Behave - 步驟函式

步驟函式是在 steps 目錄中存在的 Python 檔案中建立的。該目錄中的每個 Python 檔案（副檔名為 .py）都會被匯入以獲取步驟實現。

一旦特性檔案被觸發執行，實現檔案就會被載入。步驟函式與步驟裝飾器相關聯。

步驟實現必須以匯入開頭，使用以下命令：

from behave import *

這將匯入 Behave 中描述的多個裝飾器，以幫助我們找到步驟函式。`given`、`when`、`then` 等裝飾器接受一個字串引數。

例如，考慮以下程式碼：

@given('user is on admin screen')
def step_impl(context):
      pass

上述程式碼將匹配以下特性檔案的 Given 步驟：

Feature − Admin Module
Scenario − Admin verification
      Given user is on admin screen

特性檔案中以 And/But 開頭的步驟將重新命名為其之前的步驟關鍵字。

例如，考慮以下特性檔案：

Feature − Admin Module
Scenario − Admin verification
      Given user is on admin screen
       And user is on history screen
       Then user should be able to see admin name
         But user should not able to check history

And 步驟將重新命名為 Given 步驟，But 步驟將重新命名為之前的步驟關鍵字。所有這些都在內部處理。

如果連續有多個 And/But 步驟，它們將繼承非 And 或 But 關鍵字的關鍵字。

具有步驟裝飾器的步驟函式至少應包含一個引數。第一個引數稱為上下文變數。其他引數來自步驟引數（如果需要）。

例如，請參考根據步驟引數的步驟函式。

@given('user is on admin screen')
def step_impl(context):
      pass

專案結構

特性檔案的專案結構如下所示：

Behave - 步驟引數

我們可以在步驟名稱中使用引數。這些引數可以使用正則表示式或使用 `use_step_matcher` 方法的預設或擴充套件解析器來處理。

`behave.use_step_matcher(name)`

修改解析步驟文字的引數匹配器。Behave 中存在多個內建解析器，如下所述：

`parse` – 它提供了一個簡單的解析器，該解析器使用簡單的語法恢復步驟引數的正則表示式。例如，`{parameter: type}`。它允許使用型別轉換器進行型別轉換。
`cfparse` – 它具有基數字段 (CF) 支援。預設情況下，它會為連線的基數生成缺失的型別轉換器（如果給出了基數等於一的型別轉換器）。它可以支援以下解析表示式：

`{values:Type+}` – 基數 = 1..N，多

`{values:Type*}` – 基數 = 0..N，多0

`{values:Type?}` – 基數 = 0..1，可選

它允許使用型別轉換器進行型別轉換。
`re` – 它使用完整的正則表示式來解析子句。我們必須藉助命名組 `(?P...)` 來宣告從文字中獲得的變數，然後將其饋送到步驟 ()。

我們可以使用 `register_type` 方法建立自定義匹配器和新的資料型別。

`behave.register_type(w)`

註冊使用者自定義型別，以便在步驟匹配時進行型別轉換期間進行解析。

`class behave.matchers.Matcher(func, pattern ,step_type=None)`

它從步驟名稱中提取引數。

`pattern` – 與步驟函式關聯的模式匹配。
`func` – 步驟函式與模式關聯。
`check_match(step)` – 與提供的步驟名稱匹配。
`describe(schema=None)` – 以文字形式提供函式或匹配器物件的描述。
`regex_pattern`：產生使用的文字正則表示式。

`class behave.model_core.Argument(start, end, original, value, name=Name)`

特性檔案中使用步驟裝飾器引數獲得的步驟名稱的引數。

屬性如下：

`original` – 在步驟名稱中匹配的原始文字。
`value` – 已進行型別轉換的引數值。
`name` – 引數名稱。如果未給出引數，則值為 None。
`start` – 引數在步驟名稱中的起始索引。
`end` – 引數在步驟名稱中的結束索引。

`class behave.matchers.Match(func, arguments=None)`

特性檔案中已進行引數匹配並使用步驟裝飾器引數獲得的步驟。

屬性如下：

`func` – 適用於給定匹配的步驟函式。
`arguments` – 引數列表，其中包含從步驟名稱中獲得的匹配引數例項。

Behave - 執行指令碼

我們可以透過執行命令列引數執行 Behave 測試，或者我們可以建立一個執行器指令碼。此指令碼提供執行測試並生成相應報告的功能。

我們可以重試並執行失敗的測試。此外，在執行整個套件之前，執行器指令碼能夠進行應用程式程式設計介面 (API) 呼叫並確保 API 沒有問題。

執行器指令碼步驟

按照以下步驟在 Behave 中成功建立和執行執行器指令碼。

步驟 1 - 在 features 資料夾中建立一個執行器指令碼 (runner.py)。

您的計算機上將出現以下螢幕：

步驟 2 - 執行測試的執行器指令碼實現

可以使用以下程式碼實現執行測試的執行器指令碼：

import subprocess
if __name__ == '__main__':
#command line args along with error capture on failure with check true
      s = subprocess.run('behave --no-capture',shell=True, check=True)

步驟 3 - 執行執行器指令碼

使用命令 `python3 runner.py`（如果 Python 版本為 3）執行 runner.py 檔案。您的計算機上將出現以下螢幕

步驟 4 - 透過傳遞命令列引數來引數化執行器指令碼。

執行測試的執行器指令碼實現可以如下完成：

import argparse
import subprocess
if __name__ == '__main__':
   p = argparse.ArgumentParser()
  #--testdir command line argument added
   p.add_argument('--testdir', required=False, help="File path")
   a = p.parse_args()
   testdir = a.testdir
   #complete command
   c= f'behave --no-capture {testdir}'
   s = subprocess.run(c, shell=True, check=True)

步驟 5 - 執行執行器指令碼

使用命令 `python3 runner.py --testdir=features` 執行 runner.py 檔案。

Behave - 排除測試

我們可以透過檔名排除要執行的檔案。

假設 features 資料夾中有多個特性檔案。計算機上可以看到以下螢幕：

執行命令 behave 後，輸出將如下所示：

如果我們只需要執行特性檔案 `Payment.feature` 並排除 `Payment1.feature`，則必須傳遞命令列引數 `--e` 或 `--exclude`，後跟正則表示式的模式。

執行命令 `behave --exclude *1.feature` 後，輸出如下所示：

輸出顯示 `一個特性透過` 以及 `Payment.feature` 檔名。此外，Payment1.feature 未包含在執行中。

Behave - 重試機制

我們可以在 Behave 中重新執行特性檔案中失敗的場景。這由格式化程式處理。

可以使用以下命令檢視 Behave 中所有可用的格式化程式：

behave –f help

使用該命令後，您可以看到以下螢幕：

重新執行格式化程式用於捕獲失敗的場景並將其輸出到單獨的檔案中。讓我們來看一個例子，其中我們有一個失敗的特性。

然後使用以下命令捕獲另一個特性檔案中的失敗特性：

behave –f rerun –o failed_features.feature

您可以看到以下內容：

`failed_features.feature` 檔案在專案中生成。它包含我們發生失敗的特性檔名稱 `Payment1.feature`。

要僅重新觸發失敗的場景，我們必須執行以下命令：

behave @failed_features.feature

您將看到以下螢幕：

Behave - 報告

報告生成是測試自動化框架最重要的步驟之一。執行結束時，我們不能依賴控制檯輸出，而應該有一個詳細的報告。

它應包含有關透過、失敗、跳過、特性和場景細分的測試數量的資訊。Behave 不會生成內建報告，但它可以輸出多種格式，我們可以利用第三方工具生成報告。

可以使用以下命令顯示 Behave 中所有可用的格式化程式：

behave --format help

使用該命令後，您的計算機上將出現以下螢幕：

一些常見的 Behave 報告包括：

Allure 報告。
輸出 JSON 報告。
JUnit 報告

JUnit 報告

讓我們執行一個包含兩個特性檔案的測試，測試結果如下：

上述測試的專案資料夾結構如下所示：

步驟 1 - 執行命令

要建立 JUnit 報告，請執行以下命令：

behave --junit

步驟 2 - 生成報告資料夾

專案中會生成一個名為 reports 的資料夾，其中包含名為 TESTS-<feature 檔名>.xml 的檔案。

這裡，Payment 和 Payment1 是 feature 檔案的名稱。

步驟 3 - 將報告生成到特定資料夾

要將報告生成到特定資料夾（例如 my_reports），我們必須執行以下命令：

behave --junit --junit-directory my_reports

專案中會生成一個名為 my_reports 的資料夾，其中包含報告。

JSON 報告

我們可以建立 Behave JSON 報告。JSON 實際上是一個格式化程式。

讓我們執行一個包含兩個特性檔案的測試，測試結果如下：

上述測試的專案資料夾結構如下：

步驟 1 - 執行命令

要在控制檯中建立 JSON 輸出，請執行以下命令：

behave -f json

將出現以下螢幕：

步驟 2 - 以易於閱讀的格式輸出

要以更易於閱讀的格式建立 JSON 輸出，請執行以下命令：

behave -f json.pretty

下面圖片中捕獲了部分輸出：

步驟 3 - 將報告生成到特定資料夾

要將報告生成到特定資料夾（例如 my_reports.json），我們必須執行以下命令：

behave –f json.pretty –o my_reports.json

下圖顯示了您計算機上將出現的螢幕。

專案中會生成一個名為 my_reports.json 的資料夾，其中包含所有已執行功能的詳細資訊。

Allure 報告

要在 Behave 中生成 Allure 報告，我們首先必須在系統中安裝 Allure。要在 Linux 的命令列中進行安裝，請按順序執行以下命令：

sudo apt-add-repository ppa:qameta/allure
sudo apt-get update
sudo apt-get install allure

對於 Mac 使用者，可以使用 Homebrew 透過以下命令進行安裝：

brew install allure

對於 Windows，Allure 透過 Scoop 安裝程式安裝。執行以下命令下載並安裝 Scoop，最後在 PowerShell 中執行：

scoop install allure

要更新 Scoop 中 Allure 發行版的安裝，請從 Scoop 的安裝目錄執行以下命令：

\bin\checkver.ps1 allure -u

最後，執行以下命令：

scoop update allure

安裝 Allure 後，我們必須獲取 Python 的 Allure-Behave 整合外掛。為此，請執行以下命令：

pip install allure-behave

要驗證 Allure 是否已成功安裝，請執行以下命令：

allure

讓我們執行一個包含兩個特性檔案的測試，測試結果如下：

上述測試的專案資料夾結構如下：

步驟 1 - 將報告生成到特定資料夾

要將報告生成到特定資料夾（例如 my_allure），我們必須執行以下命令：

behave -f allure_behave.formatter:AllureFormatter –o my_allure

您將看到如下所示的螢幕：

專案中會生成一個名為 my_allure 的資料夾，其中包含副檔名為 .json 的檔案。

步驟 2 - 啟動 Web 伺服器

要啟動 Web 伺服器，請執行以下命令：

allure serve my_allure

這裡，my_allure 是包含 allure json 檔案的目錄。

同時，瀏覽器會開啟，顯示如下所示的 Allure 報告：

我們還可以點選單個功能並找到它們的細分，如下所示：

Behave - 鉤子

Behave 的 setup 和 teardown 函式在一個名為 environment.py 的檔案中實現，該檔案與包含 steps 資料夾的同一目錄中。

setup 函式包括：開啟瀏覽器、資料庫連線、配置等等。

teardown 函式包括：關閉瀏覽器、終止資料庫連線、撤銷更改等等。

environment.py 檔案包含以下函式：
before_feature(context, feature) - 在每個功能之前執行。
before_scenario(context, scenario) - 在每個場景之前執行。
before_step(context, step) - 在每個步驟之前執行。
before_tag(context, tag) - 在每個標籤之前執行。
before_all(context) - 在所有內容之前執行。
after_feature(context, feature) - 在每個功能之後執行。
after_scenario(context, scenario) - 在每個場景之後執行。
after_step(context, step) - 在每個步驟之後執行。
after_tag(context, tag) - 在每個標籤之後執行。

after_all(context) - 在所有內容之後執行。

以上函式用作 Behave 中的鉤子。專案結構應如下所示：

包含鉤子的 Feature 檔案 (Payment.feature)

Feature − Payment Process
Scenario − Verify transactions
         Given user makes a payment of 100 INR And user makes a payment of 10 Dollar

包含 Payment.feature 鉤子的 feature 檔案如下：

包含鉤子的 Feature 檔案 (Payment1.feature)

Feature − Administration Process
Scenario − Verify admin transactions
         Given user is on admin screen

包含 Payment1.feature 鉤子的 feature 檔案如下：

步驟實現檔案如下所示：

from behave import *
from parse_type import TypeBuilder
parse_amt = TypeBuilder.make_choice(["100", "10"])
register_type(Amt=parse_amt)
parse_curr = TypeBuilder.make_choice(["INR", "Dollar"])
register_type(Curn=parse_curr)
@given("user makes a payment of {n:Amt} {t:Curn}")
def step_payment(context, n, t):
   pass
@given('user is on admin screen')
def step_admin(context):
   pass

相應的步驟實現檔案

步驟 4 - environment.py 檔案中的鉤子

# before all
def before_all(context):
   print('Before all executed')
# before every scenario
def before_scenario(scenario, context):
   print('Before scenario executed')
# after every feature
def after_feature(scenario, context):
   print('After feature executed')
# after all
def after_all(context):
   print('After all executed')

輸出

environment.py 檔案中的鉤子如下：

Behave - 除錯

執行 feature 檔案後獲得的輸出如下：

可以透過預執行測試步驟來除錯 Behave 指令碼。預執行有助於檢查所有測試步驟，而無需實際執行。它有助於確定步驟定義檔案中的未定義步驟。

它驗證是否存在任何缺少的匯入語句、語法錯誤等等。透過預執行，所有這些問題都會很快被檢測到。如果我們正在進行批次更新或任何配置更改，預執行有助於在短時間內檢測任何錯誤。

behave --no-capture --dry-run

您將看到如下所示的螢幕：

如果我們必須執行整個套件進行除錯，那將非常耗時。在 Behave 中，我們可以透過以下命令進行預執行除錯：

輸出顯示 3 個未測試，顯示測試步驟的數量。

讓我們預執行包含未實現步驟的 feature 檔案，如下所示：

輸出清楚地定義了透過預執行獲得的步驟定義檔案中的未定義步驟。

列印頁面