添加测试

现在我们将为模型和视图添加测试，并在新的 tests 包裹。在以后的测试中，确保它继续工作。

测试线束

这个项目通过一些测试和一个基本的工具来启动。它们位于 tests 项目顶层的包。把测试放在一个 tests 与应用程序包一起打包，特别是随着项目规模和复杂性的增加。一个有用的约定是应用程序中的每个模块在 tests 包裹。测试模块的名称与前缀相同 test_ .

线束包括以下设置：

• pytest.ini -基本控件 pytest 配置，包括查找测试的位置。我们已经配置 pytest 在应用程序包和 tests 包裹。

• .coveragerc -控制覆盖范围配置。在我们的设置中，它与 pytest-cov 我们通过 --cov 选项到 pytest 命令。

• testing.ini -镜子 development.ini 和 production.ini 包含用于执行测试套件的设置。最重要的是，它包含需要数据库的测试所使用的数据库连接信息。

• tests_require 在里面 setup.py -控制测试时安装的依赖项。当列表更改时，需要重新运行 $VENV/bin/pip install -e ".[testing]" 以确保安装新的依赖项。

• tests/conftest.py -在我们整个测试过程中都可以使用核心夹具。下面将更详细地解释这些固定装置。

会话范围测试夹具

• app_settings -设置 dict 从 testing.ini 通常被传递的文件 pserve 应用程序的 main 功能。

• dbengine -初始化数据库。从已知状态开始测试套件的每次运行是很重要的，这个fixture负责适当地准备数据库。这包括删除任何现有的表，运行迁移，甚至可能将一些fixture数据加载到表中以便在测试中使用。

• app - Pyramid WSGI应用程序，实现 pyramid.interfaces.IRouter 接口。这通常用于功能测试。

每个测试夹具

• tm -A transaction.TransactionManager 对象控制事务生命周期。一般来说，其他固定装置会连接到 tm fixture来控制它们的生命周期，并确保它们在测试结束时被中止。

• dbsession -A sqlalchemy.orm.session.Session 对象连接到数据库。会话的作用域是 tm 固定装置。任何更改都将在测试结束时中止。

• testapp -A webtest.TestApp 实例包装 app 用于向应用程序发送请求并返回可检查的完整响应对象。这个 testapp 能够改变请求环境以便 dbsession 和 tm fixture被注入并由任何涉及的代码使用 request.dbsession 和 request.tm . 这个 testapp 维护一个cookiejar，因此它可以用于在请求之间共享状态，以及事务数据库连接。

• app_request -A pyramid.request.Request 对象，该对象可用于更轻量级的测试，而不是完整的 testapp . 这个 app_request 可以传递给需要一个完全功能的请求对象的视图函数和其他代码。

• dummy_request -A pyramid.testing.DummyRequest 非常轻量的对象。这是一个很好的对象，可以传递给视图函数，因为它具有最小的副作用，因为它将是快速和简单的。

• dummy_config -a pyramid.config.Configurator 用作配置的对象 dummy_request 。对于模拟配置(如路由和安全策略)非常有用。

修改固定装置

我们将对测试工具进行一些特定于应用程序的更改。为经常做的事情想出模式总是好的，这样可以避免很多样板。

• 使用CSRF令牌初始化cookiejar。记住我们的应用程序正在使用 pyramid.csrf.CookieCSRFStoragePolicy .

• testapp.get_csrf_token() -每个POST/PUT/DELETE/PATCH请求都必须包含当前的CSRF令牌，以向我们的应用程序证明客户端不是第三方。所以我们需要一种简单的方法来获取当前的CSRF令牌并将其添加到请求中。

• testapp.login(params) -许多页面只有登录的用户才可以访问，所以我们需要一个简单的方法在测试开始时登录用户。

更新 tests/conftest.py 如下图所示，添加高亮显示的线条：

import alembic
import alembic.config
import alembic.command
import os
from pyramid.paster import get_appsettings
from pyramid.scripting import prepare
from pyramid.testing import DummyRequest, testConfig
import pytest
import transaction
from webob.cookies import Cookie
import webtest

from tutorial import main
from tutorial import models
from tutorial.models.meta import Base


def pytest_addoption(parser):
    parser.addoption('--ini', action='store', metavar='INI_FILE')

@pytest.fixture(scope='session')
def ini_file(request):
    # potentially grab this path from a pytest option
    return os.path.abspath(request.config.option.ini or 'testing.ini')

@pytest.fixture(scope='session')
def app_settings(ini_file):
    return get_appsettings(ini_file)

