【脚本语言系列】关于Python测试工具lettuce

最新推荐文章于 2022-12-17 14:12:22 发布

Allen Moore

最新推荐文章于 2022-12-17 14:12:22 发布

阅读量2.1k

点赞数

分类专栏：脚本语言工具手册文章标签： python lettuce 脚本语言测试工具

本文链接：https://blog.csdn.net/MosesAaron/article/details/70227444

版权

脚本语言同时被 2 个专栏收录

129 篇文章 1 订阅

订阅专栏

工具手册

55 篇文章 0 订阅

订阅专栏

如何使用lettuce

安装lettuce(先安装Python2.7或者Python3.5、Python3.6)，即命令行输入以下命令：

pip install lettuce

定义问题：给定一个数，如何计算它的阶乘？
注意：只有非负整数才有阶乘，0的阶乘为1。
项目结构：新建文件夹feautures，其内新建空文件steps.py以及空文件zero.feature。
注意：文件名可以改变，feautures文件夹名以及其内文件的后缀名不能改变。lettuce将会在features文件夹中递归查找.py以及.feature。

进行测试：

第1轮测试
1. 描述行为，即用英文在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

 2. 用python定义步骤，即创建包含有描述步骤的python代码的steps.py文件
 现在有了测试方案的各步骤定义，因而Lettuce能够理解行为描述。

这里写图片描述
```Python
from lettuce import *

	@step('I have the number (\d+)')
	def have_the_number(step, number):
	    world.number = int(number)
	
	@step('I compute its factorial')
	def compute_its_factorial(step):
	    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
	```

		定义被测函数，即在其他位置（非steps.py）中定义被测函数

这里写图片描述
Python def factorial(number): return -1
3. 运行测试并观察运行结果

bat lettuce
4. 修改函数定义

Python def factorial(number): return 1
5. 再次运行测试并观察运行结果
【配图1-5——一轮测试测试成功】
bat lettuce
* 第2轮测试
1. 描述行为
这里写图片描述
```
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        
```
	2. 用python定义步骤
	在第1次测试基础上不需要进行修改。
		**定义被测函数**
	在第1次测试基础上不需要进行修改。
	3.  运行测试并观察运行结果
![这里写图片描述](https://img-blog.csdn.net/20170418165514615?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTW9zZXNBYXJvbg==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
	
	4.  修改函数定义

这里写图片描述
Python def factorial(number): number = int(number) if (number == 0) or (number == 1): return 1 else: return number
5. 再次运行测试并观察运行结果

* 第**3**轮测试
	1. 描述行为
	![【配图3-1——三轮测试行为描述】](https://img-blog.csdn.net/20170418165612615?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvTW9zZXNBYXJvbg==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
```
 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   

  Scenario: Factorial of 4
    Given I have the number 4
    When I compute its factorial
    Then I see the number 24    
```
	2. 用python定义步骤
	在第1次测试基础上不需要进行修改。
		**定义被测函数**
	在第1次测试基础上不需要进行修改。
	3.  运行测试并观察运行结果

这里写图片描述
```Python
def factorial(number):
number = int(number)
if (number == 0) or (number == 1):
return 1
else:
return number

	```		 
	4.  修改函数定义

这里写图片描述
5. 再次运行测试并观察运行结果

* 第4轮测试
语法糖：函数名以及文档现在能够描述步骤语句；0.2.19版本以上支持。由函数名和函数文档来构造步骤语句，只需用不含有参数的"@step"标识符对函数进行装饰。以下的两个例子，分别以函数名以及文档进行描述，其本质与以上的例子相同。
* 用函数名定义步骤
这里写图片描述
```Python
from lettuce import *

	@step
	def have_the_number(step, number):
	'I have the number (\d+)'
	world.number = int(number)
	
	@step
	def compute_its_factorial(step):
	world.number = factorial(world.number)
	
	@step
	def check_number(step, expected):
	'I see the number (\d+)'
	expected = int(expected)
	assert world.number == expected, \
	    "Got %d" % world.number  
	
	def factorial(number):
	number = int(number)
	if (number == 0) or (number == 1):
	    return 1
	else:
	    return number*factorial(number-1)
	     
	```		 
	* 用文档定义步骤

这里写图片描述
```Python
from lettuce import world, steps

	@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):
        self.environs.number = int(value)

    def get_number(self):
        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+)'''
        self.set_number(number)

    def i_compute_its_factorial(self, step):
        number = self.get_number()
        self.set_number(factorial(number))

    def check_number(self, step, expected):
        '''I see the number (\d+)'''
        self._assert_number_is(int(expected))
		     
	# Important!
	# Steps are added only when you instanciate the "@steps" decorated class
	# Internally decorator "@steps" build a closure with __init__
	
	FactorialSteps(world)
	
	def factorial(number):
	    number = int(number)
	    if (number == 0) or (number == 1):
	        return 1
	    else:
	        return number*factorial(number-1)			     
	```

什么是lettuce

lettuce是基于BDD（行为驱动开发）理念下非常有用和迷人的工具。
它可以执行纯文本功能描述用作Python项目的自动化测试，就像Cucumber对 Ruby一样。
lettuce使得开发和测试过程非常简单，可扩展，易读，而且最好的是，它允许不编程的人描述某个系统的行为，不需要想像这些描述会在开发过程中自动测试系统。