Python Behave框架学习

behave是python语言的行为驱动开发，全称：Behavior-driven development，简称BDD。

它是一种敏捷软件开发技术，它鼓励软件项目中的开发人员、QA和非技术或业务参与者之间进行协作。

python behave的官方网址：

https://behave.readthedocs.io/en/latest/gherkin.html#gherkin-feature-testing-language

最初由Dan North命名，并于2009年对BDD给出了如下定义：
“BDD是第二代、由外而内、基于拉动、多利益相关者、多规模、高度自动化、敏捷的方法。

它描述了一个与定义明确的输出交互的循环，从而交付了重要的工作、测试软件。”

BDD并不会描述或定义软件怎么做，而是能做了什么。最终通过python代码进行验证。

首先用pycharm创建项目Python-Behave，python环境选择Virtualenv，接着安装behave包。

在项目Python-Behave下创建一个名为“features”的目录（这个目录名称是随意的），可以在这个目录下定义所有behave的文件结构。

在features目录下创建一个“.feature”文件，这是一种叫作“Gherkin”的语言。它对非技术人员比较友好，可以使用自然语言编写。

“.feature”文件有两个用途：文档和自动化测试。一句话，在“.feature”里编写测试场景。

很多文章提到Gherkin语言必须用pycharm专业版才能编写，但是我亲测用pycharm社区版也是可以编写的。

“.feature”文件的结构：

主体由多个场景Scenario组成，可以选用Background和tag进行约束。

feature文件的一个基本的结构为：

Feature: feature name

  Scenario: some scenario
    Given some condition
     When some operation
     Then some result is expected  

• Feature是功能名称

• Scenario是场景描述

• Given是此场景下的前提条件

• When是此场景下的操作步骤

• Then是此场景下的预期结果

如果有多个测试场景呢，就再加一个Scenario。如果Scenario下的Given/When/Then有多个呢？

可以用And或But表示。

所以

Scenario: Multiple Givens
  Given one thing
  Given another thing
  Given yet another thing
   When I open my eyes
   Then I see something
   Then I don't see something else  

也可以这样写作

Scenario: Multiple Givens
  Given one thing
    And another thing
    And yet another thing
   When I open my eyes
   Then I see something
    But I don't see something else  

这种方式阅读会更流畅

当然，上面只是一个简单的feature结构，更复杂一点的，比如说这样：

@tags @tag
Feature: feature name
  description
  further description

  Background: some requirement of this test
    Given some setup condition
      And some other setup action

  Scenario: some scenario
      Given some condition
       When some action is taken
       Then some result is expected.

  Scenario: some other scenario
      Given some other condition
       When some action is taken
       Then some other result is expected.

  Scenario: ...  

Background由一系列类似于Scenario的步骤组成，它的目的是为Scenario添加上下文，在Scenario执行之前执行Background，用于设置Scenario的前提条件。

Scenario由一系列步骤组成，它描述了Feature的一种场景。如果一种场景有多种情况呢？

比如登录这个Scenario，不同的登录名和密码，登录的结果不同。这种情况可以不需要写多个Scenario描述，可以使用Scenario Outline和Examples来完成。

Scenario Outline: Blenders
   Given I put <thing> in a blender,
    when I switch the blender on
    then it should transform into <other thing>

 Examples: Amphibians
   | thing         | other thing |
   | Red Tree Frog | mush        |

 Examples: Consumer Electronics
   | thing         | other thing |
   | iPhone        | toxic waste |
   | Galaxy Nexus  | toxic waste |  

在上面这个例子中，用Scenario Outline描述“Blenders”场景，用多个Examples表示场景的多种类型，每个Examples下可以包含多种情况。不同情况的列举在Scenario Outline用符号“<key>”表示，在Examples中用key列举

Scenario由一系列步骤组成，步骤由关键字“Given”、“When”、“Then”、“And”、“But”为开头。Python Behave实际运行的也是这些步骤。

具体实现是通过此项目下的steps目录里的“.py”文件实现所有的Scenario的步骤。这里要注意，steps目录名是确定的不能改变的，但是里面的py文件名是随意的。

python behave项目的执行方式也并不是通过运行steps目录里的py文件，而是通过命名behave调用“.feature”文件，映射到py文件里的步骤下的函数，执行这些函数。

步骤描述要尽量简洁，但有时会附带一些文本text或表格table。如果python代码需要使用这些text或table，则可以通过访问属性“context.text”或”context.table“来使用。

Text：