@pytest.fixture(scope='session')
def dbengine(app_settings, ini_file):
    engine = models.get_engine(app_settings)

    alembic_cfg = alembic.config.Config(ini_file)
    Base.metadata.drop_all(bind=engine)
    alembic.command.stamp(alembic_cfg, None, purge=True)

    # run migrations to initialize the database
    # depending on how we want to initialize the database from scratch
    # we could alternatively call:
    # Base.metadata.create_all(bind=engine)
    # alembic.command.stamp(alembic_cfg, "head")
    alembic.command.upgrade(alembic_cfg, "head")

    yield engine

    Base.metadata.drop_all(bind=engine)
    alembic.command.stamp(alembic_cfg, None, purge=True)

@pytest.fixture(scope='session')
def app(app_settings, dbengine):
    return main({}, dbengine=dbengine, **app_settings)

@pytest.fixture
def tm():
    tm = transaction.TransactionManager(explicit=True)
    tm.begin()
    tm.doom()

    yield tm

    tm.abort()

@pytest.fixture
def dbsession(app, tm):
    session_factory = app.registry['dbsession_factory']
    return models.get_tm_session(session_factory, tm)

class TestApp(webtest.TestApp):
    def get_cookie(self, name, default=None):
        # webtest currently doesn't expose the unescaped cookie values
        # so we're using webob to parse them for us
        # see https://github.com/Pylons/webtest/issues/171
        cookie = Cookie(' '.join(
            '%s=%s' % (c.name, c.value)
            for c in self.cookiejar
            if c.name == name
        ))
        return next(
            (m.value.decode('latin-1') for m in cookie.values()),
            default,
        )

    def get_csrf_token(self):
        """
        Convenience method to get the current CSRF token.

        This value must be passed to POST/PUT/DELETE requests in either the
        "X-CSRF-Token" header or the "csrf_token" form value.

        testapp.post(..., headers={'X-CSRF-Token': testapp.get_csrf_token()})

        or

        testapp.post(..., {'csrf_token': testapp.get_csrf_token()})

        """
        return self.get_cookie('csrf_token')

    def login(self, params, status=303, **kw):
        """ Convenience method to login the client."""
        body = dict(csrf_token=self.get_csrf_token())
        body.update(params)
        return self.post('/login', body, **kw)

@pytest.fixture
def testapp(app, tm, dbsession):
    # override request.dbsession and request.tm with our own
    # externally-controlled values that are shared across requests but aborted
    # at the end
    testapp = TestApp(app, extra_environ={
        'HTTP_HOST': 'example.com',
        'tm.active': True,
        'tm.manager': tm,
        'app.dbsession': dbsession,
    })

    # initialize a csrf token instead of running an initial request to get one
    # from the actual app - this only works using the CookieCSRFStoragePolicy
    testapp.set_cookie('csrf_token', 'dummy_csrf_token')

    return testapp

@pytest.fixture
def app_request(app, tm, dbsession):
    """
    A real request.

    This request is almost identical to a real request but it has some
    drawbacks in tests as it's harder to mock data and is heavier.

    """
    with prepare(registry=app.registry) as env:
        request = env['request']
        request.host = 'example.com'

        # without this, request.dbsession will be joined to the same transaction
        # manager but it will be using a different sqlalchemy.orm.Session using
        # a separate database transaction
        request.dbsession = dbsession
        request.tm = tm

        yield request

@pytest.fixture
def dummy_request(tm, dbsession):
    """
    A lightweight dummy request.

    This request is ultra-lightweight and should be used only when the request
    itself is not a large focus in the call-stack.  It is much easier to mock
    and control side-effects using this object, however:

    - It does not have request extensions applied.
    - Threadlocals are not properly pushed.

    """
    request = DummyRequest()
    request.host = 'example.com'
    request.dbsession = dbsession
    request.tm = tm

    return request

@pytest.fixture
def dummy_config(dummy_request):
    """
    A dummy :class:`pyramid.config.Configurator` object.  This allows for
    mock configuration, including configuration for ``dummy_request``, as well
    as pushing the appropriate threadlocals.

    """
    with testConfig(request=dummy_request) as config:
        yield config

单元测试

我们可以在代码库中测试各个api，以确保它们满足应用程序其余部分所期望的契约。例如，我们将测试添加到 tutorial.models.User 对象。

创造 tests/test_user_model.py 如下所示：

from tutorial import models


def test_password_hash_saved():
    user = models.User(name='foo', role='bar')
    assert user.password_hash is None

    user.set_password('secret')
    assert user.password_hash is not None

def test_password_hash_not_set():
    user = models.User(name='foo', role='bar')
    assert not user.check_password('secret')

def test_correct_password():
    user = models.User(name='foo', role='bar')
    user.set_password('secret')
    assert user.check_password('secret')

def test_incorrect_password():
    user = models.User(name='foo', role='bar')
    user.set_password('secret')
    assert not user.check_password('incorrect')

集成测试

