python webdriver 测试框架-行为驱动例子

安装行为驱动模块lettuce（卷心菜）模块

pip install lettuce

Successfully installed argparse-1.4.0 colorama-0.3.9 extras-1.0.0 fixtures-3.0.0 funcsigs-1.0.2 fuzzywuzzy-0.16.0 lettuce-0.2.23 linecache2-1.0.0 mock-2.0.0 pbr-4.1.0 python-mimeparse-1.6.0 python-subunit-1.3.0 sure-1.4.11 testtools-2.3.0 traceback2-1.4.0 unittest2-1.1.0

官网：http://lettuce.it

下面通过第一个例子来说明行为驱动是做什么的。

第一个例子，解释行为驱动的用法和结构，用的是方法

建一个目录（名称随意），在该目录下新建features目录，在features目录下，建两个文件steps.py和zero.feature

features目录名称是固定的 feature文件的后缀名必须是xxx.feature，也是固定的。

features和features下这两个文件就是行为驱动lettuce的结构，一个是文本文件，用来定义用例是什么，另一个是真正执行用例步骤的脚本

可以对比一下zero.feature里用例的三个关键字语句和steps的三个函数的映射关系，就是一一对应的，一个语句对应一个函数，这就是行为驱动的结构。

总结一下行为驱动：

行为驱动就是通过feature文件里关键字对应的自然语言映射脚本中对应的函数，然后执行steps脚本来执行feature中描述的测试用例。

每一句自然语言的描述都会有一个函数或步骤执行跟它对应，这么做的意义是在执行用例的时候可以看到他在干什么，看他完成了多少需求，因为自然语言中描述的都是需求中定义的东西，行为驱动一般定义在敏捷开发当中，敏捷开发中有数据驱动、行为驱动、验收测试驱动，这就是行为驱动，好处是可以验证需求是否都完成了，可以在开发完成后执行行为驱动用例，把完成的需求按自然语言方式输出出来，都输出了就说明完成了，就是把测试用例和自然语言的需求之间建立一个联系，当他执行通过之后，我就知道我的需求完成了多少，就是做了一个映射的关系，这样需求人员就知道原来我的进度是这样，在写测试用例的时候，需求人员自己就可以写了，把不同的场景写出来就可以了，不用管测试用例的实现，最后执行的时候就知道需求完成了多少，因为只要测试用例跑通过了就认为是成功了，这就是行为驱动的好处，方便非测试、非技术人员对需求进度的了解。

本质就是把自然语言跟你的测试步骤做了一一对应，以此来看进度的完成情况，以及是否通过测试，一般认为通过测试的才认为开发算完成了，在敏捷测试中用的比较多，在一般正常的非敏捷的测试中用的不多。

可以在githun上找源码看一下lettuce怎么实现的。

如何执行测试用例：

到features目录的上层目录中，打开cmd，执行lettuce

绿色代表执行通过，有问题的话会报错。

zero.feature:

#说明功能是干什么的，用的时候把注释都去掉，防止受影响

#Feature，Scenario，Given，When，Then等第一个字母大写的，这些都是关键字，不能变

Feature: Compute factorial#计算阶乘

#备注，描述说明

In order to play with Lettuce

As beginners

We'll implement factorial

#场景1，就是第一个测试用例

Scenario: Factorial of 0#0的阶乘

#下面这三个自然语言的描述都有一个函数跟它对应，执行测试用例的时候可以看他干了什么

#是否正确的执行

#敏捷里也有验收测试驱动，行为驱动，数据驱动

#把测试用例用自然语言的描述和程序有一个映射

Given I have the number 0#如果我有一个数是0

When I compute its factorial#当我计算这个阶乘的时候

Then I see the number 1#计算完了之后，我得到的结果0的阶乘是1

#下面以此类推，原理都是一样的

Scenario: Factorial of 1

Given I have the number 1

When I compute its factorial

Then I see the number 1

Scenario: Factorial of 2

Given I have the number 2

When I compute its factorial

Then I see the number 2

Scenario: Factorial of 3

Given I have the number 3

When I compute its factorial

Then I see the number 6

steps.py:定义方法，实现测试用例

#encoding=utf-8

from lettuce import *

# 用于计算整数的阶乘函数

def factorial(number):#被测试对象，告诉怎么计算阶乘的

number = int(number)

if (number == 0) or (number == 1):

return 1

else:

return reduce(lambda x, y: x * y, range(1, number + 1))#算阶乘的方法，后续自己演练#一下

#可以对比一下zero.feature里用例的三个关键字语句和下面的三个函数的映射关系，就是一#一对应的，一个语句对应一个函数，这就是行为驱动

