之前在测试Django应用时，使用了非常方便的django.test.TestCase。在测试Tornado时，我也包装了一个TestCase类，提供和Django一样便捷的测试方法。最终，测试案例的代码将会是这样：

from testclient import TestCase

class QueryTest(TestCase):
    def setUp(self):
        pass
    def test_query(self):
        file = open('uploadfile.dat', 'rb')
        response = self.client.post('/query', { 'a': '1', 'b': '2', 'upload': file })

        self.failUnlessEqual(response.status_code, 200)
        self.failUnlessEqual(response.content, 'ok')

testclient.py的代码如下： 

代码

#!/usr/bin/env python
#coding:utf-8
#
# Copyright 2009 CoderZh.com.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

__author__ = 'CoderZh'


import tornado.ioloop
import unittest
import mimetypes

import tornado.httpclient
import tornado.ioloop

TEST_PORT = 8989

def encode_multipart_formdata(fields, files):
    """
    fields is a sequence of (name, value) elements for regular form fields.
    files is a sequence of (name, filename, value) elements for data to be uploaded as files
    Return (content_type, body) ready for httplib.HTTP instance
    """
    BOUNDARY = '----------ThIs_Is_tHe_bouNdaRY_$'
    CRLF = '\r\n'
    L = []
    for (key, value) in fields:
        L.append('--' + BOUNDARY)
        L.append('Content-Disposition: form-data; name="%s"' % key)
        L.append('')
        L.append(value)
    for (key, filename, value) in files:
        L.append('--' + BOUNDARY)
        L.append('Content-Disposition: form-data; name="%s"; filename="%s"' % (key, filename))
        L.append('Content-Type: %s' % get_content_type(filename))
        L.append('')
        L.append(value)
    L.append('--' + BOUNDARY + '--')
    L.append('')
    body = CRLF.join(L)
    content_type = 'multipart/form-data; boundary=%s' % BOUNDARY
    return content_type, body

def get_content_type(filename):
    return mimetypes.guess_type(filename)[0] or 'application/octet-stream'


class Response:
    def __init__(self, status_code, content):
        self.status_code = status_code
        self.content = content

class Client:
    
    def handle_request(self, response):
        self.response = response
        tornado.ioloop.IOLoop.instance().stop()
    
    def post(self, url, data={}):
    url = 'http://127.0.0.1:%s%s' % (TEST_PORT, url)
        fields = []
        files = []
        for key, value in data.items():
            if isinstance(value, file):
                files.append([key, value.name, value.read()])
            else:
                fields.append([key, value])
                
        content_type, body = encode_multipart_formdata(fields, files)
        headers = {'Content-Type' : content_type}
        
        request = tornado.httpclient.HTTPRequest(url=url,
                         method='POST',
                         headers=headers,
                         body=body)

        client = tornado.httpclient.AsyncHTTPClient()
        client.fetch(request , self.handle_request)    
        tornado.ioloop.IOLoop.instance().start()
        
        return Response(self.response.code, self.response.body)
    
class TestCase(unittest.TestCase):
    def _pre_setup(self):
        pass
    
    def _post_teardown(self):
        pass
    
    def __call__(self, result=None):
        """
        Wrapper around default __call__ method to perform My test
        set up. This means that user-defined Test Cases aren't required to
        include a call to super().setUp().
        """
        self.client = Client()
        try:
            self._pre_setup()
        except (KeyboardInterrupt, SystemExit):
            raise
        except Exception:
            import sys
            result.addError(self, sys.exc_info())
            return
        super(TestCase, self).__call__(result)
        try:
            self._post_teardown()
        except (KeyboardInterrupt, SystemExit):
            raise
        except Exception:
            import sys
            result.addError(self, sys.exc_info())
            return

 

本文转自CoderZh博客园博客，原文链接：http://www.cnblogs.com/coderzh/archive/2010/01/01/Tornado-Unit-Testing.html，如需转载请自行联系原作者