我们可以直接执行视图代码，绕过 Pyramid 并且只测试我们编写的代码。这些测试使用虚拟请求，我们将适当准备这些请求来设置每个视图预期的条件，例如将虚拟数据添加到会话。我们将使用 dummy_config 配置必要的路由，并将安全策略设置为 pyramid.testing.DummySecurityPolicy 嘲弄 dummy_request.identity 。

更新 tests/test_views.py 如下所示：

from pyramid.testing import DummySecurityPolicy

from tutorial import models


def makeUser(name, role):
    return models.User(name=name, role=role)


def setUser(config, user):
    config.set_security_policy(
        DummySecurityPolicy(identity=user)
    )

def makePage(name, data, creator):
    return models.Page(name=name, data=data, creator=creator)

class Test_view_wiki:
    def _callFUT(self, request):
        from tutorial.views.default import view_wiki
        return view_wiki(request)

    def _addRoutes(self, config):
        config.add_route('view_page', '/{pagename}')

    def test_it(self, dummy_config, dummy_request):
        self._addRoutes(dummy_config)
        response = self._callFUT(dummy_request)
        assert response.location == 'http://example.com/FrontPage'

class Test_view_page:
    def _callFUT(self, request):
        from tutorial.views.default import view_page
        return view_page(request)

    def _makeContext(self, page):
        from tutorial.routes import PageResource
        return PageResource(page)

    def _addRoutes(self, config):
        config.add_route('edit_page', '/{pagename}/edit_page')
        config.add_route('add_page', '/add_page/{pagename}')
        config.add_route('view_page', '/{pagename}')

    def test_it(self, dummy_config, dummy_request, dbsession):
        # add a page to the db
        user = makeUser('foo', 'editor')
        page = makePage('IDoExist', 'Hello CruelWorld IDoExist', user)
        dbsession.add_all([page, user])

        # create a request asking for the page we've created
        self._addRoutes(dummy_config)
        dummy_request.context = self._makeContext(page)

        # call the view we're testing and check its behavior
        info = self._callFUT(dummy_request)
        assert info['page'] is page
        assert info['content'] == (
            '<div class="document">\n'
            '<p>Hello <a href="http://example.com/add_page/CruelWorld">'
            'CruelWorld</a> '
            '<a href="http://example.com/IDoExist">'
            'IDoExist</a>'
            '</p>\n</div>\n'
        )
        assert info['edit_url'] == 'http://example.com/IDoExist/edit_page'

class Test_add_page:
    def _callFUT(self, request):
        from tutorial.views.default import add_page
        return add_page(request)

    def _makeContext(self, pagename):
        from tutorial.routes import NewPage
        return NewPage(pagename)

    def _addRoutes(self, config):
        config.add_route('add_page', '/add_page/{pagename}')
        config.add_route('view_page', '/{pagename}')

    def test_get(self, dummy_config, dummy_request, dbsession):
        setUser(dummy_config, makeUser('foo', 'editor'))
        self._addRoutes(dummy_config)
        dummy_request.context = self._makeContext('AnotherPage')
        info = self._callFUT(dummy_request)
        assert info['pagedata'] == ''
        assert info['save_url'] == 'http://example.com/add_page/AnotherPage'

    def test_submit_works(self, dummy_config, dummy_request, dbsession):
        dummy_request.method = 'POST'
        dummy_request.POST['body'] = 'Hello yo!'
        dummy_request.context = self._makeContext('AnotherPage')
        setUser(dummy_config, makeUser('foo', 'editor'))
        self._addRoutes(dummy_config)
        self._callFUT(dummy_request)
        page = (
            dbsession.query(models.Page)
            .filter_by(name='AnotherPage')
            .one()
        )
        assert page.data == 'Hello yo!'

class Test_edit_page:
    def _callFUT(self, request):
        from tutorial.views.default import edit_page
        return edit_page(request)

    def _makeContext(self, page):
        from tutorial.routes import PageResource
        return PageResource(page)

    def _addRoutes(self, config):
        config.add_route('edit_page', '/{pagename}/edit_page')
        config.add_route('view_page', '/{pagename}')

    def test_get(self, dummy_config, dummy_request, dbsession):
        user = makeUser('foo', 'editor')
        page = makePage('abc', 'hello', user)
        dbsession.add_all([page, user])

        self._addRoutes(dummy_config)
        dummy_request.context = self._makeContext(page)
        info = self._callFUT(dummy_request)
        assert info['pagename'] == 'abc'
        assert info['save_url'] == 'http://example.com/abc/edit_page'

    def test_submit_works(self, dummy_config, dummy_request, dbsession):
        user = makeUser('foo', 'editor')
        page = makePage('abc', 'hello', user)
        dbsession.add_all([page, user])

        self._addRoutes(dummy_config)
        dummy_request.method = 'POST'
        dummy_request.POST['body'] = 'Hello yo!'
        setUser(dummy_config, user)
        dummy_request.context = self._makeContext(page)
        response = self._callFUT(dummy_request)
        assert response.location == 'http://example.com/abc'
        assert page.data == 'Hello yo!'

