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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
import unittest
class TestMakeRequestASCII(unittest.TestCase):
def _callFUT(self, event):
from repoze.bfg.request import make_request_ascii
return make_request_ascii(event)
def test_it(self):
request = DummyRequest()
event = DummyNewRequestEvent(request)
self._callFUT(event)
self.assertEqual(request.charset, None)
class TestRequest(unittest.TestCase):
def _makeOne(self, environ):
return self._getTargetClass()(environ)
def _getTargetClass(self):
from repoze.bfg.request import Request
return Request
def test_params_decoded_from_utf_8_by_default(self):
environ = {
'PATH_INFO':'/',
'QUERY_STRING':'la=La%20Pe%C3%B1a'
}
request = self._makeOne(environ)
self.assertEqual(request.GET['la'], u'La Pe\xf1a')
def test_params_bystring_when_charset_None(self):
environ = {
'PATH_INFO':'/',
'QUERY_STRING':'la=La%20Pe%C3%B1a'
}
request = self._makeOne(environ)
request.charset = None
self.assertEqual(request.GET['la'], 'La Pe\xc3\xb1a')
def test_class_implements(self):
from repoze.bfg.interfaces import IRequest
klass = self._getTargetClass()
self.assertTrue(IRequest.implementedBy(klass))
def test_instance_provides(self):
from repoze.bfg.interfaces import IRequest
inst = self._makeOne({})
self.assertTrue(IRequest.providedBy(inst))
def test___contains__(self):
environ ={'zooma':1}
inst = self._makeOne(environ)
self.failUnless('zooma' in inst)
def test___delitem__(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
del inst['zooma']
self.failIf('zooma' in environ)
def test___getitem__(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
self.assertEqual(inst['zooma'], 1)
def test___iter__(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
iterator = iter(inst)
self.assertEqual(list(iterator), list(iter(environ)))
def test___setitem__(self):
environ = {}
inst = self._makeOne(environ)
inst['zooma'] = 1
self.assertEqual(environ, {'zooma':1})
def test_get(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
self.assertEqual(inst.get('zooma'), 1)
def test_has_key(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
self.assertEqual(inst.has_key('zooma'), True)
def test_items(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
self.assertEqual(inst.items(), environ.items())
def test_iteritems(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
self.assertEqual(list(inst.iteritems()), list(environ.iteritems()))
def test_iterkeys(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
self.assertEqual(list(inst.iterkeys()), list(environ.iterkeys()))
def test_itervalues(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
self.assertEqual(list(inst.itervalues()), list(environ.itervalues()))
def test_keys(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
self.assertEqual(inst.keys(), environ.keys())
def test_pop(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
popped = inst.pop('zooma')
self.assertEqual(environ, {})
self.assertEqual(popped, 1)
def test_popitem(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
popped = inst.popitem()
self.assertEqual(environ, {})
self.assertEqual(popped, ('zooma', 1))
def test_setdefault(self):
environ = {}
inst = self._makeOne(environ)
marker = []
result = inst.setdefault('a', marker)
self.assertEqual(environ, {'a':marker})
self.assertEqual(result, marker)
def test_update(self):
environ = {}
inst = self._makeOne(environ)
inst.update({'a':1}, b=2)
self.assertEqual(environ, {'a':1, 'b':2})
def test_values(self):
environ = {'zooma':1}
inst = self._makeOne(environ)
result = inst.values()
self.assertEqual(result, environ.values())
class Test_route_request_iface(unittest.TestCase):
def _callFUT(self, name):
from repoze.bfg.request import route_request_iface
return route_request_iface(name)
def test_it(self):
iface = self._callFUT('routename')
self.assertEqual(iface.__name__, 'routename_IRequest')
class Test_add_global_response_headers(unittest.TestCase):
def _callFUT(self, request, headerlist):
from repoze.bfg.request import add_global_response_headers
return add_global_response_headers(request, headerlist)
def test_it(self):
request = DummyRequest()
headers = [('a', 1), ('b', 2)]
request.global_response_headers = headers[:]
self._callFUT(request, [('c', 1)])
self.assertEqual(request.global_response_headers, headers + [('c', 1)])
class DummyRequest:
def __init__(self, environ=None):
if environ is None:
environ = {}
self.environ = environ
class DummyNewRequestEvent:
def __init__(self, request):
self.request = request
|