Scenario: some scenario
  Given a sample text loaded into the frobulator
     """
     Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
     eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut
     enim ad minim veniam, quis nostrud exercitation ullamco laboris
     nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in
     reprehenderit in voluptate velit esse cillum dolore eu fugiat
     nulla pariatur. Excepteur sint occaecat cupidatat non proident,
     sunt in culpa qui officia deserunt mollit anim id est laborum.
     """
 When we activate the frobulator
 Then we will find it similar to English  

Table：

 Scenario: some scenario
  Given a set of specific users
     | name      | department  |
     | Barry     | Beer Cans   |
     | Pudey     | Silly Walks |
     | Two-Lumps | Silly Walks |

 When we count the number of people in each department
 Then we will find two people in "Silly Walks"
  But we will find one person in "Beer Cans"  

Python中访问：

@given('a set of specific users')
def step_impl(context):
    for row in context.table:
        model.add_user(name=row['name'], department=row['department'])  

这个表格在python中是这样的数据类型：

[{"name":"Barry", "department":"Beer Cans"},{"name":"Pudey", "department":"Silly Walks"},{"name":"Two-Lumps", "department":"Silly Walks"}]  

认真体会下！！！

Tags：

tags用于标记Feature、Scenario或Scenario Outlook，可以选择性的只执行被标记的。

例如：

Feature: Fight or flight
  In order to increase the ninja survival rate,
  As a ninja commander
  I want my ninjas to decide whether to take on an
  opponent based on their skill levels

@slow
Scenario: Weaker opponent
  Given the ninja has a third level black-belt
  When attacked by a samurai
  Then the ninja should engage the opponent

Scenario: Stronger opponent
  Given the ninja has a third level black-belt
  When attacked by Chuck Norris
  Then the ninja should run for his life  

如果只想执行Scenario: Weaker opponent，可以对它进行标记为@slow，然后运行“behave --tags=slow”。

如果想执行除标记@slow外的其他场景，可以运行“behave --tags=“not slow””。

组合使用tags标签：

–tags=“wip or slow”，选择所有标记为wip或slow的case

–tags=“wip and slow”，选择所有标记为wip和slow的case

以上讲的是如何用“.feature”文件编写所有测试场景。虽然是通过命令behave xxx.feature触发，但实际的执行操作是在steps目录下的“.py”实现。

所以，要如何把“.feature”里的所有步骤映射到“.py”中，还必须按照顺序不能出错，这就成为了一个关键。

假设给定一个Senario：

Scenario: Search for an account
   Given I search for a valid account
    Then I will see the account details  

记住，只对所有的步骤按顺序实现，并不会对Scenario进行映射。

在python中实现如下：

@given('I search for a valid account')
def step_impl(context):
    context.browser.get('http://localhost:8000/index')
    form = get_element(context.browser, tag='form')
    get_element(form, name="msisdn").send_keys('61415551234')
    form.submit()

@then('I will see the account details')
def step_impl(context):
    elements = find_elements(context.browser, id='no-account')
    eq_(elements, [], 'account not found')
    h = get_element(context.browser, id='account-head')
    ok_(h.text.startswith("Account 61415551234"),
        'Heading %r has wrong text' % h.text)  

按照“.feature”中的步骤的顺序，将步骤的前面的关键字，在python中用装饰器匹配（@give、@when、@then），()里面是步骤描述。

如果是And或But，在python中用它们被重命名以前的关键字。也就是说，在python中，不可能有@and或@but。

然后在装饰器下方定义函数，函数名随意。函数体就是步骤的具体实现。

如果你想在某个步骤里执行另一个步骤，只需要用context对象调用execute_steps()函数，里面传入被调用步骤。

@when('I do the same thing as before')
def step_impl(context):
    context.execute_steps('''
        when I press the big red button
         and I duck
    ''')  

如果你想把“.feature”的步骤上的信息传递到“.py”中，可以在py文件中用中括号加关键字表示“{key}”。

比如访问百度首页：

Scenario: 访问百度网页
    Given: 打开网页
    When: 输入网址www.baidu.com
    Then：显示百度首页  

关于其中输入百度网址，在python中就可以这样实现：

@when(输入网址{baidu})
def step_imp1(context, baidu):
    context.driver.get(baidu)  

Context：

聪明的你一定注意到了，在py文件中每个步骤下的函数内第一个参数是context，它是Feature或Scenario的实例化，可以用来传递信息。

如何传递呢，这里我们暂且按下不表，先思考一个问题。

如果我有一个场景，打开百度网页，输入关键字搜索，然后查看搜索结果。

在feature文件中如何描述，这个我们应该已经学会了。在py文件中如何实现，我们也不陌生了。

