Fixed #12226 -- Deprecated test client Response.template attribute in favor of...

import os

import re

import mimetypes

import warnings

try:

    from cStringIO import StringIO

except ImportError:

    """

    Stores templates and contexts that are rendered.

    """

    store.setdefault('template', []).append(template)

    store.setdefault('templates', []).append(template)

    store.setdefault('context', ContextList()).append(context)

def encode_multipart(boundary, data):

            response.request = request

            # Add any rendered template detail to the response.

            # If there was only one template rendered (the most likely case),

            # flatten the list to a single element.

            for detail in ('template', 'context'):

                if data.get(detail):

                    if len(data[detail]) == 1:

                        setattr(response, detail, data[detail][0]);

                    else:

                        setattr(response, detail, data[detail])

                else:

                    setattr(response, detail, None)

            response.templates = data.get("templates", [])

            response.context = data.get("context")

            # Flatten a single context. Not really necessary anymore thanks to

            # the __getattr__ flattening in ContextList, but has some edge-case

            # backwards-compatibility implications.

            if response.context and len(response.context) == 1:

                response.context = response.context[0]

            # Provide a backwards-compatible (but pending deprecation) response.template

            def _get_template(self):

                warnings.warn("response.template is deprecated; use response.templates instead (which is always a list)",

                              PendingDeprecationWarning)

                if not self.templates:

                    return None

                elif len(self.templates) == 1:

                    return self.templates[0]

                return self.templates

            response.__class__.template = property(_get_template)

            # Update persistent cookie data.

            if response.cookies:

        if msg_prefix:

            msg_prefix += ": "

        template_names = [t.name for t in to_list(response.template)]

        template_names = [t.name for t in response.templates]

        if not template_names:

            self.fail(msg_prefix + "No templates used to render the response")

        self.failUnless(template_name in template_names,

        if msg_prefix:

            msg_prefix += ": "

        template_names = [t.name for t in to_list(response.template)]

        template_names = [t.name for t in response.templates]

        self.failIf(template_name in template_names,

            msg_prefix + "Template '%s' was used unexpectedly in rendering"

            " the response" % template_name)

        * The ``mod_python`` request handler has been deprecated since the 1.3

          release. The ``mod_wsgi`` handler should be used instead.

        * The ``template`` attribute on :class:`~django.test.client.Response`

          objects returned by the :ref:`test client <test-client>` has been

          deprecated since the 1.3 release. The

          :attr:`~django.test.client.Response.templates` attribute should be

          used instead.

    * 2.0

        * ``django.views.defaults.shortcut()``. This function has been moved

          to ``django.contrib.contenttypes.views.shortcut()`` as part of the

encouraged you redeploy your Django instances using :doc:`mod_wsgi

</howto/deployment/modwsgi>`.

Test client response ``template`` attribute

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Django's :ref:`test client <test-client>` returns

:class:`~django.test.client.Response` objects annotated with extra testing

information. In Django versions prior to 1.3, this included a

:attr:`~django.test.client.Response.template` attribute containing information

about templates rendered in generating the response: either None, a single

:class:`~django.template.Template` object, or a list of

:class:`~django.template.Template` objects. This inconsistency in return values

(sometimes a list, sometimes not) made the attribute difficult to work with.

In Django 1.3 the :attr:`~django.test.client.Response.template` attribute is

deprecated in favor of a new :attr:`~django.test.client.Response.templates`

attribute, which is always a list, even if it has only a single element or no

elements.

What's new in Django 1.3

========================

Django provides a small set of tools that come in handy when writing tests.

.. _test-client:

The test client

---------------

        The HTTP status of the response, as an integer. See RFC2616_ for a full

        list of HTTP status codes.

    .. attribute:: template

    .. versionadded:: 1.3

    .. attribute:: templates

        The ``Template`` instance that was used to render the final content. Use

        A list of ``Template`` instances used to render the final content, in

        the order they were rendered. For each template in the list, use

        ``template.name`` to get the template's file name, if the template was

        loaded from a file. (The name is a string such as ``'admin/index.html'``.)

        If the rendered page used multiple templates -- e.g., using :ref:`template

        inheritance<template-inheritance>` -- then ``template`` will be a list of

        ``Template`` instances, in the order in which they were rendered.

        loaded from a file. (The name is a string such as

        ``'admin/index.html'``.)

You can also use dictionary syntax on the response object to query the value

of any settings in the HTTP headers. For example, you could determine the