功能测试

我们将测试整个应用程序，包括单元测试和集成测试中未测试的安全方面，如登录、注销、检查 basic 用户不能编辑它没有创建的页面，但是 editor 用户可以，等等。

更新 tests/test_functional.py 如下所示：

import pytest
import transaction

from tutorial import models


basic_login = dict(login='basic', password='basic')
editor_login = dict(login='editor', password='editor')

@pytest.fixture(scope='session', autouse=True)
def dummy_data(app):
    """
    Add some dummy data to the database.

    Note that this is a session fixture that commits data to the database.
    Think about it similarly to running the ``initialize_db`` script at the
    start of the test suite.

    This data should not conflict with any other data added throughout the
    test suite or there will be issues - so be careful with this pattern!

    """
    tm = transaction.TransactionManager(explicit=True)
    with tm:
        dbsession = models.get_tm_session(app.registry['dbsession_factory'], tm)
        editor = models.User(name='editor', role='editor')
        editor.set_password('editor')
        basic = models.User(name='basic', role='basic')
        basic.set_password('basic')
        page1 = models.Page(name='FrontPage', data='This is the front page')
        page1.creator = editor
        page2 = models.Page(name='BackPage', data='This is the back page')
        page2.creator = basic
        dbsession.add_all([basic, editor, page1, page2])

def test_root(testapp):
    res = testapp.get('/', status=303)
    assert res.location == 'http://example.com/FrontPage'

def test_FrontPage(testapp):
    res = testapp.get('/FrontPage', status=200)
    assert b'FrontPage' in res.body

def test_missing_page(testapp):
    res = testapp.get('/SomePage', status=404)
    assert b'404' in res.body

def test_successful_log_in(testapp):
    params = dict(
        **basic_login,
        csrf_token=testapp.get_csrf_token(),
    )
    res = testapp.post('/login', params, status=303)
    assert res.location == 'http://example.com/'

def test_successful_log_with_next(testapp):
    params = dict(
        **basic_login,
        next='WikiPage',
        csrf_token=testapp.get_csrf_token(),
    )
    res = testapp.post('/login', params, status=303)
    assert res.location == 'http://example.com/WikiPage'

def test_failed_log_in(testapp):
    params = dict(
        login='basic',
        password='incorrect',
        csrf_token=testapp.get_csrf_token(),
    )
    res = testapp.post('/login', params, status=400)
    assert b'login' in res.body

def test_logout_link_present_when_logged_in(testapp):
    testapp.login(basic_login)
    res = testapp.get('/FrontPage', status=200)
    assert b'Logout' in res.body

def test_logout_link_not_present_after_logged_out(testapp):
    testapp.login(basic_login)
    testapp.get('/FrontPage', status=200)
    params = dict(csrf_token=testapp.get_csrf_token())
    res = testapp.post('/logout', params, status=303)
    assert b'Logout' not in res.body

def test_anonymous_user_cannot_edit(testapp):
    res = testapp.get('/FrontPage/edit_page', status=303).follow()
    assert b'Login' in res.body

def test_anonymous_user_cannot_add(testapp):
    res = testapp.get('/add_page/NewPage', status=303).follow()
    assert b'Login' in res.body

def test_basic_user_cannot_edit_front(testapp):
    testapp.login(basic_login)
    res = testapp.get('/FrontPage/edit_page', status=403)
    assert b'403' in res.body

def test_basic_user_can_edit_back(testapp):
    testapp.login(basic_login)
    res = testapp.get('/BackPage/edit_page', status=200)
    assert b'Editing' in res.body

def test_basic_user_can_add(testapp):
    testapp.login(basic_login)
    res = testapp.get('/add_page/NewPage', status=200)
    assert b'Editing' in res.body

def test_editors_member_user_can_edit(testapp):
    testapp.login(editor_login)
    res = testapp.get('/FrontPage/edit_page', status=200)
    assert b'Editing' in res.body

def test_editors_member_user_can_add(testapp):
    testapp.login(editor_login)
    res = testapp.get('/add_page/NewPage', status=200)
    assert b'Editing' in res.body

def test_editors_member_user_can_view(testapp):
    testapp.login(editor_login)
    res = testapp.get('/FrontPage', status=200)
    assert b'FrontPage' in res.body

def test_redirect_to_edit_for_existing_page(testapp):
    testapp.login(editor_login)
    res = testapp.get('/add_page/FrontPage', status=303)
    assert b'FrontPage' in res.body

运行测试

在UNIX上：

$VENV/bin/pytest -q

在Windows上：

%VENV%\Scripts\pytest -q

预期结果应如下所示：

...........................                                         [100%]
27 passed in 6.91s