Behave - 快速指南

Behave - 简介

Behave是Python编程语言中用于Behave驱动开发（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安装可以通过以下方式完成 -

带点

对于 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 安装。

要安装安装工具，请运行下面提到的命令 -

pip install setuptools

现在，对于 Behave 安装，请运行以下命令：

easy_install behave

我们可以使用下面给出的命令更新现有版本的Behave：

easy_install –U behave

与源分布

解压 Behave 源代码发行版后，输入新生成的目录“behave-<version>”并执行下面提到的命令 -

python setup.py install

使用 Git 存储库

我们首先应该在系统中安装 pip。

稍后，要安装最新版本的 Behave with Git 存储库，请运行下面提到的命令 -

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

如果我们使用PyCharm 编辑器编写 Behave 代码，我们应该安装 PyCharm 的专业版以及与其一起安装的 Gherkin 插件。

Behave - 命令行

Behave 有一组命令行参数，也可以从配置文件中概述。配置文件中设置的值会自动使用，但是，它可以被命令行参数推翻。

命令行参数

让我们讨论一些命令行参数 -

–c, --无颜色

损害 ANSI 颜色转义的使用。

- 颜色 -

利用 ANSI 颜色转义。这是一个内置特征，可以推翻配置文件中的设置。

–d, --试运行

调用格式化程序而不运行步骤。

-D，--定义

声明 config.userdata 字典的自定义信息。

–e, --排除模式

从执行中排除与正则表达式模式相同的特征文件。

–i, --include 模式

包括在执行期间与正则表达式模式相同的特征文件。

--无junit

省略 JUnit 报告作为输出。

--junit

添加 JUnit 报告作为输出。当 JUnit 打开时，每个 stdout 和 stderr 将成为 junit 报告的一部分。（无论 -capture/-no-capture 选项如何）。

–f，--格式

定义一个格式化程序。如果省略，则使用内置格式化程序。–format-help 命令应显示所有可用的格式。

显示所有现有步骤定义的目录。

–k, --不跳过

从控制台中的打印中排除跳过的步骤。

无片段

从控制台中打印的步骤中排除片段，这些步骤仍未实现。

--片段

包括片段，同时在控制台中打印尚未实施的步骤。这是一个内置特征，可以推翻配置文件设置。

–m, --no-多行

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

--多行

在步骤下包含多行表和字符串。这是一个内置特征，可以推翻配置文件设置。

–n，--名称

包括与运行中指定名称相同的功能元素。如果多次提供该选项，则它应与所有名称匹配。

--不捕获

从捕获中排除标准输出。

- 捕获

包括标准输出。这是一个内置特征，可以推翻配置文件设置。

--无捕获标准错误

从捕获中排除 stderr。

--捕获标准错误

包括标准错误。这是一个内置特征，可以推翻配置文件设置。

--无日志捕获

从捕获中排除日志。

--日志捕获

包括日志捕获。在失败期间，步骤的每个日志都将存在并可用。这是一个内置特征，可以推翻配置文件设置。

--日志记录级别

提及应捕获的日志记录级别。默认值为信息。

--日志记录格式

提及打印报表的用户定义格式。默认值为%(levelname)s:%(name)s:%(message)s。

--logging-datefmt

提及打印报表的用户定义的日期和时间格式。

--日志记录过滤器

提及是否要过滤语句。默认情况下捕获所有语句。如果输出太长，我们可以利用该选项过滤掉不必要的输出。

--日志记录清除处理程序

删除所有用于日志记录的处理程序。

--无摘要

排除执行后的摘要。

-概括

包括执行后的摘要。

–o, --outfile

写入给定的文件而不是使用标准输出。

–q，--安静

别名用于 –no-snippets –no-source。

–s, --无源

排除打印文件和步骤定义行以及步骤。

--显示源

包括打印文件和步骤定义行以及步骤。这是一个内置特征，可以推翻配置文件设置。

- 阶段

描述测试的当前阶段。阶段名称用作环境文件的名称前缀，以及步骤的目录。

- 停止

遇到第一次失败后终止执行测试。

–t、--标签

包含具有标签的功能/场景，这些标签与执行中的 TAG_EXPRESSION 相同。

–T, --无计时

排除打印每个步骤的执行持续时间。

--显示时间

在控制台中捕获每个步骤完成所需的持续时间（以秒为单位）。这是一个内置特征，可以推翻配置文件设置。

–v，--详细

显示加载的功能和文件。

–w, --wip

执行具有 wip 标签的场景。此外，我们必须使用普通格式化程序，而不是记录标准输出或日志输出，并在第一次失败后终止。

