Coverage (under 2.x) for _compat.

Tres Seaver

2012-03-18 a37affe2222736549e34447d1517e7171aa954f3

Coverage (under 2.x) for _compat.

 repoze/who/_compat.py

@@ -1,35 +1,39 @@
try:
    STRING_TYPES = (str, unicode)
except NameError:
except NameError: #pragma NO COVER Python >= 3.0
    STRING_TYPES = (str,)

try:
    u = unicode
    b = unicode
    b = str
except NameError: #pragma NO COVER Python >= 3.0
    u = str
    b = bytes

try:
    from base64 import decodebytes
    from base64 import encodebytes
except: # Python < 3.0
    from base64 import decodestring as decodebytes
    from base64 import encodestring as encodebytes
import base64
if 'decodebytes' in base64.__dict__: #pragma NO COVER Python >= 3.0
    decodebytes = base64.decodebytes
    encodebytes = base64.encodebytes
else:
    decodebytes = base64.decodestring
    encodebytes = base64.encodestring
del base64

try:
    from ConfigParser import ConfigParser
    from ConfigParser import ParsingError
except ImportError: #pragma NO COVER Python >= 3.0
    from configparser import ConfigParser
    from configparser import ParsingError
else:
    from ConfigParser import ParsingError

try:
    from Cookie import SimpleCookie
    from Cookie import CookieError
except ImportError: #pragma NO COVER Python >= 3.0
    from http.cookies import SimpleCookie
    from http.cookies import CookieError
else:
    from Cookie import CookieError

try:
    from itertools import izip_longest
@@ -43,19 +47,21 @@

try:
    from urllib import urlencode
    from urllib import quote as url_quote
    from urllib import unquote as url_unquote
except ImportError: #pragma NO COVER Python >= 3.0
    from urllib.parse import urlencode
    from urllib.parse import quote as url_quote
    from urllib.parse import unquote as url_unquote
else:
    from urllib import quote as url_quote
    from urllib import unquote as url_unquote

try:
    from urlparse import urlparse
    from urlparse import urlunparse
except ImportError: #pragma NO COVER Python >= 3.0
    from urllib.parse import urlparse
    from urllib.parse import urlunparse
else:
    from urlparse import urlunparse

import wsgiref.util
import wsgiref.headers
@@ -74,14 +80,14 @@

def get_cookies(environ):
    header = environ.get('HTTP_COOKIE', '')
    if 'paste-cookies' in environ:
    if 'paste.cookies' in environ:
        cookies, check_header = environ['paste.cookies']
        if check_header == header:
            return cookies
    cookies = SimpleCookie()
    try:
        cookies.load(header)
    except CookieError:
    except CookieError: #pragma NO COVER (can't see how to provoke this)
        pass
    environ['paste.cookies'] = (cookies, header)
    return cookies

 repoze/who/tests/test__compat.py

New file
@@ -0,0 +1,96 @@
import unittest

class CompatTests(unittest.TestCase):

    def failUnless(self, predicate, message=''):
        self.assertTrue(predicate, message) # Nannies go home!

    def failIf(self, predicate, message=''):
        self.assertFalse(predicate, message) # Nannies go home!

    def test_REQUEST_METHOD_miss(self):
        from .._compat import REQUEST_METHOD
        self.assertRaises(KeyError, REQUEST_METHOD, {})

    def test_REQUEST_METHOD_hit(self):
        from .._compat import REQUEST_METHOD
        self.assertEqual(REQUEST_METHOD({'REQUEST_METHOD': 'FOO'}), 'FOO')

    def test_CONTENT_TYPE_miss(self):
        from .._compat import CONTENT_TYPE
        self.assertRaises(KeyError, CONTENT_TYPE, {})

    def test_CONTENT_TYPE_hit(self):
        from .._compat import CONTENT_TYPE
        self.assertEqual(CONTENT_TYPE({'CONTENT_TYPE': 'text/html'}),
                         'text/html')

    def test_USER_AGENT_miss(self):
        from .._compat import USER_AGENT
        self.assertEqual(USER_AGENT({}), None)

    def test_USER_AGENT_hit(self):
        from .._compat import USER_AGENT
        self.assertEqual(USER_AGENT({'HTTP_USER_AGENT': 'FOO'}), 'FOO')

    def test_AUTHORIZATION_miss(self):
        from .._compat import AUTHORIZATION
        self.assertEqual(AUTHORIZATION({}), '')

    def test_AUTHORIZATION_hit(self):
        from .._compat import AUTHORIZATION
        self.assertEqual(AUTHORIZATION({'HTTP_AUTHORIZATION': 'FOO'}), 'FOO')

    def test_get_cookies_no_cache_ok_header_value(self):
        from .._compat import get_cookies
        from .._compat import SimpleCookie
        environ = {'HTTP_COOKIE': 'qux=spam'}
        cookies = get_cookies(environ)
        self.failUnless(isinstance(cookies, SimpleCookie))
        self.assertEqual(len(cookies), 1)
        self.assertEqual(cookies['qux'].value, 'spam')
        self.assertEqual(environ['paste.cookies'], (cookies, 'qux=spam'))

    def test_get_cookies_w_cache_miss(self):
        from .._compat import get_cookies
        from .._compat import SimpleCookie
        environ = {'HTTP_COOKIE': 'qux=spam',
                   'paste.cookies': (object(), 'foo=bar'),
                  }
        cookies = get_cookies(environ)
        self.failUnless(isinstance(cookies, SimpleCookie))
        self.assertEqual(len(cookies), 1)
        self.assertEqual(cookies['qux'].value, 'spam')
        self.assertEqual(environ['paste.cookies'], (cookies, 'qux=spam'))

    def test_get_cookies_w_cache_hit(self):
        from .._compat import get_cookies
        from .._compat import SimpleCookie
        existing = SimpleCookie()
        existing['foo'] = 'bar'
        environ = {'HTTP_COOKIE': 'qux=spam',
                   'paste.cookies': (existing, 'qux=spam'),
                  }
        cookies = get_cookies(environ)
        self.failUnless(cookies is existing)

    def test_construct_url(self):
        from .._compat import construct_url
        environ = {'wsgi.url_scheme': 'http',
                   'HTTP_HOST': 'example.com',
                  }
        self.assertEqual(construct_url(environ), 'http://example.com/')

    def test_header_value_miss(self):
        from .._compat import header_value
        self.assertEqual(header_value([], 'nonesuch'), '')

    def test_header_value_list(self):
        from .._compat import header_value
        self.assertEqual(header_value([('listed', ['a', 'b'])], 'listed'),
                         'a,b')

    def test_header_value_simple(self):
        from .._compat import header_value
        self.assertEqual(header_value([('simple', 'SIMPLE')], 'simple'),
                         'SIMPLE')