A Unix-style Python web framework: filesystem routing, flat files, messages and cron, with CGI's simplicity at modern speed.

0 downloads

dbbasic-web/tests/test_request.py
Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-web.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-web.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-web.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

Dan Quellhorst Replace multipart parser with stdlib-only implementation eb957a2 9 months, 2 weeks ago History
test_request.py · 7.4 KB · 214 lines
1"""Tests for dbbasic_web.request module"""
2import pytest
3from dbbasic_web.request import Request
4
5
6class TestRequestBasicProperties:
7 """Test basic Request property access"""
8
9 def test_method_default(self):
10 """Default method should be GET"""
11 request = Request({})
12 assert request.method == 'GET'
13
14 def test_method_explicit(self):
15 """Method should return explicit value"""
16 request = Request({'method': 'POST'})
17 assert request.method == 'POST'
18
19 def test_path_default(self):
20 """Default path should be /"""
21 request = Request({})
22 assert request.path == '/'
23
24 def test_path_explicit(self):
25 """Path should return explicit value"""
26 request = Request({'path': '/users/123'})
27 assert request.path == '/users/123'
28
29 def test_body_default(self):
30 """Default body should be empty bytes"""
31 request = Request({})
32 assert request.body == b''
33
34 def test_body_explicit(self):
35 """Body should return explicit value"""
36 request = Request({'body': b'hello world'})
37 assert request.body == b'hello world'
38
39
40class TestRequestDictAccess:
41 """Test PHP-style dict access"""
42
43 def test_POST_empty(self):
44 """POST should return empty dict by default"""
45 request = Request({})
46 assert request.POST == {}
47
48 def test_POST_with_form_data(self):
49 """POST should return form data"""
50 request = Request({'form': {'username': 'alice', 'password': 'secret'}})
51 assert request.POST == {'username': 'alice', 'password': 'secret'}
52
53 def test_GET_empty(self):
54 """GET should return empty dict by default"""
55 request = Request({})
56 assert request.GET == {}
57
58 def test_GET_with_query_data(self):
59 """GET should return query string data"""
60 request = Request({'query': {'page': '1', 'limit': '10'}})
61 assert request.GET == {'page': '1', 'limit': '10'}
62
63 def test_COOKIES_empty(self):
64 """COOKIES should return empty dict by default"""
65 request = Request({})
66 assert request.COOKIES == {}
67
68 def test_COOKIES_with_data(self):
69 """COOKIES should return cookie data"""
70 request = Request({'cookies': {'session': 'abc123'}})
71 assert request.COOKIES == {'session': 'abc123'}
72
73 def test_PATH_empty(self):
74 """PATH should return empty list by default"""
75 request = Request({})
76 assert request.PATH == []
77
78 def test_PATH_with_parts(self):
79 """PATH should return path parts"""
80 request = Request({'path_parts': ['users', '123', 'edit']})
81 assert request.PATH == ['users', '123', 'edit']
82
83
84class TestRequestParam:
85 """Test param() method - Perl CGI.pm style"""
86
87 def test_param_from_POST(self):
88 """param() should return POST value first"""
89 request = Request({
90 'form': {'email': 'post@example.com'},
91 'query': {'email': 'get@example.com'}
92 })
93 assert request.param('email') == 'post@example.com'
94
95 def test_param_from_GET_when_not_in_POST(self):
96 """param() should fall back to GET"""
97 request = Request({
98 'form': {},
99 'query': {'page': '5'}
100 })
101 assert request.param('page') == '5'
102
103 def test_param_default_when_missing(self):
104 """param() should return default when key not found"""
105 request = Request({'form': {}, 'query': {}})
106 assert request.param('missing', 'default_value') == 'default_value'
107
108 def test_param_none_when_missing_no_default(self):
109 """param() should return None when key not found and no default"""
110 request = Request({'form': {}, 'query': {}})
111 assert request.param('missing') is None
112
113
114class TestRequestCookie:
115 """Test cookie() method"""
116
117 def test_cookie_exists(self):
118 """cookie() should return cookie value"""
119 request = Request({'cookies': {'session': 'token123'}})
120 assert request.cookie('session') == 'token123'
121
122 def test_cookie_missing_with_default(self):
123 """cookie() should return default when missing"""
124 request = Request({'cookies': {}})
125 assert request.cookie('session', 'none') == 'none'
126
127 def test_cookie_missing_no_default(self):
128 """cookie() should return None when missing and no default"""
129 request = Request({'cookies': {}})
130 assert request.cookie('session') is None
131
132
133class TestRequestPathParam:
134 """Test path_param() method"""
135
136 def test_path_param_valid_index(self):
137 """path_param() should return segment at index"""
138 request = Request({'path_parts': ['users', '123', 'edit']})
139 assert request.path_param(0) == 'users'
140 assert request.path_param(1) == '123'
141 assert request.path_param(2) == 'edit'
142
143 def test_path_param_out_of_bounds(self):
144 """path_param() should return default when out of bounds"""
145 request = Request({'path_parts': ['users']})
146 assert request.path_param(5, 'default') == 'default'
147
148 def test_path_param_out_of_bounds_no_default(self):
149 """path_param() should return None when out of bounds and no default"""
150 request = Request({'path_parts': ['users']})
151 assert request.path_param(5) is None
152
153
154class TestRequestFiles:
155 """Test files property for multipart uploads"""
156
157 def test_files_empty(self):
158 """files should return empty dict by default"""
159 request = Request({})
160 assert request.files == {}
161
162 def test_files_with_upload(self):
163 """files should return uploaded file data"""
164 request = Request({
165 'files': {
166 'avatar': {
167 'filename': 'photo.jpg',
168 'content': b'\xff\xd8\xff\xe0',
169 'content_type': 'image/jpeg'
170 }
171 }
172 })
173 assert 'avatar' in request.files
174 assert request.files['avatar']['filename'] == 'photo.jpg'
175 assert request.files['avatar']['content'] == b'\xff\xd8\xff\xe0'
176
177 def test_files_multiple_uploads(self):
178 """files should support multiple file uploads"""
179 request = Request({
180 'files': {
181 'doc1': {'filename': 'a.pdf', 'content': b'pdf1', 'content_type': 'application/pdf'},
182 'doc2': {'filename': 'b.pdf', 'content': b'pdf2', 'content_type': 'application/pdf'},
183 }
184 })
185 assert len(request.files) == 2
186 assert request.files['doc1']['filename'] == 'a.pdf'
187 assert request.files['doc2']['filename'] == 'b.pdf'
188
189
190class TestRequestDictCompatibility:
191 """Test that Request is still dict-compatible"""
192
193 def test_dict_access(self):
194 """Request should support dict-style access"""
195 request = Request({'method': 'POST', 'path': '/test'})
196 assert request['method'] == 'POST'
197 assert request['path'] == '/test'
198
199 def test_dict_get(self):
200 """Request should support .get()"""
201 request = Request({'method': 'POST'})
202 assert request.get('method') == 'POST'
203 assert request.get('missing', 'default') == 'default'
204
205 def test_dict_keys(self):
206 """Request should support .keys()"""
207 request = Request({'method': 'POST', 'path': '/test'})
208 assert set(request.keys()) == {'method', 'path'}
209
210 def test_dict_in_operator(self):
211 """Request should support 'in' operator"""
212 request = Request({'method': 'POST'})
213 assert 'method' in request
214 assert 'missing' not in request