Migrated requests doctests. Thanks to Stephan Jaekel.

"""

>>> from django.http import HttpRequest, HttpResponse

>>> print repr(HttpRequest())

<HttpRequest

GET:{},

POST:{},

COOKIES:{},

META:{}>

from datetime import datetime, timedelta

import time

import unittest

>>> from django.core.handlers.wsgi import WSGIRequest

>>> print repr(WSGIRequest({'PATH_INFO': 'bogus', 'REQUEST_METHOD': 'bogus'}))

<WSGIRequest

GET:<QueryDict: {}>,

POST:<QueryDict: {}>,

COOKIES:{},

META:{...}>

from django.http import HttpRequest, HttpResponse, parse_cookie

from django.core.handlers.wsgi import WSGIRequest

from django.core.handlers.modpython import ModPythonRequest

from django.utils.http import cookie_date

>>> from django.core.handlers.modpython import ModPythonRequest

>>> class FakeModPythonRequest(ModPythonRequest):

...    def __init__(self, *args, **kwargs):

...        super(FakeModPythonRequest, self).__init__(*args, **kwargs)

...        self._get = self._post = self._meta = self._cookies = {}

>>> class Dummy:

...     def get_options(self):

...         return {}

>>> req = Dummy()

>>> req.uri = 'bogus'

>>> print repr(FakeModPythonRequest(req))

<ModPythonRequest

path:bogus,

GET:{},

POST:{},

COOKIES:{},

META:{}>

class RequestsTests(unittest.TestCase):

>>> from django.http import parse_cookie

>>> parse_cookie('invalid:key=true')

{}

    def test_httprequest(self):

        self.assertEquals(repr(HttpRequest()),

            "<HttpRequest\n"\

            "GET:{},\n"\

            "POST:{},\n"\

            "COOKIES:{},\n"\

            "META:{}>"

        )

>>> request = HttpRequest()

>>> print request.build_absolute_uri(location="https://www.example.com/asdf")

https://www.example.com/asdf

>>> request.get_host = lambda: 'www.example.com'

>>> request.path = ''

>>> print request.build_absolute_uri(location="/path/with:colons")

http://www.example.com/path/with:colons

    def test_wsgirequest(self):

        self.assertEquals(repr(WSGIRequest({'PATH_INFO': 'bogus', 'REQUEST_METHOD': 'bogus'})),

            "<WSGIRequest\n"\

            "GET:<QueryDict: {}>,\n"\

            "POST:<QueryDict: {}>,\n"\

            "COOKIES:{},\n"\

            "META:{'PATH_INFO': u'bogus', 'REQUEST_METHOD': 'bogus', 'SCRIPT_NAME': u''}>"

        )

    def test_modpythonrequest(self):

        class FakeModPythonRequest(ModPythonRequest):

           def __init__(self, *args, **kwargs):

               super(FakeModPythonRequest, self).__init__(*args, **kwargs)

               self._get = self._post = self._meta = self._cookies = {}

# Test cookie datetime expiration logic

>>> from datetime import datetime, timedelta

>>> import time

>>> delta = timedelta(seconds=10)

>>> response = HttpResponse()

>>> expires = datetime.utcnow() + delta

        class Dummy:

            def get_options(self):

                return {}

        req = Dummy()

        req.uri = 'bogus'

        self.assertEquals(repr(FakeModPythonRequest(req)),

            "<ModPythonRequest\n"\

            "path:bogus,\n"\

            "GET:{},\n"\

            "POST:{},\n"\

            "COOKIES:{},\n"\

            "META:{}>")

    def test_parse_cookie(self):

        self.assertEquals(parse_cookie('invalid:key=true'), {})

    def test_httprequest_location(self):

        request = HttpRequest()

        self.assertEquals(request.build_absolute_uri(location="https://www.example.com/asdf"),

            'https://www.example.com/asdf')

        request.get_host = lambda: 'www.example.com'

        request.path = ''

        self.assertEquals(request.build_absolute_uri(location="/path/with:colons"),

            'http://www.example.com/path/with:colons')

    def test_near_expiration(self):

        "Cookie will expire when an near expiration time is provided"

        response = HttpResponse()

        # There is a timing weakness in this test; The

        # expected result for max-age requires that there be

        # a very slight difference between the evaluated expiration

        # difference doesn't exist, the cookie time will be

        # 1 second larger. To avoid the problem, put in a quick sleep,

        # which guarantees that there will be a time difference.

>>> time.sleep(0.001)

>>> response.set_cookie('datetime', expires=expires)

>>> datetime_cookie = response.cookies['datetime']

>>> datetime_cookie['max-age']

10

>>> response.set_cookie('datetime', expires=datetime(2028, 1, 1, 4, 5, 6))

>>> response.cookies['datetime']['expires']

'Sat, 01-Jan-2028 04:05:06 GMT'

        expires = datetime.utcnow() + timedelta(seconds=10)

        time.sleep(0.001)

        response.set_cookie('datetime', expires=expires)

        datetime_cookie = response.cookies['datetime']

        self.assertEquals(datetime_cookie['max-age'], 10)

    def test_far_expiration(self):

        "Cookie will expire when an distant expiration time is provided"

        response = HttpResponse()

        response.set_cookie('datetime', expires=datetime(2028, 1, 1, 4, 5, 6))

        datetime_cookie = response.cookies['datetime']

        self.assertEquals(datetime_cookie['expires'], 'Sat, 01-Jan-2028 04:05:06 GMT')

# Test automatically setting cookie expires if only max_age is provided

>>> response.set_cookie('max_age', max_age=10)

>>> max_age_cookie = response.cookies['max_age']

>>> max_age_cookie['max-age']

10

>>> from django.utils.http import cookie_date

>>> import time

>>> max_age_cookie['expires'] == cookie_date(time.time()+10)

True

"""

    def test_max_age_expiration(self):

        "Cookie will expire if max_age is provided"

        response = HttpResponse()

        response.set_cookie('max_age', max_age=10)

        max_age_cookie = response.cookies['max_age']

        self.assertEqual(max_age_cookie['max-age'], 10)

        self.assertEqual(max_age_cookie['expires'], cookie_date(time.time()+10))