kar*_*cow 33 python unit-testing monkeypatching http mocking
我想为我所有与HTTP相关的测试都包含一个Web服务器.它不需要非常复杂.我宁愿不依赖在线.所以我可以测试一下我的程序的一些选项.
有关此代码的任何提示都会有所帮助.我用BaseHTTPServer尝试了一些但尚未成功的东西.nosetests命令似乎无限期地等待.
import unittest
from foo import core
class HttpRequests(unittest.TestCase):
"""Tests for HTTP"""
def setUp(self):
"Starting a Web server"
self.port = 8080
# Here we need to start the server
#
# Then define a couple of URIs and their HTTP headers
# so we can test the code.
pass
def testRequestStyle(self):
"Check if we receive a text/css content-type"
myreq = core.httpCheck()
myuri = 'http://127.0.0.1/style/foo'
myua = "Foobar/1.1"
self.asserEqual(myreq.mimetype(myuri, myua), "text/css")
def testRequestLocation(self):
"another test"
pass
def tearDown(self):
"Shutting down the Web server"
# here we need to shut down the server
pass
谢谢你的帮助.
更新 - 2012:07:10T02:34:00Z
这是一个代码,对于给定的Web站点将返回CSS列表.我想测试它是否返回正确的CSS列表.
import unittest
from foo import core
class CssTests(unittest.TestCase):
"""Tests for CSS requests"""
def setUp(self):
self.css = core.Css()
self.req = core.HttpRequests()
def testCssList(self):
"For a given Web site, check if we get the right list of linked stylesheets"
WebSiteUri = 'http://www.opera.com/'
cssUriList = [
'http://www.opera.com/css/handheld.css',
'http://www.opera.com/css/screen.css',
'http://www.opera.com/css/print.css',
'http://www.opera.com/css/pages/home.css']
content = self.req.getContent(WebSiteUri)
cssUriListReq = self.css.getCssUriList(content, WebSiteUri)
# we need to compare ordered list.
cssUriListReq.sort()
cssUriList.sort()
self.assertListEqual(cssUriListReq, cssUriList)
然后进去 foo/core.py
import urlparse
import requests
from lxml import etree
import cssutils
class Css:
"""Grabing All CSS for one given URI"""
def getCssUriList(self, htmltext, uri):
"""Given an htmltext, get the list of linked CSS"""
tree = etree.HTML(htmltext)
sheets = tree.xpath('//link[@rel="stylesheet"]/@href')
for i, sheet in enumerate(sheets):
cssurl = urlparse.urljoin(uri, sheet)
sheets[i] = cssurl
return sheets
现在,代码依赖于在线服务器.它不应该.我希望能够添加大量不同类型的样式表组合并测试协议,然后在解析,组合等方面提供一些选项.
Rod*_*gue 71
启动Web服务器进行单元测试绝对不是一个好习惯.单元测试应该简单且隔离,这意味着它们应该避免执行IO操作.
如果您要编写的内容实际上是单元测试,那么您应该制作自己的测试输入并查看模拟对象.Python是一种动态语言,模拟和猴子路径是编写单元测试的简单而强大的工具.特别是,看看优秀的Mock模块.
因此,如果我们看一下您的CssTests示例,那么您正在尝试测试css.getCssUriList能够提取您提供的HTML片段中引用的所有CSS样式表.您在此特定单元测试中所做的不是测试您是否可以发送请求并从网站获得响应,对吧？您只是想确保给定一些HTML,您的函数会返回正确的CSS URL列表.因此,在此测试中,您显然不需要与真实的HTTP服务器通信.
我会做类似以下的事情:
import unittest
class CssListTestCase(unittest.TestCase):
def setUp(self):
self.css = core.Css()
def test_css_list_should_return_css_url_list_from_html(self):
# Setup your test
sample_html = """
<html>
<head>
<title>Some web page</title>
<link rel='stylesheet' type='text/css' media='screen'
href='http://example.com/styles/full_url_style.css' />
<link rel='stylesheet' type='text/css' media='screen'
href='/styles/relative_url_style.css' />
</head>
<body><div>This is a div</div></body>
</html>
"""
base_url = "http://example.com/"
# Exercise your System Under Test (SUT)
css_urls = self.css.get_css_uri_list(sample_html, base_url)
# Verify the output
expected_urls = [
"http://example.com/styles/full_url_style.css",
"http://example.com/styles/relative_url_style.css"
]
self.assertListEqual(expected_urls, css_urls)
现在,不那么明显的事情就是getContent()对你core.HttpRequests班级的方法进行单元测试.我想你正在使用HTTP库而不是在TCP套接字上发出自己的请求.
要将测试保持在单元级别,您不希望通过网络发送任何内容.您可以采取哪些措施来避免这种情况,即可通过测试确保您正确使用HTTP库.这不是测试代码的行为,而是测试它与周围其他对象的交互方式.
一种方法是明确依赖于该库:我们可以添加一个参数HttpRequests.__init__来传递它的库的HTTP客户端实例.假设我使用的HTTP库提供了一个HttpClient我们可以调用的对象get().你可以这样做:
class HttpRequests(object):
def __init__(self, http_client):
self.http_client = http_client
def get_content(self, url):
# You could imagine doing more complicated stuff here, like checking the
# response code, or wrapping your library exceptions or whatever
return self.http_client.get(url)
我们已经明确了依赖项,并且调用者现在需要满足需求HttpRequests:这称为依赖注入(DI).
DI对两件事非常有用:
在这里,我们可以使用我们将提供的模拟对象,并且它将在core.HttpRequests不知不觉中使用,就像它是真正的库一样.之后,我们可以测试交互是否按预期进行.
import core
class HttpRequestsTestCase(unittest.TestCase):
def test_get_content_should_use_get_properly(self):
# Setup
url = "http://example.com"
# We create an object that is not a real HttpClient but that will have
# the same interface (see the `spec` argument). This mock object will
# also have some nice methods and attributes to help us test how it was used.
mock_http_client = Mock(spec=somehttplib.HttpClient)
# Exercise
http_requests = core.HttpRequests(mock_http_client)
content = http_requests.get_content(url)
# Here, the `http_client` attribute of `http_requests` is the mock object we
# have passed it, so the method that is called is `mock.get()`, and the call
# stops in the mock framework, without a real HTTP request being sent.
# Verify
# We expect our get_content method to have called our http library.
# Let's check!
mock_http_client.get.assert_called_with(url)
# We can find out what our mock object has returned when get() was
# called on it
expected_content = mock_http_client.get.return_value
# Since our get_content returns the same result without modification,
# we should have received it
self.assertEqual(content, expected_content)
我们现在测试了我们的get_content方法与我们的HTTP库正确交互.我们已经定义了HttpRequests对象的边界并对它们进行了测试,这就是我们应该在单元测试级别上进行的.请求现在在该库的手中,并且它肯定不是我们的单元测试套件的角色来测试库是否按预期工作.
现在想象我们决定使用伟大的请求库.它的API更具程序性,它不会提供我们可以从中获取HTTP请求的对象.相反,我们将导入模块并调用其get方法.
然后我们的HttpRequests班级core.py会看下面的事情如下:
import requests
class HttpRequests(object):
# No more DI in __init__
def get_content(self, url):
# We simply delegate the HTTP work to the `requests` module
return requests.get(url)
没有DI,所以现在,我们想知道:
requests是否正确使用该模块？在这里,您可以使用动态语言提供的另一种奇妙且有争议的机制:猴子修补.我们将在运行时requests使用我们制作的对象替换模块,并可以在我们的测试中使用.
我们的单元测试将看起来像:
import core
class HttpRequestsTestCase(unittest.TestCase):
def setUp(self):
# We create a mock to replace the `requests` module
self.mock_requests = Mock()
# We keep a reference to the current, real, module
self.old_requests = core.requests
# We replace the module with our mock
core.requests = self.mock_requests
def tearDown(self):
# It is very important that each unit test be isolated, so we need
# to be good citizen and clean up after ourselves. This means that
# we need to put back the correct `requests` module where it was
core.requests = self.old_requests
def test_get_content_should_use_get_properly(self):
# Setup
url = "http://example.com"
# Exercise
http_client = core.HttpRequests()
content = http_client.get_content(url)
# Verify
# We expect our get_content method to have called our http library.
# Let's check!
self.mock_requests.get.assert_called_with(url)
# We can find out what our mock object has returned when get() was
# called on it
expected_content = self.mock_requests.get.return_value
# Since our get_content returns the same result without modification,
# we should have received
self.assertEqual(content, expected_content)
为了使这个过程更简洁,mock模块有一个patch装饰器,用于管理脚手架.然后我们只需要写:
import core
class HttpRequestsTestCase(unittest.TestCase):
@patch("core.requests")
def test_get_content_should_use_get_properly(self, mock_requests):
# Notice the extra param in the test. This is the instance of `Mock` that the
# decorator has substituted for us and it is populated automatically.
...
# The param is now the object we need to make our assertions against
expected_content = mock_requests.get.return_value
保持单元测试小巧,简单,快速和独立是非常重要的.依赖于另一台服务器运行的单元测试根本不是单元测试.为了帮助解决这个问题,DI是一个很好的实践,模拟对象是一个很好的工具.
首先,要了解mock的概念以及如何使用它们并不容易.像每个电动工具一样,它们也可以在你手中爆炸,例如让你相信你已经测试了一些东西,而实际上却没有.确保模拟对象的行为和输入/输出反映现实是至关重要的.
鉴于我们从未在单元测试级别与真正的HTTP服务器进行交互,因此编写集成测试非常重要,这将确保我们的应用程序能够与现实生活中将要处理的服务器进行通信.我们可以通过专门为集成测试设置的完全成熟的服务器来实现这一目标,或者编写一个人为的服务器.
| 归档时间： |
|
| 查看次数： |
25740 次 |
| 最近记录： |