–x，--展开

展平输出中的场景大纲表。

--郎

使用英语以外的语言的关键字。

--语言列表

显示 –lang 中存在的所有语言。

--lang-帮助

显示为单一语言获取的所有翻译。

--标签帮助

显示标签语句的帮助。

- 版本

显示版本。

这是存储 Junit 报告的目录位置。

--跳过显示

包括在控制台中打印时跳过的步骤。这是一个内置特征，可以推翻配置文件设置。

Behave - 配置文件

Behave配置文件称为.behaverc / behave.ini / setup.cfg / tox.ini（任何一个，并根据用户选择进行设置）。

这些文件可以位于以下位置 -

当前的工作目录。
用户主目录。
对于 Windows 用户，位于目录 %APPDATA% 中。

命令behavior –v，应显示所有配置详细信息。配置文件应以关键字 [behave] 开头，并遵循 Windows INI 样式格式。

例如，

[behave]
format = plain
dry_run = false

参数类型

Behave 中的配置参数类型包括以下内容 -

文本- 为配置设置分配文本。
Bool - 为配置设置分配布尔值。文本定义Behave（真值包括 1、true、yes 和 on）。false 值包括 0、false、no 和 off）。
Sequence<text> - 在新行上接受多个值。

例如，标签表达式可以如下 -

tags=@a, ~@b
         @c

这相当于以下标签表达式 -

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

配置参数

Behave 中的一些配置参数解释如下 -

颜色 - 布尔值

利用 ANSI 颜色转义。这是一个内置特征，可以推翻配置文件中的设置。

dry_run - 布尔值

调用格式化程序而不运行这些步骤。

userdata_defines - 序列<文本>

声明 config.userdata 字典的自定义数据。

except_re - 文本

从执行中排除与正则表达式模式相同的特征文件。

include_re - 文本

在执行过程中包含与正则表达式模式相同的特征文件。

Junit - 布尔

添加 JUnit 报告作为输出。当 JUnit 打开时，每个 stdout 和 stderr 将成为 junit 报告的一部分。（无论 -capture/-no-capture 选项如何）。

junit_directory - 文本

这是存储 JUnit 报告的目录位置。

默认格式 - 文本

声明默认格式化程序。默认值很漂亮。

格式：序列<文本>

定义一个格式化程序。如果省略，则使用内置格式化程序。–format-help 命令应显示所有可用的格式。

显示所有现有步骤定义的目录。

scene_outline_annotation_schema：文本

提及场景大纲的注释模式。

show_skipped - 布尔值

包括在控制台中打印时跳过的步骤。这是一个内置特征，可以推翻配置文件设置。

show_snippets - 布尔

在控制台中打印步骤时包含片段，但这些步骤尚未实现。这是一个内置特征，可以推翻配置文件设置。

show_multiline - 布尔

在步骤下包含多行表和字符串。这是一个内置特征，可以推翻配置文件设置。

名称 - 序列<文本>

包括与运行中指定名称相同的功能元素。如果多次提供该选项，则它应匹配所有指定的名称。

stdout_capture - 布尔

包括标准输出。这是一个内置特征，可以推翻配置文件设置。

stderr_capture - 布尔

包括标准错误。这是一个内置特征，可以推翻配置文件设置。

log_capture - 布尔值

包括日志捕获。在失败期间，步骤的每个日志都将存在并可用。这是一个内置特征，可以推翻配置文件设置。

logging_level - 文本

提及要捕获的日志记录级别。默认值为信息。

logging_format - 文本

提及打印报表的用户定义格式。默认值为%(levelname)s:%(name)s:%(message)s。

logging_datefmt - 文本

提及用于打印报表的用户定义的日期和时间格式。

logging_filter - 文本

提及要过滤的语句。默认情况下捕获所有语句。如果输出太长，我们可以利用该选项过滤掉不必要的输出。

logging_clear_handlers : 布尔

删除所有用于日志记录的处理程序。

摘要 - 布尔

包括执行后的摘要。

输出文件-序列<文本>

写入给定的文件而不是使用标准输出。

路径 - 序列<文本>

提及功能文件的默认路径。

安静 - 布尔

别名用于 –no-snippets –no-source。

显示源 - 布尔

包括打印文件和步骤定义行以及步骤。这是一个内置特征，可以推翻配置文件设置。

舞台 - 文本

描述测试的当前阶段。阶段名称用作环境文件的名称前缀以及步骤的目录。

停止 - 布尔

遇到第一次失败后终止执行测试。

标签 - 序列<文本>

在执行中包含具有与 TAG_EXPRESSION 相同的标签的功能/场景。