#下面的@是装饰器的用法，括号里是给装饰器穿的参数

@step('I have the number (\d+)')#跟feature里的Given所指的一样

def have_the_number(step, number):

# 将通过正则表达式匹配的数字存于全局变量world中

# world是lettuce里的命名空间，这命名空间里的所有变量在所有lettuce方法中共用，类似全局变量

#做了一个类型转换

world.number = int(number)#world是lettuce里的命名空间，这空间里的所有变量在所有lettuce里公用

@step('I compute its factorial')#同步features文件，然后用正则

def compute_its_factorial(step):

# 从全局变量world中取出匹配的数字，

# 计算其阶乘，并将结果再存回world中

world.number = factorial(world.number)#把world.number传给函数，返回后又传给自己了

@step('I see the number (\d+)')

def check_number(step, expected):#step对应I see the number ，expected对应分组(\d+)

# 通过正则匹配到预期数字

expected = int(expected)#把字符串转成整形

# 断言计算阶乘结果是否等于预期

assert world.number == expected, "Got %d" %world.number

测试用例的执行：

到features目录的上层目录中，打开cmd，执行lettuce

绿色代表执行通过，有问题的话会报错。

结果：

D:\test\xingweiqudong\practice1>lettuce

c:\python27\lib\site-packages\fuzzywuzzy\fuzz.py:35: UserWarning: Using slow pure-python SequenceMatcher. Install python-Levenshtein to remove this warning

warnings.warn('Using slow pure-python SequenceMatcher. Install python-Levenshtein to remove this warning')

Feature: Compute factorial # \features\zero.feature:1

In order to play with Lettuce # \features\zero.feature:2

As beginners # \features\zero.feature:3

We'll implement factorial # \features\zero.feature:4

Scenario: Factorial of 0 # \features\zero.feature:6

Given I have the number 0 # \features\steps.py:13

When I compute its factorial # \features\steps.py:18

Then I see the number 1 # \features\steps.py:24

Scenario: Factorial of 1 # \features\zero.feature:11

Given I have the number 1 # \features\steps.py:13

When I compute its factorial # \features\steps.py:18

Then I see the number 1 # \features\steps.py:24

Scenario: Factorial of 2 # \features\zero.feature:16

Given I have the number 2 # \features\steps.py:13

When I compute its factorial # \features\steps.py:18

Then I see the number 2 # \features\steps.py:24

Scenario: Factorial of 3 # \features\zero.feature:21

Given I have the number 3 # \features\steps.py:13

When I compute its factorial # \features\steps.py:18

Then I see the number 6 # \features\steps.py:24

1 feature (1 passed)

4 scenarios (4 passed)

12 steps (12 passed)

第二个例子：用类的方式实现

features没有变化和第一个例子一样，steps文件有变化，用类的方式实现

方法就是在类的上边用装饰器@steps来实现

steps.py:

#encoding=utf-8

from lettuce import world, steps

def factorial(number):

number = int(number)

if (number == 0) or (number == 1):

return 1

else:

return reduce(lambda x, y: x * y, range(1, number + 1))

@steps#装饰器，测试步骤类，他的每个方法默认都是一个测试步骤

class FactorialSteps(object):

"""Methods in exclude or starting with _ will not be considered as step"""

exclude = ['set_number', 'get_number']#不作为测试步骤，因为@steps测试步骤类里的方#法都作为测试步骤，所以在这里做一个排除

def __init__(self, environs):

# 初始全局变量

self.environs = environs#实例化后就是一个world，存全局共享变量的对象

def set_number(self, value):#不是步骤

# 设置全局变量中的number变量的值

#设定测试数据

self.environs.number = int(value)#就是world存到了这个实例变量里

def get_number(self):#不是步骤

# 从全局变量中取出number的值

return self.environs.number#取出测试数据

#私有方法默认也不是测试步骤

def _assert_number_is(self, expected, msg="Got %d"):

number = self.get_number()

# 断言取出的数据和期望的数据是否一致

assert number == expected, msg % number

#下边三个都是测试步骤

def have_the_number(self, step, number):

#下边跟自然语言描述是一样的，三句话

'''I have the number (\d+)'''#从feature文件里取出的自然语言的内容

# 上面的三引号引起的代码必须写，并且必须是三引号引起

# 表示从场景步骤中获取需要的数据

# 并将获得数据存到环境变量number中

self.set_number(number)#获取一下测试数据

def i_compute_its_factorial(self, step):

"""When I compute its factorial"""

number = self.get_number()#取出数据

# 调用factorial方法进行阶乘结算，

# 并将结算结果存于全局变量中的number中

