Throw in towel on unit test assertion names.

Tres Seaver

2014-12-12 826ba007a16d4a2558239ab690dd1d52c9de6633

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import unittest
 
 
class CompatTests(unittest.TestCase):
 
    def test_REQUEST_METHOD_miss(self):
        # PEP 3333 says CONTENT_TYPE is mandatory
        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):
        # PEP 3333 says CONTENT_TYPE is optional
        from .._compat import CONTENT_TYPE
        self.assertEqual(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.assertTrue(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.assertTrue(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.assertTrue(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_simple(self):
        from .._compat import header_value
        self.assertEqual(header_value([('simple', 'SIMPLE')], 'simple'),
                         'SIMPLE')
 
    def test_must_decode_non_string(self):
        from .._compat import must_decode
        foo = object()
        self.assertTrue(must_decode(foo) is foo)
 
    def test_must_decode_unicode(self):
        from .._compat import must_decode
        from .._compat import u
        foo = u('foo')
        self.assertTrue(must_decode(foo) is foo)
 
    def test_must_decode_utf8(self):
        from .._compat import must_decode
        foo = b'b\xc3\xa2tard'
        self.assertEqual(must_decode(foo), foo.decode('utf-8'))
 
    def test_must_decode_latin1(self):
        from .._compat import must_decode
        foo = b'b\xe2tard'
        self.assertEqual(must_decode(foo), foo.decode('latin1'))
 
    def test_must_encode_non_string(self):
        from .._compat import must_encode
        foo = object()
        self.assertTrue(must_encode(foo) is foo)
 
    def test_must_encode_unicode(self):
        from .._compat import must_encode
        from .._compat import u
        foo = u('foo')
        self.assertEqual(must_encode(foo), foo.encode('utf-8'))
 
    def test_must_encode_utf8(self):
        from .._compat import must_encode
        foo = b'b\xc3\xa2tard'
        self.assertTrue(must_encode(foo) is foo)
 
    def test_must_encode_latin1(self):
        from .._compat import must_encode
        foo = b'b\xe2tard'
        self.assertTrue(must_encode(foo) is foo)