Merge pull request #2182 from stevepiercy/1.6-branch

Steve Piercy

2015-12-14 b4e77c1fd64e4312b425ec066fbb1d479cac528b

Merge pull request #2182 from stevepiercy/1.6-branch

- Remove broken integration test example from testing and source file…

 docs/narr/MyProject/myproject/tests.py

@@ -16,31 +16,6 @@
        info = my_view(request)
        self.assertEqual(info['project'], 'MyProject')

class ViewIntegrationTests(unittest.TestCase):
    def setUp(self):
        """ This sets up the application registry with the
        registrations your application declares in its ``includeme``
        function.
        """
        self.config = testing.setUp()
        self.config.include('myproject')

    def tearDown(self):
        """ Clear out the application registry """
        testing.tearDown()

    def test_my_view(self):
        from myproject.views import my_view
        request = testing.DummyRequest()
        result = my_view(request)
        self.assertEqual(result.status, '200 OK')
        body = result.app_iter[0]
        self.assertTrue('Welcome to' in body)
        self.assertEqual(len(result.headerlist), 2)
        self.assertEqual(result.headerlist[0],
                         ('Content-Type', 'text/html; charset=UTF-8'))
        self.assertEqual(result.headerlist[1], ('Content-Length',
                                                str(len(body))))

class FunctionalTests(unittest.TestCase):
    def setUp(self):

 docs/narr/testing.rst

@@ -348,26 +348,6 @@

   See also :ref:`including_configuration`

Let's demonstrate this by showing an integration test for a view.

Given the following view definition, which assumes that your application's
:term:`package` name is ``myproject``, and within that :term:`package` there
exists a module ``views``, which in turn contains a :term:`view` function named
``my_view``:

   .. literalinclude:: MyProject/myproject/views.py
      :linenos:
      :lines: 1-6
      :language: python

You'd then create a ``tests`` module within your ``myproject`` package,
containing the following test code:

   .. literalinclude:: MyProject/myproject/tests.py
      :linenos:
      :pyobject: ViewIntegrationTests
      :language: python

Writing unit tests that use the :class:`~pyramid.config.Configurator` API to
set up the right "mock" registrations is often preferred to creating
integration tests.  Unit tests will run faster (because they do less for each
@@ -388,22 +368,53 @@

Regardless of which testing :term:`package` you use, ensure to add a
``tests_require`` dependency on that package to your application's
``setup.py`` file:
``setup.py`` file.  Using the project ``MyProject`` generated by the starter
scaffold as described in :doc:`project`, we would insert the following code immediately following the
``requires`` block in the file ``MyProject/setup.py``.

   .. literalinclude:: MyProject/setup.py
      :linenos:
      :emphasize-lines: 26-28,48
      :language: python
.. code-block:: ini
    :linenos:
    :lineno-start: 11
    :emphasize-lines: 8-

Let us assume your :term:`package` is named ``myproject`` which contains a
``views`` module, which in turn contains a :term:`view` function ``my_view``
that returns a HTML body when the root URL is invoked:
    requires = [
        'pyramid',
        'pyramid_chameleon',
        'pyramid_debugtoolbar',
        'waitress',
        ]

    test_requires = [
        'webtest',
        ]

Remember to change the dependency.

.. code-block:: ini
    :linenos:
    :lineno-start: 39
    :emphasize-lines: 2

      install_requires=requires,
      tests_require=test_requires,
      test_suite="myproject",

As always, whenever you change your dependencies, make sure to run the
following command.

.. code-block:: bash

    $VENV/bin/python setup.py develop

In your ``MyPackage`` project, your :term:`package` is named ``myproject``
which contains a ``views`` module, which in turn contains a :term:`view`
function ``my_view`` that returns an HTML body when the root URL is invoked:

   .. literalinclude:: MyProject/myproject/views.py
      :linenos:
      :language: python

Then the following example functional test demonstrates invoking the above
The following example functional test demonstrates invoking the above
:term:`view`:

   .. literalinclude:: MyProject/myproject/tests.py
@@ -414,9 +425,9 @@
When this test is run, each test method creates a "real" :term:`WSGI`
application using the ``main`` function in your ``myproject.__init__`` module,
using :term:`WebTest` to wrap that WSGI application.  It assigns the result to
``self.testapp``.  In the test named ``test_root``. The ``TestApp``'s ``GET``
``self.testapp``.  In the test named ``test_root``, the ``TestApp``'s ``GET``
method is used to invoke the root URL.  Finally, an assertion is made that the
returned HTML contains the text ``MyProject``.
returned HTML contains the text ``Pyramid``.

See the :term:`WebTest` documentation for further information about the methods
available to a :class:`webtest.app.TestApp` instance.