self.set_number(factorial(number))#通过测试数据调用被测试方法

def check_number(self, step, expected):

'''I see the number (\d+)'''

# 上面的三引号引起的代码必须写，并且必须是三引号引起

# 表示从场景步骤中获取需要的数据以便断言测试结果

self._assert_number_is(int(expected))#私有方法做一个断言

FactorialSteps(world)#测试类的实例化，world是一个类，lettuce里可以存全局共享变量的对象

Zero.eature:

Feature: Compute factorial

In order to play with Lettuce

As beginners

We'll implement factorial

Scenario: Factorial of 0

Given I have the number 0

When I compute its factorial

Then I see the number 1

Scenario: Factorial of 1

Given I have the number 1

When I compute its factorial

Then I see the number 1

Scenario: Factorial of 2

Given I have the number 2

When I compute its factorial

Then I see the number 2

Scenario: Factorial of 3

Given I have the number 3

When I compute its factorial

Then I see the number 6

结果：

D:\test\xingweiqudong\practice2>lettuce

c:\python27\lib\site-packages\fuzzywuzzy\fuzz.py:35: UserWarning: Using slow pure-python SequenceMatcher. Install python-Levenshtein to remove this warning

warnings.warn('Using slow pure-python SequenceMatcher. Install python-Levenshtein to remove this warning')

Feature: Compute factorial # \features\zero.feature:1

In order to play with Lettuce # \features\zero.feature:2

As beginners # \features\zero.feature:3

We'll implement factorial # \features\zero.feature:4

Scenario: Factorial of 0 # \features\zero.feature:6

Given I have the number 0 # \features\steps.py:35

When I compute its factorial # \features\steps.py:42

Then I see the number 1 # \features\steps.py:49

Scenario: Factorial of 1 # \features\zero.feature:11

Given I have the number 1 # \features\steps.py:35

When I compute its factorial # \features\steps.py:42

Then I see the number 1 # \features\steps.py:49

Scenario: Factorial of 2 # \features\zero.feature:16

Given I have the number 2 # \features\steps.py:35

When I compute its factorial # \features\steps.py:42

Then I see the number 2 # \features\steps.py:49

Scenario: Factorial of 3 # \features\zero.feature:21

Given I have the number 3 # \features\steps.py:35

When I compute its factorial # \features\steps.py:42

Then I see the number 6 # \features\steps.py:49

1 feature (1 passed)

4 scenarios (4 passed)

12 steps (12 passed)

第三个例子：用表格的模式

用表格的模式，用多行数据的时候会用到

核心的原理：表格里的数据是

Student.feature：多了个and关键字

Feature: bill students alphabetically#基于字母来付款

In order to bill students properly

As a financial specialist

I want to bill those which name starts with some letter

Scenario: Bill students which name starts with "G"

#数据表，不同字母开头，付的钱不一样

Given I have the following students in my database:

| name | monthly_due | billed |

| Anton | $ 500 | no |

| Jack | $ 400 | no |

| Gabriel | $ 300 | no |

| Gloria | $ 442.65 | no |

| Ken | $ 907.86 | no |

| Leonard | $ 742.84 | no |

#只想让以G开头的人付款

When I bill names starting with "G"#当我打了一个G

Then I see those billed students:#看到这些人，以G开头的

| name | monthly_due | billed |

| Gabriel | $ 300 | no |

| Gloria | $ 442.65 | no |

And those that weren't:#且不看到这些人（非G开头）的信息

| name | monthly_due | billed |

| Anton | $ 500 | no |

| Jack | $ 400 | no |

| Ken | $ 907.86 | no |

| Leonard | $ 742.84 | no |

step.py:

#encoding=utf-8

from lettuce import *

@step('I have the following students in my database:')#以函数的方式实现的

def students_in_database(step):

if step.hashes:#feature的数据表的内容给读出来

# 如果存在步骤表格数据，则继续后续步骤

print type(step.hashes)