Scenario: 打开百度网页并输入关键字
    Given: 打开百度网页http://www.baidu.com
    When: 输入关键字大美女
    Then：验证返回的搜索结果标题是大美女_百度搜索  

@given(打开百度网页{baidu})
def step_imp1(context, baidu):
    context.driver.get(baidu)  

@when(输入关键字{keyword})
def step_imp1(context, keyword):
    context.driver.find_element_by_xpath('//*[@id="kw"]').send_keys(keyword)
    ...  

后面我就不写了。现在只看given的步骤，你应该就能发现问题，context.driver哪来的，从已知的上下文中并没有相关信息。

如果你再仔细的思考一下，就会发现这里少了一步，我们在打开百度网站前，是不是应该先打开浏览器，然后才是输入百度网址。

如果你有多个关于网页搜索的场景，你是不是应该每次执行Scenario前都要打开浏览器，执行完毕关闭浏览器。这个操作类似于python unittester中的setup()和teardown()的用法。

那python behave框架中，对于操作前和操作后的前置条件和后置条件，是放在了“environment.py”文件中定义。

它有以下几种：

• before_step(context, step)和after_step(context, step)，每一步之前和之后运行
• before_scenario(context, scenario)和after_scenario(context, scenario)，每个场景运行之前和之后运行
• before_feature(context, feature)和after_feature(context, feature)，每个feature文件执行之前和之后运行
• before_tag(context, tag)和after_tag(context, tag)，每个标签调用之前和之后运行
• before_all(context)和after_all(context)，整个behave之前和之后运行

那上面的例子中，在environment.py中实现打开和关闭浏览器的操作，要这样实现：

# environment.py
from selenium import webdriver

def before_scenario(context, scenario):
    context.driver = webdriver.Chrome(r"/usr/local/bin/chromedriver")

def after_scenario(context, scenario):
    context.driver.close()  

前置条件和后置条件在environment.py中用上面列举的函数直接定义，函数名和形参必须符合规范。

可以看出，如果environment.py中的信息、变量或对象需要在steps中的py文件中被使用，可以用context来存储。

这里就把打开的浏览器对象赋值给了context下定义的driver属性，然后在py文件中直接可以使用context.driver，就相当于使用这个浏览器了。

注意注意，environment.py文件在python behave项目中的位置是哪里？是steps目录中吗？

不是的，environment.py文件是和“.feature”文件、steps目录并列在同一目录下的。而且它的名称必须是environment.py。

现在回头看下一个完整的python behave项目的最低结构要求：

+--features/
|   +--steps/       # -- Steps directory
|   |    +-- *.py   # -- Step implementation or use step-library python files.
|   +-- *.feature   # -- Feature files.  

更复杂的目录为：

+-- features/
|     +-- steps/
|     |    +-- website_steps.py
|     |    +-- utils.py
|     |
|     +-- environment.py      # -- Environment file with behave hooks, etc.
|     +-- signup.feature
|     +-- login.feature
|     +-- account_details.feature  

最后，如何执行behave的程序？

不是执行的steps目录里的py文件，而是通过cmd打开命令行窗口，执行：“behave xxx.feature”。

这样也很麻烦，有没有一种方式可以在py文件的主入口里执行"behave xxx.feature"，这样可以封装成exe程序，双击运行exe，即可运行behave。

在python behave项目目录下创建一个py文件（也就是和feature文件、steps目录文件在同一级下），命名为main.py，然后写一个主入口程序：

# main.py
from behave.__main__ import main as behave_main
import os

if __name__ == "__main__":
    # 获取main.py的当前目录
    featurefile_dir = os.path.dirname(os.path.realpath(__file__))
    # 获取feature文件的绝对路径
    featurefile_path = os.path.join(featurefile_dir, "Behave.feature")
    # 用behave.__main__下的main函数，传入feature文件路径，实现behave xxx.feature相同的效果
    # 但是这里有个主要点，传入feature文件的路径不能是以这样“\”或这样“\\”的表示方式，必须要改成这种“/”
    featurefile_path = featurefile_path.replace("\\", "/")
    behave_main(featurefile_path)
    # 或者你不转成“\”，那么你就不能直接传入feature文件路径了，必须把文件路径放入一个list中，然后把list传入
    # 如果你传入list，相当于传入多个参数，这时候除了文件路径，还可以传入tags参数，以执行标记的功能或场景
    cmd_order = []
    cmd_order.append(featurefile_path) # 把feature文件路径添加为list的第一个元素
    cmd_order.append("-t @slow") # 把tag标签添加为list的第二个元素
    behave_main(cmd_order) # 传入参数列表  

---