default_tags - 文本

如果未给出默认标签，请声明它们。

show_timings - 布尔

在控制台中捕获每个步骤完成所需的持续时间（以秒为单位）。这是一个内置特征，可以推翻配置文件设置。

详细 - 布尔

显示加载的功能和文件。

在制品 - 布尔

执行具有 wip 标签的场景。此外，我们必须使用普通格式化程序，而不是记录标准输出或日志输出，并在第一次失败后终止。

展开 - 布尔

展平输出中的场景大纲表。

语言 - 文本

使用英语以外的语言的关键字。

Behave - 功能测试设置

Behave 适用于三种不同的文件类型，如下所示 -

由业务分析师或任何项目利益相关者创建的功能文件，包含与Behave相关的用例。
步骤功能文件中定义的场景的实施文件。
环境设置文件，其中要先执行前置/后置条件，然后执行步骤、功能、场景等。

特征文件

功能文件应位于称为功能的文件夹中。另外，features 目录中应该有一个子目录steps。

启动功能文件

我们可以使用各种命令行参数启动功能文件。这些解释如下 -

如果没有可用信息，则应加载 features 目录中的所有功能文件以在 Behave 中执行。
如果提供了features目录的路径，则features目录中必须至少有一个feature文件（扩展名为.feature）和一个名为steps的子目录。
另外，如果environment.py存在，它应该位于具有steps目录的目录中，而不是位于steps目录中。
如果提供了功能文件的路径，则它指示 Behave 搜索它。要获取该功能文件的相应步骤目录，请搜索父目录。
如果在当前父目录中找不到，则会搜索其父目录。这将继续，直到到达文件系统根目录。另外，如果environment.py存在，它应该位于具有steps目录的目录中，而不是位于steps目录中。

Behave - 小Cucumber关键词

Behave 中的 Gherkin 关键字如下 -

特征
设想
脚步
背景
场景概要
文本
桌子
标签
给定
什么时候
然后
但
和

功能文件是用 Gherkin 语言编写的。它采用纯文本形式，由团队的非技术成员（业务分析师）创建。功能文件可用于自动化测试和文档编制。

行结束完成语句包含在 Behave 中。我们可以使用制表符/空格来缩进。大多数行都以 Scenario、Given、Then 等关键字开头。可以将注释添加到文件内的任何位置。它们以/不带空格开头，后跟 # 符号和文本。

让我们讨论一些关键的 Gherkin 关键字。

特征

功能由场景组成。它们可能/可能不包含描述、背景和一组标签。

特征文件的结构如下 -

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

功能的名称应该包含正在测试的功能的描述。然而，冗长的描述不是强制性的，添加描述只是为了消除功能名称中的歧义。

背景

添加背景以具有一组步骤。它接近于一个场景。我们可以通过背景为多个场景添加上下文。它在功能的每个场景之前运行，但在 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

设想

场景定义了正在测试的应用程序的Behave。它有一个标题来描述其目标。可以添加其描述以提高人类可读性。

一个场景可能有多个步骤，这些步骤以关键字“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 关键字的功能文件如下 -

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

例子

以下是带有场景大纲的功能文件示例 -

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

使用不同的参数集执行相同的测试。

给定

以关键字 Give 开头的步骤用于在用户与系统交互之前将系统置于熟悉的环境中（类似于前提条件）。建议不要在给定步骤中描述用户操作。

可以添加给定步骤来设置数据库中的配置、登录应用程序等。

带有给定的特征文件

带有给定关键字的功能文件如下 -

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 关键字的功能文件如下 -

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 的特征文件

带有 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

但是

如果我们有多个 Give、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

步骤数据 – 表格

步骤可以具有与其关联的文本和数据表。我们可以添加一个带有步骤的数据表。建议表数据缩进，并且每行必须具有相同的列号。

列数据应该用 | 分隔象征。

带表的特征文件

带有 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

实现 Python 代码可以通过上下文变量（在步骤函数中传递）中的 .table 属性来访问表。表是表的一个实例。

Table的实现逻辑

下面给出的是 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'])

步骤数据 – 文本

用“””括起来的步骤后面的文本块将与该步骤链接。这里，缩进被解析。开头的所有空格都将从文本中删除。此外，所有后续行必须至少有一个最小空格作为起始行。

实现 Python 代码可以使用上下文变量中的 .text 属性（在步骤函数中传递）来访问文本。

带有文本的特征文件

带有文本关键字的功能文件如下 -

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

Behave - 功能文件

如前所述，Behave 适用于三种不同的文件类型。这些文件如下 -