assert step.hashes == [#断言是否和数据表对应，每个{}里的内容和数据表的一行数据对应

{

#每行的数据，表头加值

'name': 'Anton',#每行的数据是一个字典

'monthly_due': '$ 500',

'billed': 'no'

{

'name': 'Jack',

'monthly_due': '$ 400',

'billed': 'no'

{

'name': 'Gabriel',

'monthly_due': '$ 300',

'billed': 'no'

{

'name': 'Gloria',

'monthly_due': '$ 442.65',

'billed': 'no'

{

'name': 'Ken',

'monthly_due': '$ 907.86',

'billed': 'no'

{

'name': 'Leonard',

'monthly_due': '$ 742.84',

'billed': 'no'

]

@step('I bill names starting with "(.*)"')#敲了一个东西，正则.*代表除回车外的任意字符

def match_starting(step, startAlpha):

# 将通过正则表达式匹配步骤中最后一个字母，

# 并存于全局变量startAlpha中

world.startAlpha = startAlpha#给全局变量

#打印了一下取出来的东西，'feature里bill names starting with部分没哈希表

print "no data exist:",step.hashes

@step('I see those billed students:')#要看到需要付款的人，有哈希表

def get_starting_with_G_student(step):

# 遍历步骤数据表中的数据

for i in step.hashes:#遍历哈希表

# 断言学生的名字是否以world.startAlpha变量存取的的字母开头

assert i["name"].startswith(world.startAlpha)#断言每个人的名字是否是以刚才敲的字符开头的

@step("those that weren't:")

def result(step):

for j in step.hashes:#就是feature里those that weren’t部分的数据表/哈希表

# 断言学生名字不以world.startAlpha变量存取的的字母开头

assert world.startAlpha not in j["name"][0]#断言表里每个名字的首字母不是G

结果：

D:\test\xingweiqudong\practice3>lettuce

Feature: bill students alphabetically # \features\student.feature:1

In order to bill students properly # \features\student.feature:2

As a financial specialist # \features\student.feature:3

I want to bill those which name starts with some letter # \features\student.feature:4

Scenario: Bill students which name starts with "G" # \features\student.feature:6

Given I have the following students in my database: # \features\step.py:5

| name | monthly_due | billed |

| Anton | $ 500 | no |

| Jack | $ 400 | no |

| Gabriel | $ 300 | no |

| Gloria | $ 442.65 | no |

| Ken | $ 907.86 | no |

| Leonard | $ 742.84 | no |

When I bill names starting with "G" # \features\step.py:43

Then I see those billed students: # \features\step.py:50

| name | monthly_due | billed |

| Gabriel | $ 300 | no |

| Gloria | $ 442.65 | no |

And those that weren't: # \features\step.py:57

| name | monthly_due | billed |

| Anton | $ 500 | no |

| Jack | $ 400 | no |

| Ken | $ 907.86 | no |

| Leonard | $ 742.84 | no |

1 feature (1 passed)

1 scenario (1 passed)

4 steps (4 passed)

py -3 m pip install lettuce python 3，运行python3

virtual env 虚拟环境，生成独立的沙盒，跟虚拟机一样，生成了一个虚拟的python运行环境

帖子：linux下的

https://blog.csdn.net/u012734441/article/details/55044025/

pycharm里新建项目时，选virtualEnv，安装的python编译环境跟操作系统就完全独立的

window下

https://www.cnblogs.com/ruhai/p/6597280.html

第四个例子，基于webdriver，数据驱动的例子

sogou.feature:

Feature: Search in Sogou website

In order to Search in Sogou website

As a visitor

We'll search the NBA best player

Scenario: Search NBA player

Given I have the english name "<search_name>"#尖括号是保留字，对应Examples下的数据列

When I search it in Sogou website

Then I see the entire name "<search_result>"#尖括号是保留字

Examples:

| search_name | search_result |

| Jordan | Michael |

| Curry | Stephen |

| Kobe | Bryant |

自然语言和测试步骤函数的映射关系，一一对应，方便非测试、非技术人员对需求进度的了解

Examples是关键字

sougou.py:

#encoding=utf-8

from lettuce import *

from selenium import webdriver

import time

@step('I have the english name "(.*)"')

def have_the_searchWord(step, searchWord):

world.searchWord = str(searchWord)

print world.searchWord

@step('I search it in Sogou website')

def search_in_sogou_website(step):

world.driver = webdriver.Firefox(executable_path = "c:\\geckodriver")

world.driver.get("http://www.sogou.com")

world.driver.find_element_by_id("query").send_keys(world.searchWord)#上个方法获取的数据

world.driver.find_element_by_id("stb").click()

time.sleep(3)

@step('I see the entire name "(.*)"')

def check_result_in_sogou(step, searchResult):

assert searchResult in world.driver.page_source, "got word:%s" %searchResult

world.driver.quit()

terrain.py:

#本质是在用例开始的前、后，每个场景之前、后，每个步骤开始之前、后做一些事情

#跟testNG的标签差不多，就是一个框架

#encoding=utf-8

from lettuce import *

import logging

# 初始化日志对象

logging.basicConfig(

# 日志级别

level = logging.INFO,

# 日志格式

# 时间、代码所在文件名、代码行号、日志级别名字、日志信息

format = '%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',

# 打印日志的时间

datefmt = '%a, %Y-%m-%d %H:%M:%S',

# 日志文件存放的目录（目录必须存在）及日志文件名

filename = 'e:/BddDataDriveRreport.log',

# 打开日志文件的方式

filemode = 'w'

)

# 在所有场景执行前执行，只会执行一次

@before.all

def say_hello():

logging.info("Lettuce will start to run tests right now...")

print "Lettuce will start to run tests right now..."

# 在每个secnario开始执行前执行

@before.each_scenario

def setup_some_scenario(scenario):

# 每个Scenario开始前，打印场景的名字

print 'Begin to execute scenario name:' + scenario.name

# 将开始执行的场景信息打印到日志

logging.info('Begin to execute scenario name:' + scenario.name)

# 每个step开始前执行，每执行一步就打印一次

@before.each_step#固定写法

def setup_some_step(step):

run = "running step %r, defined at %s" % (

step.sentence, # 执行的步骤

step.defined_at.file # 步骤定义在哪个文件

)

# 将每个场景的每一步信息打印到日志

logging.info(run)

# 每个step执行后执行

@after.each_step

def teardown_some_step(step):

if not step.hashes:#判断是否没有表格文件

print "no tables in the step" #会被打印9次，因为我们仅仅设定了场景的table，而不是给每个步骤设定table

#注意每个step可以有自己的table,等价于把table的数据作为一个字典传入到程序中使用。

logging.info("no tables in the step")#打印没有table

# 在每个secnario执行结束执行，每一个场景结束后打印

@after.each_scenario

def teardown_some_scenario(scenario):

print 'finished, scenario name:' + scenario.name

logging.info('finished, scenario name:' + scenario.name)

# 在所有场景开始执行后执行

@after.all #默认获取执行结果的对象作为total参数

def say_goodbye(total):

result = "Congratulations, %d of %d scenarios passed!" % (

total.scenarios_ran, #一共多少场景运行了

total.scenarios_passed #一共多少场景运行成功了

)

print result

logging.info(result)

# 将测试结果写入日志文件

logging.info("Goodbye!")

print "------ Goodbye! ------"

结果：

D:\test\xingweiqudong\practice4>lettuce

Lettuce will start to run tests right now...

Feature: Search in Sogou website # \features\sogou.feature:1

In order to Search in Sogou website # \features\sogou.feature:2

As a visitor # \features\sogou.feature:3

We'll search the NBA best player # \features\sogou.feature:4

Begin to execute scenario name:Search NBA player

Scenario Outline: Search NBA player # \features\sogou.feature:6

Begin to execute scenario name:Search NBA player

Given I have the english name "<search_name>" # \features\sogou.py:7

Jordan

no tables in the step

When I search it in Sogou website # \features\sogou.py:12

no tables in the step

Then I see the entire name "<search_result>" # \features\sogou.py:20

no tables in the step

Examples:

| search_name | search_result |

| Jordan | Michael |

Curry

no tables in the step

| Curry | Stephen |

Kobe

no tables in the step

| Kobe | Bryant |

finished, scenario name:Search NBA player

Congratulations, 3 of 3 scenarios passed!

------ Goodbye! ------

1 feature (1 passed)

3 scenarios (3 passed)

9 steps (9 passed)

Congratulations, 3 of 3 scenarios passed!

------ Goodbye! ------

第五个例子：feature里用中文#language:zh-CN

涉及中文，要改个东西，colored_shell_output.py里encode('utf-8')注释掉

在默认编码为GBK的Windows系统中执行场景使用中文描述的行为驱动测试时，打印到控制台的场景等信息，中文会出现乱码，这是由于lettuce框架将输出到控制台的场景描述信息转成UTF8编码的字符导致的。下面针对lettuce(0.2.23)版本给出具体解决方法。

（1）进入Python安装目录中lettuce安装路径中的plugins目录中，比如本地路径为C:\Python27\Lib\site-packages\lettuce\plugins。

（2）找到该目录下的colored_shell_output.py文件，

（3）打开该文件，找到该文件的第32行代码what = what.encode('utf-8')，将其改成what = what#.encode('utf-8')

Baidu.feature:

#encoding=utf-8

# language: zh-CN

特性: 在百度网址搜索IT相关书籍

能够搜索到书的作者，比如吴晓华

场景: 在百度网站搜索IT相关书籍

如果将搜索词设定为书的名字"<书名>"

当打开百度网站

和在搜索输入框中输入搜索的关键词，并点击搜索按钮后

那么在搜索结果中可以看到书的作者"<作者>"

例如:

| 书名 | 作者 |

| Selenium WebDriver实战宝典 | 吴晓华 |

| HTTP权威指南 | 协议 |

| Python核心编程 | Python |

log.py:写了个配置

#encoding=utf-8

import logging

# 初始化日志对象

logging.basicConfig(

# 日志级别

level = logging.INFO,

# 日志格式

# 时间、代码所在文件名、代码行号、日志级别名字、日志信息

format = '%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',

# 打印日志的时间

datefmt = '%a, %Y-%m-%d %H:%M:%S',

# 日志文件存放的目录（目录必须存在）及日志文件名

filename = 'e:/BddDataDriveRreport.log',

# 打开日志文件的方式

filemode = 'w'

)

terranin.py内容跟上个例子一样

#encoding=utf-8

from lettuce import *

from log import *

# 在所有场景执行前执行

@before.all

def say_hello():

logging.info(u"开始执行行为数据驱动测试...")

# 在每个secnario开始执行前执行

@before.each_scenario

def setup_some_scenario(scenario):

# 将开始执行的场景信息打印到日志

logging.info(u'开始执行场景“%s”' %scenario.name)

# 每个step开始前执行

@before.each_step

def setup_some_step(step):

world.stepName = step.sentence

run = u"执行步骤“%s”, 定义在“%s”文件" % (

step.sentence, # 执行的步骤

step.defined_at.file # 步骤定义在哪个文件

)

# 将每个场景的每一步信息打印到日志

logging.info(run)

# 每个step执行后执行

@after.each_step

def teardown_some_step(step):

logging.info(u"步骤“%s”执行结束" % world.stepName)

# 在每个secnario执行结束执行

@after.each_scenario

def teardown_some_scenario(scenario):

logging.info(u'场景“%s”执行结束' %scenario.name)

# 在所有场景开始执行后执行

@after.all #默认获取执行结果的对象作为total参数

def say_goodbye(total):

result = u"恭喜，%d个场景运行，%d个场景运行成功" % (

total.scenarios_ran, #一共多少场景运行了

total.scenarios_passed #一共多少场景运行成功了

)

logging.info(result)

# 将测试结果写入日志文件

logging.info(u"本次行为数据驱动执行结束")

baidu.py:

把装饰器里传的内容改成中文，其他没变化

#encoding=utf-8

# language: zh-CN

from lettuce import *

from selenium import webdriver

import time

@step(u'将搜索词设定为书的名字"(.*)"')

def have_the_searchWord(step, searchWord):

world.searchWord = searchWord

print world.searchWord

@step(u'打开百度网站')

def visit_baidu_website(step):

world.driver = webdriver.Firefox(executable_path = "c:\\geckodriver ")

world.driver.get("http://www.baidu.com")

@step(u'在搜索输入框中输入搜索的关键词，并点击搜索按钮后')

def search_in_sogou_website(step):

world.driver.find_element_by_id("kw").send_keys(world.searchWord)

world.driver.find_element_by_id("su").click()

time.sleep(3)

@step(u'在搜索结果中可以看到书的作者"(.*)"')

def check_result_in_sogou(step, searchResult):

assert searchResult in world.driver.page_source, "got word:%s" %searchResult

world.driver.quit()

结果：

D:\test\xingweiqudong\practice5>lettuce

特性: 在百度网址搜索IT相关书籍 # \features\baidu.feature:4

能够搜索到书的作者，比如吴晓华 # \features\baidu.feature:5

场景模板: 在百度网站搜索IT相关书籍 # \features\baidu.feature:7

如果将搜索词设定为书的名字"<书名>" # \features\baidu.py:8

Selenium WebDriver实战宝典

当打开百度网站 # \features\baidu.py:13

和在搜索输入框中输入搜索的关键词，并点击搜索按钮后 # \features\baidu.py:18

那么在搜索结果中可以看到书的作者"<作者>" # \features\baidu.py:24

例如:

| 书名 | 作者 |

| Selenium WebDriver实战宝典 | 吴晓华 |

HTTP权威指南

| HTTP权威指南 | 协议 |

Python核心编程

| Python核心编程 | Python |

1 feature (1 passed)

3 scenarios (3 passed)

12 steps (12 passed)

第六个例子：批量执行

把多个feature和脚本文件放在一个目录下，lettuce会自动的匹配feature的东西，一个一个的执行

Login_Chinese.feature：

#encoding=utf-8

# language: zh-CN

特性: 登录126邮箱和退出126邮箱登录

场景: 成功登录126邮箱

假如启动一个浏览器

当用户访问http://mail.126.com网址

当用户输入输入用户名“testman1980”和密码“wulaoshi1978”

那么页面会出现“未读邮件”关键字

场景: 成功退出126邮箱

当用户从页面单击退出链接

那么页面显示“您已成功退出网易邮箱”关键内容

Login_English.feature：

#encoding=utf-8

Feature: login and logout

Scenario: Successful Login with Valid Credentials

Given Launch a browser

When User visit to http://mail.126.com Page

And User enters UserName"testman1980" and Password"wulaoshi1978"

Then Message displayed Login Successfully

Scenario: Successful LogOut

When User LogOut from the Application

Then Message displayed LogOut Successfully

Login_Chinese.py：

#encoding=utf-8

# language: zh-CN

from lettuce import *

from selenium import webdriver

from selenium.webdriver.common.keys import Keys

import time

@step(u'启动一个浏览器')

def open_browser(step):

try:

# 创建Chrome浏览器的driver实例，并存于全局对象world中，

# 供后续场景或步骤函数使用

world.driver = webdriver.Firefox(executable_path="c:\\geckodriver")

except Exception, e:

raise e

@step(u'用户访问(.*)网址')

def visit_url(step, url):

print url

world.driver.get(url)

@step(u'用户输入输入用户名“(.*)”和密码“(.*)”')

def user_enters_UserName_and_Password(step, username, password):

print username, password

# 浏览器窗口最大化

world.driver.maximize_window()

time.sleep(3)

# 切换进frame控件

world.driver.switch_to.frame("x-URS-iframe")

# 获取用户名输入框

userName = world.driver.find_element_by_xpath('//input[@name="email"]')

userName.clear()

# 输入用户名

userName.send_keys(username)

# 获取密码输入框

pwd = world.driver.find_element_by_xpath("//input[@name='password']")

# 输入密码

pwd.send_keys(password)

# 发送一个回车键

pwd.send_keys(Keys.RETURN)

# 等待15秒，以便登录后成功进入登录后的页面

time.sleep(15)

@step(u'页面会出现“(.*)”关键字')

def message_displayed_Login_Successfully(step, keywords):

# print world.driver.page_source.encode('utf-8')

# 断言登录成功后，页面是否出现预期的关键字

world.driver.switch_to.default_content()#自己加的

assert keywords in world.driver.page_source

# 断言成功后，打印登录成功信息

print "Login Success"

@step(u'用户从页面单击退出链接')

def LogOut_from_the_Application(step):

print "====",world.driver

# time.sleep(5)

world.driver.switch_to.default_content()#自己加的

# 点击退出按钮，退出登录

world.driver.find_element_by_link_text(u"退出").click()

time.sleep(8)

@step(u'页面显示“(.*)”关键内容')

def displayed_LogOut_Successfully(step, keywords):

# 断言退出登录后，页面是否出现退出成功关键内容

assert keywords in world.driver.page_source

print u"Logout Success"

# 退出浏览器

world.driver.quit()

Login_English.py：

#encoding=utf-8

from lettuce import *

from selenium import webdriver

from selenium.webdriver.common.keys import Keys

import time

@step('Launch a browser')

def open_browser(step):

try:

world.driver = webdriver.Firefox(executable_path="c:\\geckodriver")

except Exception, e:

raise e

@step('User visit to (.*) Page')

def visit_url(step, url):

world.driver.get(url)

@step('User enters UserName"(.*)" and Password"(.*)"')

def user_enters_UserName_and_Password(step, username, password):

world.driver.maximize_window()

time.sleep(3)

world.driver.switch_to.frame("x-URS-iframe")

userName = world.driver.find_element_by_xpath('//input[@name="email"]')

userName.clear()

userName.send_keys(username)

pwd = world.driver.find_element_by_xpath("//input[@name='password']")

pwd.send_keys(password)

pwd.send_keys(Keys.RETURN)

time.sleep(15)

@step('Message displayed Login Successfully')

def message_displayed_Login_Successfully(step):

# print world.driver.page_source.encode('utf-8')

world.driver.switch_to.default_content()#自己加的

assert u"未读邮件" in world.driver.page_source

print "Login Success"

@step('User LogOut from the Application')

def LogOut_from_the_Application(step):

print "====",world.driver

# time.sleep(15)

world.driver.switch_to.default_content()#自己加的

world.driver.find_element_by_link_text(u"退出").click()

time.sleep(4)

@step('Message displayed LogOut Successfully')

def displayed_LogOut_Successfully(step):

assert u"您已成功退出网易邮箱" in world.driver.page_source

print u"Logout Success"

world.driver.quit()

terrain.py：

#encoding=utf-8

from lettuce import *

# 在所有场景执行前执行

@before.all

def say_hello():

print u"开始执行行为数据驱动测试..."

# 在每个secnario开始执行前执行

@before.each_scenario

def setup_some_scenario(scenario):

print u'开始执行场景“%s”' %scenario.name

# 在每个secnario执行结束后执行

@after.each_scenario

def teardown_some_scenario(scenario):

print u'场景“%s”执行结束' %scenario.name

# 在所有场景执行结束后执行

@after.all #默认获取执行结果的对象作为total参数

def say_goodbye(total):

result = u"恭喜，%d个场景被运行，%d个场景运行成功" % (

total.scenarios_ran, #一共多少场景运行了

total.scenarios_passed #一共多少场景运行成功了

)

print result

结果：

D:\test\xingweiqudong\practice6>lettuce

开始执行行为数据驱动测试...

特性: 登录126邮箱和退出126邮箱登录 # \features\Login_Chinese.feature:4

场景: 成功登录126邮箱 # \features\Login_Chinese.feature:6

开始执行场景“成功登录126邮箱”

假如启动一个浏览器 # \features\Login_Chinese.py:9

当用户访问http://mail.126.com网址 # \features\Login_Chinese.py:19

当用户输入输入用户名“xiaxiaoxu1987”和密码“gloryroad” # \features\Login_Chinese.py:24

那么页面会出现“未读邮件”关键字 # \features\Login_Chinese.py:46

场景“成功登录126邮箱”执行结束

场景: 成功退出126邮箱 # \features\Login_Chinese.feature:12

开始执行场景“成功退出126邮箱”

当用户从页面单击退出链接 # \features\Login_Chinese.py:55

当用户从页面单击退出链接 # \features\Login_Chinese.py:55364d904c9c4")>

那么页面显示“您已成功退出网易邮箱”关键内容 # \features\Login_Chinese.py:64

场景“成功退出126邮箱”执行结束

Feature: login and logout # \features\Login_English.feature:3

Scenario: Successful Login with Valid Credentials # \features\Login_English.feature:5

开始执行场景“Successful Login with Valid Credentials”

Given Launch a browser # \features\Login_English.py:8

When User visit to http://mail.126.com Page # \features\Login_English.py:16

And User enters UserName"xiaxiaoxu1987" and Password"gloryroad" # \features\Login_English.py:20

Then Message displayed Login Successfully # \features\Login_English.py:33

场景“Successful Login with Valid Credentials”执行结束

Scenario: Successful LogOut # \features\Login_English.feature:11

开始执行场景“Successful LogOut”

When User LogOut from the Application # \features\Login_English.py:40

When User LogOut from the Application # \features\Login_English.py:40")>

Then Message displayed LogOut Successfully # \features\Login_English.py:48

场景“Successful LogOut”执行结束

2 features (2 passed)

4 scenarios (4 passed)

12 steps (12 passed)

恭喜，4个场景被运行，4个场景运行成功

pip show lettuce 显示lettuce版本号

练习，用lettuce实现两个数的相加

steps.py:

#encoding=utf-8

from lettuce import *

# 用于计算整数的阶乘函数

def sum(a,b):

return a+b

@step('I have the number (\d),(\d)')

def have_the_number(step, number1,number2):

# 将通过正则表达式匹配的数字存于全局变量world中

world.number1 = int(number1)

world.number2 = int(number2)

print "number1:",number1#这样打印显示不了

print "number2:",number2#这样打印显示不了

@step('I compute its sum')

def compute_its_sum(step):

# 从全局变量world中取出匹配的数字，

# 计算其阶乘，并将结果再存回world中

world.number = sum(world.number1,world.number2)

print "world.number:",world.number#这样打印显示不了

@step('I see the number (\d+)')

def check_number(step, expected):

# 通过正则匹配到预期数字

expected = int(expected)

print "expected:",expected#这样打印显示不了

# 断言计算阶乘结果是否等于预期

assert world.number == expected, "Got %d" %world.number

feature:

Feature: Compute sum

In order to play with Lettuce

As beginners

We'll implement sum

Scenario: sum of 1,2

Given I have the number 1,2

When I compute its sum

Then I see the number 3

结果：

D:\test\xingweiqudong\test>lettuce

Feature: Compute sum # \features\zero.feature:1

In order to play with Lettuce # \features\zero.feature:2

As beginners # \features\zero.feature:3

We'll implement sum # \features\zero.feature:4

Scenario: sum of 1,2 # \features\zero.feature:6

Given I have the number 1,2 # \features\steps.py:9

number1: 1

Given I have the number 1,2 # \features\steps.py:9

When I compute its sum # \features\steps.py:17

Then I see the number 3 # \features\steps.py:24

1 feature (1 passed)

1 scenario (1 passed)

3 steps (3 passed)