askrobots / dbbasic-web
Public
A Unix-style Python web framework: filesystem routing, flat files, messages and cron, with CGI's simplicity at modern speed.
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""" |
| 2 | import pytest |
| 3 | from dbbasic_web.request import Request |
| 4 | |
| 5 | |
| 6 | class 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 | |
| 40 | class 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 | |
| 84 | class 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 | |
| 114 | class 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 | |
| 133 | class 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 | |
| 154 | class 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 | |
| 190 | class 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 |