由业务分析师或任何项目利益相关者创建的功能文件，包含与Behave相关的用例。
步骤功能文件中定义的场景的实施文件。
环境设置文件，其中要在步骤、功能、场景等之前和之后执行前置/后置条件。

功能文件应位于称为功能的文件夹中。另外，features 目录中应该有一个子目录steps。

您的计算机上将出现以下屏幕 -

启动功能文件

我们可以使用各种命令行参数启动功能文件，如下所述 -

如果没有可用信息，则应加载 features 目录中的所有特征文件以在 Behave 中执行。
如果提供了features目录的路径，则features目录中必须至少有一个feature文件（扩展名为.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 扩展名），应位于步骤目录中。

所有必需的导入都存在于该文件中。步骤目录应该是功能目录的一部分。

您的计算机上将出现以下屏幕 -

步骤定义文件包含定义特征文件中的步骤的 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')

项目结构

“付款类型”功能的项目结构如下 -

输出

运行feature文件后得到的输出如下所示，这里使用的命令是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))

输出

运行功能文件后获得的输出如下，使用的命令是beeve --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。

输出显示登录用户名：user1、登录密码：pwd1 和登录用户名：user2、登录密码：pwd2。这里，两个数据集来自示例。

Behave - 多行文本

用“””括起来的步骤之后的文本块将与该步骤链接。这里，缩进被解析。开头的所有空格都将从文本中删除，并且所有后续行必须至少具有最小空格，如下所示起跑线。

实现 Python 代码可以使用上下文变量中的 .text 属性（在步骤函数中传递）来访问文本。

特征文件

标题为“用户信息”的功能的功能文件如下 -

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

实现 Python 代码可以通过上下文变量（在步骤函数中传递）中的 .table 属性来访问表。表是表的一个实例。我们可以使用设置表来方便设置测试。

Python代码

访问表的Python代码。(login_module.py)如下 -

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工程中该文件设置的工程如下

输出

运行功能文件后获得的输出如下所示，使用的命令是beeve --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')

输出

运行功能文件后获得的输出如下所示，使用的命令是beeve --no-capture -f plain。

连续输出如下 -

输出显示场景验证的新用户可以通过执行场景验证新用户可以处理付款的步骤来处理付款。

Behave - 背景

后台一般用于执行登录场景或者数据库连接等前置条件。

可以添加背景描述以提高人类可读性。它只能在功能文件中出现一次，并且必须在场景或场景大纲之前声明。

不应使用背景来创建复杂状态（仅当无法避免时）。这一部分应该简短而真实。此外，我们应该避免在一个特性文件中包含大量场景。

带背景的特征文件

标题为付款流程的功能的背景功能文件如下 -

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。

连续输出如下 -

输出显示后台步骤（给定启动应用程序然后输入凭据）在每个场景之前运行两次。

Behave - 数据类型

Behave中有两种类型的数据类型，即预定义的和用户定义的。让我们首先了解什么是预定义的数据类型。

预定义数据类型

Behave 使用解析模块来解析步骤定义中的参数。让我们探讨一些支持步骤定义且不需要像用户定义数据类型那样注册的解析类型。

w（str 类型）- 下划线和字母。
W（str 类型）- 下划线和非字母。
s（str 类型）- 空白。
S（str 类型）- 非空白。
d（int 类型）- 数字。
D（str 类型）- 非数字。
n（int 类型）- 具有千位分隔符的数字。
%（浮点类型）- 百分比。（转换为值/100.0）
f（浮点型） - 固定 - 点数。
e (float 类型) - 浮点 - 点数和指数。
g（浮点类型）- 数字格式。
b（int 类型）- 二进制数字。
（int 类型）- 八进制数字。
x（int 类型）- 十六进制数字。
ti（日期时间类型）- ISO 8601 日期/时间格式的时间。
te（日期时间类型）- RFC 2822 电子邮件数据/时间格式的时间。
tg（日期时间类型）- 全局数据/时间格式的时间。
ta（日期时间类型）- 美国数据/时间格式的时间。
tc（日期时间类型）- ctime() 数据/时间格式。
th (datetime 类型) - 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

要运行标签高的功能并执行所有场景，我们必须运行以下命令 -

behave payment.feature --tags=high

如果运行下面的命令，则表示该命令将执行标记有信用卡支付或借记支付的场景。

behave payment.feature --tags= creditpayment, debitpayment

如果运行下面给出的命令，则意味着该命令将执行标记有信用卡付款和借记付款的场景。

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

如果运行下面提到的命令，则意味着该命令不会执行带有credit payment标签的Scenario。

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):