lettuce行为驱动框架实例

练习：

一：e1_MyFirstBDD 使用方法的方式实现阶乘的计算

zero.feature:

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

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

#取出数据

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

def have_the_number(step, number):

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

    #world是公用的，不能变

    #step对应的是I have the number，number参数名字是自定义的

    world.number = int(number)

#用测试数据调用测试方法

@step('I compute its factorial')

def compute_its_factorial(step):

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

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

    world.number = factorial(world.number)

#断言实际结果和期望结果是否一致

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

def check_number(step, expected):

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

    expected = int(expected)

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

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

二：e2_MyFirstBDD 使用类的方式实现阶乘的计算

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']

    def __init__(self, environs):

        # 初始全局变量

        self.environs = environs

    def set_number(self, value):

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

        # 实际上self.environs=world

        self.environs.number = int(value)

    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+)'''

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

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

        # 并将获得数据存到环境变量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))

#world可以理解为一个类，存全局共享变量的对象

FactorialSteps(world)

三：e3_StepDataTables 基于表格的方式实现查找出名字以"G"开头的学生

student.feature

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     |

    When I bill names starting with "G"

    Then I see those billed students:

        | name     | monthly_due | billed |

        | Gabriel  | $ 300       | no     |

        | Gloria   | $ 442.65    | no     |

    And those that weren't:

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

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

        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'

            },

        ]

#通过正则获取到的(.*)这个分组，给参数startAlpha

@step('I bill names starting with "(.*)"')

def match_starting(step, startAlpha):

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

    # 并存于全局变量startAlpha中

    world.startAlpha = startAlpha

    print "no data exist:",step.hashes

    print ""

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

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

        assert world.startAlpha not in j["name"][0]

四：e4_English_example 英文模板

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>"

    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        |

sogou.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.Ie(executable_path = "c:\\IEDriverServer")

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

五：e5_Chinese_example 中文模板

baidu.feature：

#encoding=utf-8

# language: zh-CN

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

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

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

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

        当打开百度网站

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

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

    例如:

        | 书名                         | 作者   |

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

        | HTTP权威指南                 | 协议 |

        | Python核心编程               | Python |

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.Ie(executable_path = "c:\\IEDriverServer")

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

六：e6_executed_by_batch 批量执行

Login_Chinese.feature：

#encoding=utf-8

# language: zh-CN

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

    场景: 成功登录126邮箱

        假如启动一个浏览器

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

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

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

    场景: 成功退出126邮箱

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

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

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.Ie(executable_path = "c:\\IEDriverServer")

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

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

    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.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()

七：e7_example 行为驱动实现1+2=3

zero.feature:

Feature: Compute factorial

  In order to play with Lettuce

  As beginners

  We'll implement factorial

  Scenario: Factorial of 1

    Given I have the number 1,2

    When I compute its factorial

    Then I see the number 3

step.py:

#encoding=utf-8

from lettuce import *

# 用于计算整数的和函数

def sum(number1,number2):

    return int(number1+number2)

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

def have_the_number(step, number1,number2):

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

    world.number1 = int(number1)

    world.number2 = int(number2)

@step('I compute its factorial')

def compute_its_factorial(step):

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

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

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

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

def check_number(step, expected):

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

    expected = int(expected)

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

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