8 | """
9 | import importlib
10 | import io
11 | import json
12 | import logging
13 | import os
14 | import sys
15 | import traceback
16 | from werkzeug.exceptions import InternalServerError
17 |
18 | # Call decompression helper from `serverless-python-requirements` if
19 | # available. See: https://github.com/UnitedIncome/serverless-python-requirements#dealing-with-lambdas-size-limitations
20 | try:
21 | import unzip_requirements # noqa
22 | except ImportError:
23 | pass
24 |
25 | import serverless_wsgi
26 |
27 |
28 | def load_config():
29 | """Read the configuration file created during deployment"""
30 | root = os.path.abspath(os.path.dirname(__file__))
31 | with open(os.path.join(root, ".serverless-wsgi"), "r") as f:
32 | return json.loads(f.read())
33 |
34 |
35 | def import_app(config):
36 | """Load the application WSGI handler"""
37 | wsgi_fqn = config["app"].rsplit(".", 1)
38 | wsgi_fqn_parts = wsgi_fqn[0].rsplit("/", 1)
39 |
40 | if len(wsgi_fqn_parts) == 2:
41 | root = os.path.abspath(os.path.dirname(__file__))
42 | sys.path.insert(0, os.path.join(root, wsgi_fqn_parts[0]))
43 |
44 | try:
45 | wsgi_module = importlib.import_module(wsgi_fqn_parts[-1])
46 |
47 | return getattr(wsgi_module, wsgi_fqn[1])
48 | except Exception as err:
49 | logging.exception("Unable to import app: '{}' - {}".format(config["app"], err))
50 | return InternalServerError("Unable to import app: {}".format(config["app"]))
51 |
52 |
53 | def append_text_mime_types(config):
54 | """Append additional text (non-base64) mime types from configuration file"""
55 | if "text_mime_types" in config and isinstance(config["text_mime_types"], list):
56 | serverless_wsgi.TEXT_MIME_TYPES.extend(config["text_mime_types"])
57 |
58 |
59 | def handler(event, context):
60 | """Lambda event handler, invokes the WSGI wrapper and handles command invocation"""
61 | if "_serverless-wsgi" in event:
62 | import shlex
63 | import subprocess
64 |
65 | native_stdout = sys.stdout
66 | native_stderr = sys.stderr
67 | output_buffer = io.StringIO()
68 |
69 | try:
70 | sys.stdout = output_buffer
71 | sys.stderr = output_buffer
72 |
73 | meta = event["_serverless-wsgi"]
74 | if meta.get("command") == "exec":
75 | # Evaluate Python code
76 | exec(meta.get("data", ""))
77 | elif meta.get("command") == "command":
78 | # Run shell commands
79 | result = subprocess.check_output(
80 | meta.get("data", ""), shell=True, stderr=subprocess.STDOUT
81 | )
82 | output_buffer.write(result.decode())
83 | elif meta.get("command") == "manage":
84 | # Run Django management commands
85 | from django.core import management
86 |
87 | management.call_command(*shlex.split(meta.get("data", "")))
88 | elif meta.get("command") == "flask":
89 | # Run Flask CLI commands
90 | from flask.cli import FlaskGroup
91 |
92 | flask_group = FlaskGroup(create_app=_create_app)
93 | flask_group.main(
94 | shlex.split(meta.get("data", "")), standalone_mode=False
95 | )
96 | else:
97 | raise Exception("Unknown command: {}".format(meta.get("command")))
98 | except subprocess.CalledProcessError as e:
99 | return [e.returncode, e.output.decode("utf-8")]
100 | except: # noqa
101 | return [1, traceback.format_exc()]
102 | finally:
103 | sys.stdout = native_stdout
104 | sys.stderr = native_stderr
105 |
106 | return [0, output_buffer.getvalue()]
107 | else:
108 | return serverless_wsgi.handle_request(wsgi_app, event, context)
109 |
110 |
111 | def _create_app():
112 | return wsgi_app
113 |
114 |
115 | # Read configuration and import the WSGI application
116 | config = load_config()
117 | wsgi_app = import_app(config)
118 | append_text_mime_types(config)
119 |
--------------------------------------------------------------------------------
/wsgi_handler_test.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 | import builtins
4 | import importlib
5 | import json
6 | import os
7 | import pytest
8 | import sys
9 | from urllib.parse import urlencode
10 | from werkzeug.wrappers import Request, Response
11 |
12 | # Reference to open() before monkeypatching
13 | original_open = open
14 |
15 | # This workaround is needed for coverage.py to pick up the wsgi handler module
16 | try:
17 | import wsgi_handler # noqa: F401
18 | except: # noqa: E722
19 | pass
20 |
21 |
22 | class MockApp:
23 | def __init__(self):
24 | self.cookie_count = 3
25 | self.response_mimetype = "text/plain"
26 | self.status_code = 200
27 |
28 | def __call__(self, environ, start_response):
29 | self.last_environ = environ
30 | response = Response("Hello World ☃!", mimetype=self.response_mimetype)
31 | cookies = [
32 | ("CUSTOMER", "WILE_E_COYOTE"),
33 | ("PART_NUMBER", "ROCKET_LAUNCHER_0002"),
34 | ("LOT_NUMBER", "42"),
35 | ]
36 | for cookie in cookies[: self.cookie_count]:
37 | response.set_cookie(cookie[0], cookie[1])
38 | print("application debug #1", file=environ["wsgi.errors"])
39 | response.status_code = self.status_code
40 | return response(environ, start_response)
41 |
42 |
43 | class MockFile:
44 | def __init__(self):
45 | self.contents = None
46 |
47 | def __enter__(self):
48 | return self
49 |
50 | def __exit__(self, *args):
51 | pass
52 |
53 | def read(self):
54 | return self.contents
55 |
56 | def write(self, data):
57 | self.contents = data
58 |
59 |
60 | class MockFileManager:
61 | def __init__(self):
62 | self.files = {}
63 |
64 | def open(self, name, mode="r", buffering=-1, **options):
65 | if name not in self.files:
66 | if mode.startswith("r"): # pragma: no cover
67 | return original_open(name, mode, buffering, **options)
68 | else:
69 | self.files[name] = MockFile()
70 |
71 | return self.files[name]
72 |
73 |
74 | @pytest.fixture
75 | def mock_app(monkeypatch):
76 | mock_app = MockApp()
77 |
78 | def mock_importlib(module):
79 | class MockObject:
80 | pass
81 |
82 | app = MockObject()
83 | app.app = mock_app
84 | app.app.module = module
85 | return app
86 |
87 | monkeypatch.setattr(importlib, "import_module", mock_importlib)
88 |
89 | return mock_app
90 |
91 |
92 | @pytest.fixture
93 | def mock_app_with_import_error(monkeypatch):
94 | def mock_importlib(module):
95 | raise ImportError("No module named {}".format(module))
96 |
97 | monkeypatch.setattr(importlib, "import_module", mock_importlib)
98 |
99 |
100 | @pytest.fixture
101 | def mock_wsgi_app_file(monkeypatch):
102 | monkeypatch.setattr(os.path, "abspath", lambda x: "/tmp")
103 |
104 | manager = MockFileManager()
105 | with manager.open("/tmp/.serverless-wsgi", "w") as f:
106 | f.write(json.dumps({"app": "app.app"}))
107 | monkeypatch.setattr(builtins, "open", manager.open)
108 |
109 |
110 | @pytest.fixture
111 | def mock_subdir_wsgi_app_file(monkeypatch):
112 | monkeypatch.setattr(os.path, "abspath", lambda x: "/tmp")
113 |
114 | manager = MockFileManager()
115 | with manager.open("/tmp/.serverless-wsgi", "w") as f:
116 | f.write(json.dumps({"app": "subdir/app.app"}))
117 | monkeypatch.setattr(builtins, "open", manager.open)
118 |
119 |
120 | @pytest.fixture
121 | def mock_text_mime_wsgi_app_file(monkeypatch):
122 | monkeypatch.setattr(os.path, "abspath", lambda x: "/tmp")
123 |
124 | manager = MockFileManager()
125 | with manager.open("/tmp/.serverless-wsgi", "w") as f:
126 | f.write(
127 | json.dumps(
128 | {"app": "app.app", "text_mime_types": [
129 | "application/custom+json"]}
130 | )
131 | )
132 | monkeypatch.setattr(builtins, "open", manager.open)
133 |
134 |
135 | @pytest.fixture
136 | def event_v1():
137 | return {
138 | "body": None,
139 | "headers": {
140 | "Accept": "*/*",
141 | "Accept-Encoding": "gzip, deflate",
142 | "CloudFront-Forwarded-Proto": "https",
143 | "CloudFront-Is-Desktop-Viewer": "true",
144 | "CloudFront-Is-Mobile-Viewer": "false",
145 | "CloudFront-Is-SmartTV-Viewer": "false",
146 | "CloudFront-Is-Tablet-Viewer": "false",
147 | "CloudFront-Viewer-Country": "DK",
148 | "Cookie": "CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKET_LAUNCHER_0001",
149 | "Host": "3z6kd9fbb1.execute-api.us-east-1.amazonaws.com",
150 | "Postman-Token": "778a706e-d6b0-48d5-94dd-9e98c22f12fe",
151 | "User-Agent": "PostmanRuntime/3.0.11-hotfix.2",
152 | "Via": "1.1 b8fa.cloudfront.net (CloudFront)",
153 | "X-Amz-Cf-Id": "jx0Bvz9rm--Mz3wAj4i46FdOQQK3RHF4H0moJjBsQ==",
154 | "X-Amzn-Trace-Id": "Root=1-58d534a5-1e7cffe644b086304dce7a1e",
155 | "X-Forwarded-For": "76.20.166.147, 205.251.218.72",
156 | "X-Forwarded-Port": "443",
157 | "X-Forwarded-Proto": "https",
158 | "cache-control": "no-cache",
159 | },
160 | "httpMethod": "GET",
161 | "isBase64Encoded": False,
162 | "path": "/some/path",
163 | "pathParameters": {"proxy": "some/path"},
164 | "queryStringParameters": {"param1": "value1", "param2": "value2"},
165 | "requestContext": {
166 | "accountId": "16794",
167 | "apiId": "3z6kd9fbb1",
168 | "httpMethod": "GET",
169 | "identity": {
170 | "accessKey": None,
171 | "accountId": None,
172 | "apiKey": None,
173 | "caller": None,
174 | "cognitoAuthenticationProvider": None,
175 | "cognitoAuthenticationType": None,
176 | "cognitoIdentityId": None,
177 | "cognitoIdentityPoolId": None,
178 | "sourceIp": "76.20.166.147",
179 | "user": None,
180 | "userAgent": "PostmanRuntime/3.0.11-hotfix.2",
181 | "userArn": None,
182 | },
183 | "authorizer": {"principalId": "wile_e_coyote"},
184 | "requestId": "ad2db740-10a2-11e7-8ced-35048084babb",
185 | "resourceId": "r4kza9",
186 | "resourcePath": "/{proxy+}",
187 | "stage": "dev",
188 | },
189 | "resource": "/{proxy+}",
190 | "stageVariables": None,
191 | }
192 |
193 |
194 | @pytest.fixture
195 | def event_v1_offline(event_v1):
196 | event = event_v1
197 | del event["body"]
198 | return event
199 |
200 |
201 | @pytest.fixture
202 | def elb_event():
203 | return {
204 | "requestContext": {
205 | "elb": {
206 | "targetGroupArn": "arn:aws:elasticloadbalancing:us-east-1:12345:targetgroup/xxxx/5e43816d76759862"
207 | }
208 | },
209 | "httpMethod": "GET",
210 | "path": "/cats",
211 | "queryStringParameters": {},
212 | "headers": {
213 | "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
214 | "accept-encoding": "gzip, deflate",
215 | "accept-language": "en-US,en;q=0.9,da;q=0.8",
216 | "cache-control": "max-age=0",
217 | "connection": "keep-alive",
218 | "host": "xxxx-203391234.us-east-1.elb.amazonaws.com",
219 | "upgrade-insecure-requests": "1",
220 | "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36",
221 | "x-amzn-trace-id": "Root=1-5f05949b-77e2b0f9434e2acbf5ad8ce8",
222 | "x-forwarded-for": "95.181.37.218",
223 | "x-forwarded-port": "80",
224 | "x-forwarded-proto": "http",
225 | },
226 | "body": "",
227 | "isBase64Encoded": False,
228 | }
229 |
230 |
231 | @pytest.fixture # noqa: F811
232 | def wsgi_handler(): # noqa: F811
233 | if "wsgi_handler" in sys.modules:
234 | del sys.modules["wsgi_handler"]
235 | import wsgi_handler
236 |
237 | return wsgi_handler
238 |
239 |
240 | def test_handler(mock_wsgi_app_file, mock_app, event_v1, capsys, wsgi_handler):
241 | response = wsgi_handler.handler(event_v1, {"memory_limit_in_mb": "128"})
242 |
243 | assert response == {
244 | "body": "Hello World ☃!",
245 | "headers": {
246 | "set-cookie": "CUSTOMER=WILE_E_COYOTE; Path=/",
247 | "Content-Length": "16",
248 | "Content-Type": "text/plain; charset=utf-8",
249 | "sEt-cookie": "LOT_NUMBER=42; Path=/",
250 | "Set-cookie": "PART_NUMBER=ROCKET_LAUNCHER_0002; Path=/",
251 | },
252 | "statusCode": 200,
253 | "isBase64Encoded": False,
254 | }
255 |
256 | assert wsgi_handler.wsgi_app.last_environ == {
257 | "CONTENT_LENGTH": "0",
258 | "CONTENT_TYPE": "",
259 | "HTTP_ACCEPT": "*/*",
260 | "HTTP_ACCEPT_ENCODING": "gzip, deflate",
261 | "HTTP_CACHE_CONTROL": "no-cache",
262 | "HTTP_CLOUDFRONT_FORWARDED_PROTO": "https",
263 | "HTTP_CLOUDFRONT_IS_DESKTOP_VIEWER": "true",
264 | "HTTP_CLOUDFRONT_IS_MOBILE_VIEWER": "false",
265 | "HTTP_CLOUDFRONT_IS_SMARTTV_VIEWER": "false",
266 | "HTTP_CLOUDFRONT_IS_TABLET_VIEWER": "false",
267 | "HTTP_CLOUDFRONT_VIEWER_COUNTRY": "DK",
268 | "HTTP_COOKIE": "CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKET_LAUNCHER_0001",
269 | "HTTP_HOST": "3z6kd9fbb1.execute-api.us-east-1.amazonaws.com",
270 | "HTTP_POSTMAN_TOKEN": "778a706e-d6b0-48d5-94dd-9e98c22f12fe",
271 | "HTTP_USER_AGENT": "PostmanRuntime/3.0.11-hotfix.2",
272 | "HTTP_VIA": "1.1 b8fa.cloudfront.net (CloudFront)",
273 | "HTTP_X_AMZN_TRACE_ID": "Root=1-58d534a5-1e7cffe644b086304dce7a1e",
274 | "HTTP_X_AMZ_CF_ID": "jx0Bvz9rm--Mz3wAj4i46FdOQQK3RHF4H0moJjBsQ==",
275 | "HTTP_X_FORWARDED_FOR": "76.20.166.147, 205.251.218.72",
276 | "HTTP_X_FORWARDED_PORT": "443",
277 | "HTTP_X_FORWARDED_PROTO": "https",
278 | "PATH_INFO": "/some/path",
279 | "QUERY_STRING": urlencode(event_v1["queryStringParameters"], doseq=True),
280 | "REMOTE_ADDR": "76.20.166.147",
281 | "REMOTE_USER": "wile_e_coyote",
282 | "REQUEST_METHOD": "GET",
283 | "SCRIPT_NAME": "/dev",
284 | "SERVER_NAME": "3z6kd9fbb1.execute-api.us-east-1.amazonaws.com",
285 | "SERVER_PORT": "443",
286 | "SERVER_PROTOCOL": "HTTP/1.1",
287 | "wsgi.errors": wsgi_handler.wsgi_app.last_environ["wsgi.errors"],
288 | "wsgi.input": wsgi_handler.wsgi_app.last_environ["wsgi.input"],
289 | "wsgi.multiprocess": False,
290 | "wsgi.multithread": False,
291 | "wsgi.run_once": False,
292 | "wsgi.url_scheme": "https",
293 | "wsgi.version": (1, 0),
294 | "serverless.authorizer": {"principalId": "wile_e_coyote"},
295 | "serverless.context": {"memory_limit_in_mb": "128"},
296 | "serverless.event": event_v1,
297 | }
298 |
299 | out, err = capsys.readouterr()
300 | assert out == ""
301 | assert err == "application debug #1\n"
302 |
303 |
304 | def test_handler_offline(mock_wsgi_app_file, mock_app, event_v1_offline, wsgi_handler):
305 | response = wsgi_handler.handler(
306 | event_v1_offline, {"memory_limit_in_mb": "128"})
307 |
308 | assert response["body"] == "Hello World ☃!"
309 |
310 |
311 | def test_handler_multivalue(
312 | mock_wsgi_app_file, mock_app, event_v1, capsys, wsgi_handler
313 | ):
314 | event_v1["multiValueQueryStringParameters"] = {
315 | "param1": ["value1"],
316 | "param2": ["value2", "value3"],
317 | }
318 |
319 | # Convert regular headers request to multiValueHeaders
320 | multi_headers = {}
321 | for key, value in event_v1["headers"].items():
322 | if key not in multi_headers:
323 | multi_headers[key] = []
324 | multi_headers[key].append(value)
325 |
326 | event_v1["multiValueHeaders"] = multi_headers
327 | response = wsgi_handler.handler(event_v1, {"memory_limit_in_mb": "128"})
328 | query_string = wsgi_handler.wsgi_app.last_environ["QUERY_STRING"]
329 |
330 | print(query_string)
331 | assert query_string == urlencode(
332 | [
333 | (i, k)
334 | for i, j in event_v1["multiValueQueryStringParameters"].items()
335 | for k in j
336 | ],
337 | doseq=True
338 | )
339 |
340 | assert response == {
341 | "body": "Hello World ☃!",
342 | "multiValueHeaders": {
343 | "Content-Length": ["16"],
344 | "Content-Type": ["text/plain; charset=utf-8"],
345 | "Set-Cookie": [
346 | "CUSTOMER=WILE_E_COYOTE; Path=/",
347 | "PART_NUMBER=ROCKET_LAUNCHER_0002; Path=/",
348 | "LOT_NUMBER=42; Path=/",
349 | ],
350 | },
351 | "statusCode": 200,
352 | "isBase64Encoded": False,
353 | }
354 |
355 |
356 | def test_handler_china(mock_wsgi_app_file, mock_app, event_v1, capsys, wsgi_handler):
357 | event_v1["headers"]["Host"] = "x.amazonaws.com.cn"
358 | wsgi_handler.handler(event_v1, {"memory_limit_in_mb": "128"})
359 |
360 | assert wsgi_handler.wsgi_app.last_environ["SCRIPT_NAME"] == "/dev"
361 |
362 |
363 | def test_handler_single_cookie(mock_wsgi_app_file, mock_app, event_v1, wsgi_handler):
364 | wsgi_handler.wsgi_app.cookie_count = 1
365 | response = wsgi_handler.handler(event_v1, {})
366 |
367 | assert response == {
368 | "body": "Hello World ☃!",
369 | "headers": {
370 | "Set-Cookie": "CUSTOMER=WILE_E_COYOTE; Path=/",
371 | "Content-Length": "16",
372 | "Content-Type": "text/plain; charset=utf-8",
373 | },
374 | "statusCode": 200,
375 | "isBase64Encoded": False,
376 | }
377 |
378 |
379 | def test_handler_no_cookie(mock_wsgi_app_file, mock_app, event_v1, wsgi_handler):
380 | wsgi_handler.wsgi_app.cookie_count = 0
381 | response = wsgi_handler.handler(event_v1, {})
382 |
383 | assert response == {
384 | "body": "Hello World ☃!",
385 | "headers": {
386 | "Content-Length": "16",
387 | "Content-Type": "text/plain; charset=utf-8",
388 | },
389 | "statusCode": 200,
390 | "isBase64Encoded": False,
391 | }
392 |
393 |
394 | def test_handler_schedule(mock_wsgi_app_file, mock_app, event_v1, wsgi_handler):
395 | event_v1 = {"source": "aws.events"}
396 | response = wsgi_handler.handler(event_v1, {})
397 | assert response == {}
398 |
399 |
400 | def test_handler_warmup_plugin(
401 | mock_wsgi_app_file, mock_app, event_v1, wsgi_handler, capsys
402 | ):
403 | event_v1 = {"source": "serverless-plugin-warmup"}
404 | response = wsgi_handler.handler(event_v1, {})
405 | assert response == {}
406 |
407 | out, err = capsys.readouterr()
408 | assert out == "Lambda warming event received, skipping handler\n"
409 | assert err == ""
410 |
411 |
412 | def test_handler_custom_domain(mock_wsgi_app_file, mock_app, event_v1, wsgi_handler):
413 | event_v1["headers"]["Host"] = "custom.domain.com"
414 | wsgi_handler.handler(event_v1, {})
415 |
416 | assert wsgi_handler.wsgi_app.last_environ == {
417 | "CONTENT_LENGTH": "0",
418 | "CONTENT_TYPE": "",
419 | "HTTP_ACCEPT": "*/*",
420 | "HTTP_ACCEPT_ENCODING": "gzip, deflate",
421 | "HTTP_CACHE_CONTROL": "no-cache",
422 | "HTTP_CLOUDFRONT_FORWARDED_PROTO": "https",
423 | "HTTP_CLOUDFRONT_IS_DESKTOP_VIEWER": "true",
424 | "HTTP_CLOUDFRONT_IS_MOBILE_VIEWER": "false",
425 | "HTTP_CLOUDFRONT_IS_SMARTTV_VIEWER": "false",
426 | "HTTP_CLOUDFRONT_IS_TABLET_VIEWER": "false",
427 | "HTTP_CLOUDFRONT_VIEWER_COUNTRY": "DK",
428 | "HTTP_COOKIE": "CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKET_LAUNCHER_0001",
429 | "HTTP_HOST": "custom.domain.com",
430 | "HTTP_POSTMAN_TOKEN": "778a706e-d6b0-48d5-94dd-9e98c22f12fe",
431 | "HTTP_USER_AGENT": "PostmanRuntime/3.0.11-hotfix.2",
432 | "HTTP_VIA": "1.1 b8fa.cloudfront.net (CloudFront)",
433 | "HTTP_X_AMZN_TRACE_ID": "Root=1-58d534a5-1e7cffe644b086304dce7a1e",
434 | "HTTP_X_AMZ_CF_ID": "jx0Bvz9rm--Mz3wAj4i46FdOQQK3RHF4H0moJjBsQ==",
435 | "HTTP_X_FORWARDED_FOR": "76.20.166.147, 205.251.218.72",
436 | "HTTP_X_FORWARDED_PORT": "443",
437 | "HTTP_X_FORWARDED_PROTO": "https",
438 | "PATH_INFO": "/some/path",
439 | "QUERY_STRING": urlencode(event_v1["queryStringParameters"], doseq=True),
440 | "REMOTE_ADDR": "76.20.166.147",
441 | "REMOTE_USER": "wile_e_coyote",
442 | "REQUEST_METHOD": "GET",
443 | "SCRIPT_NAME": "",
444 | "SERVER_NAME": "custom.domain.com",
445 | "SERVER_PORT": "443",
446 | "SERVER_PROTOCOL": "HTTP/1.1",
447 | "wsgi.errors": wsgi_handler.wsgi_app.last_environ["wsgi.errors"],
448 | "wsgi.input": wsgi_handler.wsgi_app.last_environ["wsgi.input"],
449 | "wsgi.multiprocess": False,
450 | "wsgi.multithread": False,
451 | "wsgi.run_once": False,
452 | "wsgi.url_scheme": "https",
453 | "wsgi.version": (1, 0),
454 | "serverless.authorizer": {"principalId": "wile_e_coyote"},
455 | "serverless.context": {},
456 | "serverless.event": event_v1,
457 | }
458 |
459 |
460 | def test_handler_api_gateway_base_path(
461 | mock_wsgi_app_file, mock_app, event_v1, wsgi_handler
462 | ):
463 | event_v1["headers"]["Host"] = "custom.domain.com"
464 | event_v1["path"] = "/prod/some/path"
465 | try:
466 | os.environ["API_GATEWAY_BASE_PATH"] = "prod"
467 | wsgi_handler.handler(event_v1, {})
468 | finally:
469 | del os.environ["API_GATEWAY_BASE_PATH"]
470 |
471 | assert wsgi_handler.wsgi_app.last_environ == {
472 | "CONTENT_LENGTH": "0",
473 | "CONTENT_TYPE": "",
474 | "HTTP_ACCEPT": "*/*",
475 | "HTTP_ACCEPT_ENCODING": "gzip, deflate",
476 | "HTTP_CACHE_CONTROL": "no-cache",
477 | "HTTP_CLOUDFRONT_FORWARDED_PROTO": "https",
478 | "HTTP_CLOUDFRONT_IS_DESKTOP_VIEWER": "true",
479 | "HTTP_CLOUDFRONT_IS_MOBILE_VIEWER": "false",
480 | "HTTP_CLOUDFRONT_IS_SMARTTV_VIEWER": "false",
481 | "HTTP_CLOUDFRONT_IS_TABLET_VIEWER": "false",
482 | "HTTP_CLOUDFRONT_VIEWER_COUNTRY": "DK",
483 | "HTTP_COOKIE": "CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKET_LAUNCHER_0001",
484 | "HTTP_HOST": "custom.domain.com",
485 | "HTTP_POSTMAN_TOKEN": "778a706e-d6b0-48d5-94dd-9e98c22f12fe",
486 | "HTTP_USER_AGENT": "PostmanRuntime/3.0.11-hotfix.2",
487 | "HTTP_VIA": "1.1 b8fa.cloudfront.net (CloudFront)",
488 | "HTTP_X_AMZN_TRACE_ID": "Root=1-58d534a5-1e7cffe644b086304dce7a1e",
489 | "HTTP_X_AMZ_CF_ID": "jx0Bvz9rm--Mz3wAj4i46FdOQQK3RHF4H0moJjBsQ==",
490 | "HTTP_X_FORWARDED_FOR": "76.20.166.147, 205.251.218.72",
491 | "HTTP_X_FORWARDED_PORT": "443",
492 | "HTTP_X_FORWARDED_PROTO": "https",
493 | "PATH_INFO": "/some/path",
494 | "QUERY_STRING": urlencode(event_v1["queryStringParameters"]),
495 | "REMOTE_ADDR": "76.20.166.147",
496 | "REMOTE_USER": "wile_e_coyote",
497 | "REQUEST_METHOD": "GET",
498 | "SCRIPT_NAME": "/prod",
499 | "SERVER_NAME": "custom.domain.com",
500 | "SERVER_PORT": "443",
501 | "SERVER_PROTOCOL": "HTTP/1.1",
502 | "wsgi.errors": wsgi_handler.wsgi_app.last_environ["wsgi.errors"],
503 | "wsgi.input": wsgi_handler.wsgi_app.last_environ["wsgi.input"],
504 | "wsgi.multiprocess": False,
505 | "wsgi.multithread": False,
506 | "wsgi.run_once": False,
507 | "wsgi.url_scheme": "https",
508 | "wsgi.version": (1, 0),
509 | "serverless.authorizer": {"principalId": "wile_e_coyote"},
510 | "serverless.context": {},
511 | "serverless.event": event_v1,
512 | }
513 |
514 |
515 | def test_handler_strip_stage_path(mock_wsgi_app_file, mock_app, event_v1, wsgi_handler):
516 | try:
517 | os.environ["STRIP_STAGE_PATH"] = "True"
518 | wsgi_handler.handler(event_v1, {})
519 | finally:
520 | del os.environ["STRIP_STAGE_PATH"]
521 |
522 | assert wsgi_handler.wsgi_app.last_environ["SCRIPT_NAME"] == ""
523 |
524 |
525 | def test_handler_base64(mock_wsgi_app_file, mock_app, event_v1, wsgi_handler):
526 | wsgi_handler.wsgi_app.cookie_count = 1
527 | wsgi_handler.wsgi_app.response_mimetype = "image/jpeg"
528 | response = wsgi_handler.handler(event_v1, {})
529 |
530 | assert response == {
531 | "body": "SGVsbG8gV29ybGQg4piDIQ==",
532 | "headers": {
533 | "Set-Cookie": "CUSTOMER=WILE_E_COYOTE; Path=/",
534 | "Content-Length": "16",
535 | "Content-Type": "image/jpeg",
536 | },
537 | "statusCode": 200,
538 | "isBase64Encoded": True,
539 | }
540 |
541 |
542 | def test_handler_plain(mock_wsgi_app_file, mock_app, event_v1, wsgi_handler):
543 | wsgi_handler.wsgi_app.cookie_count = 1
544 |
545 | plain_mimetypes = [
546 | "application/vnd.api+json",
547 | "application/javascript; charset=utf-8",
548 | "image/svg+xml; charset=utf-8",
549 | ]
550 |
551 | for mimetype in plain_mimetypes:
552 | wsgi_handler.wsgi_app.response_mimetype = mimetype
553 | response = wsgi_handler.handler(event_v1, {})
554 |
555 | assert response == {
556 | "body": "Hello World ☃!",
557 | "headers": {
558 | "Set-Cookie": "CUSTOMER=WILE_E_COYOTE; Path=/",
559 | "Content-Length": "16",
560 | "Content-Type": mimetype,
561 | },
562 | "statusCode": 200,
563 | "isBase64Encoded": False,
564 | }
565 |
566 |
567 | def test_handler_base64_request(mock_wsgi_app_file, mock_app, event_v1, wsgi_handler):
568 | event_v1["body"] = "SGVsbG8gd29ybGQ="
569 | event_v1["headers"]["Content-Type"] = "text/plain"
570 | event_v1["isBase64Encoded"] = True
571 | event_v1["httpMethod"] = "PUT"
572 |
573 | wsgi_handler.handler(event_v1, {})
574 |
575 | environ = wsgi_handler.wsgi_app.last_environ
576 |
577 | assert environ["CONTENT_TYPE"] == "text/plain"
578 | assert environ["CONTENT_LENGTH"] == "11"
579 | assert environ["REQUEST_METHOD"] == "PUT"
580 | assert environ["wsgi.input"].getvalue().decode() == "Hello world"
581 |
582 |
583 | def test_non_package_subdir_app(mock_subdir_wsgi_app_file, mock_app, wsgi_handler):
584 | assert wsgi_handler.wsgi_app.module == "app"
585 |
586 |
587 | def test_handler_binary_request_body(
588 | mock_wsgi_app_file, mock_app, event_v1, wsgi_handler
589 | ):
590 | event_v1["body"] = (
591 | "LS0tLS0tV2ViS2l0Rm9ybUJvdW5kYXJ5VTRDZE5CRWVLQWxIaGRRcQ0KQ29udGVu"
592 | "dC1EaXNwb3NpdGlvbjogZm9ybS1kYXRhOyBuYW1lPSJ3YXQiDQoNCmhleW9vb3Bw"
593 | "cHBwDQotLS0tLS1XZWJLaXRGb3JtQm91bmRhcnlVNENkTkJFZUtBbEhoZFFxDQpD"
594 | "b250ZW50LURpc3Bvc2l0aW9uOiBmb3JtLWRhdGE7IG5hbWU9ImZpbGVUb1VwbG9h"
595 | "ZCI7IGZpbGVuYW1lPSJGRjREMDAtMC44LnBuZyINCkNvbnRlbnQtVHlwZTogaW1h"
596 | "Z2UvcG5nDQoNColQTkcNChoKAAAADUlIRFIAAAABAAAAAQEDAAAAJdtWygAAAANQ"
597 | "TFRF/00AXDU4fwAAAAF0Uk5TzNI0Vv0AAAAKSURBVHicY2IAAAAGAAM2N3yoAAAA"
598 | "AElFTkSuQmCCDQotLS0tLS1XZWJLaXRGb3JtQm91bmRhcnlVNENkTkJFZUtBbEho"
599 | "ZFFxDQpDb250ZW50LURpc3Bvc2l0aW9uOiBmb3JtLWRhdGE7IG5hbWU9InN1Ym1p"
600 | "dCINCg0KVXBsb2FkIEltYWdlDQotLS0tLS1XZWJLaXRGb3JtQm91bmRhcnlVNENk"
601 | "TkJFZUtBbEhoZFFxLS0NCg=="
602 | )
603 | event_v1["headers"][
604 | "Content-Type"
605 | ] = "multipart/form-data; boundary=----WebKitFormBoundaryU4CdNBEeKAlHhdQq"
606 | event_v1["isBase64Encoded"] = True
607 | event_v1["httpMethod"] = "POST"
608 |
609 | wsgi_handler.handler(event_v1, {})
610 |
611 | environ = wsgi_handler.wsgi_app.last_environ
612 |
613 | assert environ["CONTENT_LENGTH"] == "496"
614 | assert Request(environ).form["submit"] == "Upload Image"
615 |
616 |
617 | def test_handler_request_body_undecodable_with_latin1(
618 | mock_wsgi_app_file, mock_app, event_v1, wsgi_handler
619 | ):
620 | event_v1["body"] = (
621 | "------WebKitFormBoundary3vA72kRLuq9D3NdL\r\n"
622 | u'Content-Disposition: form-data; name="text"\r\n\r\n'
623 | "テスト 테스트 测试\r\n"
624 | "------WebKitFormBoundary3vA72kRLuq9D3NdL--"
625 | )
626 | event_v1["headers"][
627 | "Content-Type"
628 | ] = "multipart/form-data; boundary=----WebKitFormBoundary3vA72kRLuq9D3NdL"
629 | event_v1["httpMethod"] = "POST"
630 |
631 | wsgi_handler.handler(event_v1, {})
632 |
633 | environ = wsgi_handler.wsgi_app.last_environ
634 | assert Request(environ).form["text"] == "テスト 테스트 测试"
635 |
636 |
637 | def test_handler_custom_text_mime_types(
638 | mock_text_mime_wsgi_app_file, mock_app, event_v1, wsgi_handler
639 | ):
640 | wsgi_handler.wsgi_app.cookie_count = 1
641 | wsgi_handler.wsgi_app.response_mimetype = "application/custom+json"
642 | response = wsgi_handler.handler(event_v1, {})
643 |
644 | assert response == {
645 | "body": "Hello World ☃!",
646 | "headers": {
647 | "Set-Cookie": "CUSTOMER=WILE_E_COYOTE; Path=/",
648 | "Content-Length": "16",
649 | "Content-Type": "application/custom+json",
650 | },
651 | "statusCode": 200,
652 | "isBase64Encoded": False,
653 | }
654 |
655 |
656 | def test_handler_alb(mock_wsgi_app_file, mock_app, wsgi_handler, elb_event):
657 | response = wsgi_handler.handler(elb_event, {})
658 |
659 | assert response == {
660 | "body": "Hello World ☃!",
661 | "headers": {
662 | "set-cookie": "CUSTOMER=WILE_E_COYOTE; Path=/",
663 | "Content-Length": "16",
664 | "Content-Type": "text/plain; charset=utf-8",
665 | "sEt-cookie": "LOT_NUMBER=42; Path=/",
666 | "Set-cookie": "PART_NUMBER=ROCKET_LAUNCHER_0002; Path=/",
667 | },
668 | "statusDescription": "200 OK",
669 | "statusCode": 200,
670 | "isBase64Encoded": False,
671 | }
672 |
673 |
674 | def test_alb_query_params(mock_wsgi_app_file, mock_app, wsgi_handler, elb_event):
675 | elb_event["queryStringParameters"] = {"test": "test%20test"}
676 | response = wsgi_handler.handler(elb_event, {})
677 | query_string = wsgi_handler.wsgi_app.last_environ["QUERY_STRING"]
678 | assert query_string == "test=test+test"
679 |
680 | assert response == {
681 | "body": "Hello World ☃!",
682 | "headers": {
683 | "set-cookie": "CUSTOMER=WILE_E_COYOTE; Path=/",
684 | "Content-Length": "16",
685 | "Content-Type": "text/plain; charset=utf-8",
686 | "sEt-cookie": "LOT_NUMBER=42; Path=/",
687 | "Set-cookie": "PART_NUMBER=ROCKET_LAUNCHER_0002; Path=/",
688 | },
689 | "statusDescription": "200 OK",
690 | "statusCode": 200,
691 | "isBase64Encoded": False,
692 | }
693 |
694 |
695 | def test_alb_multi_query_params(mock_wsgi_app_file, mock_app, wsgi_handler, elb_event):
696 | del elb_event["queryStringParameters"]
697 | elb_event["multiValueQueryStringParameters"] = {
698 | "%E6%B8%AC%E8%A9%A6": ["%E3%83%86%E3%82%B9%E3%83%88", "test"],
699 | "test": "test%20test",
700 | }
701 | response = wsgi_handler.handler(elb_event, {})
702 | query_string = wsgi_handler.wsgi_app.last_environ["QUERY_STRING"]
703 | assert query_string == urlencode(
704 | {"測試": ["テスト", "test"], "test": "test test"}, doseq=True)
705 |
706 | assert response == {
707 | "body": "Hello World ☃!",
708 | "headers": {
709 | "set-cookie": "CUSTOMER=WILE_E_COYOTE; Path=/",
710 | "Content-Length": "16",
711 | "Content-Type": "text/plain; charset=utf-8",
712 | "sEt-cookie": "LOT_NUMBER=42; Path=/",
713 | "Set-cookie": "PART_NUMBER=ROCKET_LAUNCHER_0002; Path=/",
714 | },
715 | "statusDescription": "200 OK",
716 | "statusCode": 200,
717 | "isBase64Encoded": False,
718 | }
719 |
720 |
721 | def test_command_exec(mock_wsgi_app_file, mock_app, wsgi_handler):
722 | response = wsgi_handler.handler(
723 | {"_serverless-wsgi": {"command": "exec", "data": "print(1+4)"}}, {}
724 | )
725 |
726 | assert response[0] == 0
727 | assert response[1] == "5\n"
728 |
729 | response = wsgi_handler.handler(
730 | {"_serverless-wsgi": {"command": "exec", "data": "invalid code"}}, {}
731 | )
732 |
733 | assert response[0] == 1
734 | assert "Traceback (most recent call last):" in response[1]
735 | assert "SyntaxError: invalid syntax" in response[1]
736 |
737 |
738 | def test_command_command(mock_wsgi_app_file, mock_app, wsgi_handler):
739 | response = wsgi_handler.handler(
740 | {"_serverless-wsgi": {"command": "command", "data": 'echo "hello world"'}}, {}
741 | )
742 |
743 | assert response[0] == 0
744 | assert response[1] == "hello world\n"
745 |
746 | response = wsgi_handler.handler(
747 | {
748 | "_serverless-wsgi": {
749 | "command": "command",
750 | "data": "ls non-existing-filename",
751 | }
752 | },
753 | {},
754 | )
755 |
756 | assert response[0] > 0
757 | assert "No such file or directory" in response[1]
758 |
759 |
760 | def test_command_manage(mock_wsgi_app_file, mock_app, wsgi_handler):
761 | class MockObject:
762 | pass
763 |
764 | class MockDjango:
765 | def call_command(*args):
766 | print("Called with: {}".format(", ".join(args[1:])))
767 |
768 | sys.modules["django"] = MockObject()
769 | sys.modules["django.core"] = MockObject()
770 | sys.modules["django.core"].management = MockDjango()
771 |
772 | response = wsgi_handler.handler(
773 | {"_serverless-wsgi": {"command": "manage", "data": "check --list-tags"}}, {}
774 | )
775 |
776 | assert response[0] == 0
777 | assert response[1] == "Called with: check, --list-tags\n"
778 |
779 |
780 | def test_command_flask(mock_wsgi_app_file, mock_app, wsgi_handler):
781 | class MockObject:
782 | def __init__(self, **kwargs):
783 | for k, v in kwargs.items():
784 | self.__dict__[k] = v
785 |
786 | class MockFlaskGroup:
787 | def __init__(self, create_app):
788 | assert create_app() == mock_app
789 |
790 | def main(ctx, args, standalone_mode):
791 | assert not standalone_mode
792 | print("Called with: {}".format(", ".join(args)))
793 |
794 | sys.modules["flask"] = MockObject()
795 | sys.modules["flask.cli"] = MockObject(FlaskGroup=MockFlaskGroup)
796 |
797 | response = wsgi_handler.handler(
798 | {"_serverless-wsgi": {"command": "flask", "data": "custom command"}}, {}
799 | )
800 |
801 | assert response[0] == 0
802 | assert response[1] == "Called with: custom, command\n"
803 |
804 |
805 | def test_command_unknown(mock_wsgi_app_file, mock_app, wsgi_handler):
806 | response = wsgi_handler.handler(
807 | {"_serverless-wsgi": {"command": "unknown", "data": 'echo "hello world"'}}, {}
808 | )
809 |
810 | assert response[0] == 1
811 | assert "Traceback (most recent call last):" in response[1]
812 | assert "Exception: Unknown command: unknown" in response[1]
813 |
814 |
815 | def test_app_import_error(mock_wsgi_app_file, mock_app_with_import_error, event_v1, wsgi_handler):
816 | response = wsgi_handler.handler(event_v1, {})
817 | assert response == {
818 | "statusCode": 500,
819 | "body": "\n\n500 Internal Server Error\nInternal Server Error
\nUnable to import app: app.app
\n",
820 | "headers": {
821 | "Content-Type": "text/html; charset=utf-8",
822 | "Content-Length": "140"
823 | },
824 | "isBase64Encoded": False
825 | }
826 |
827 |
828 | def test_handler_with_encoded_characters_in_path(
829 | mock_wsgi_app_file, mock_app, event_v1, capsys, wsgi_handler
830 | ):
831 | event_v1["path"] = "/city/new%20york"
832 | wsgi_handler.handler(event_v1, {"memory_limit_in_mb": "128"})
833 | assert wsgi_handler.wsgi_app.last_environ["PATH_INFO"] == "/city/new york"
834 |
835 |
836 | @pytest.fixture
837 | def event_v2():
838 | return {
839 | "version": "2.0",
840 | "routeKey": "GET /some/path",
841 | "rawPath": "/some/path",
842 | "rawQueryString": "param1=value1¶m2=value2¶m2=value3",
843 | "cookies": ["CUSTOMER=WILE_E_COYOTE", "PART_NUMBER=ROCKET_LAUNCHER_0001"],
844 | "headers": {
845 | "Accept": "*/*",
846 | "Accept-Encoding": "gzip, deflate",
847 | "CloudFront-Forwarded-Proto": "https",
848 | "CloudFront-Is-Desktop-Viewer": "true",
849 | "CloudFront-Is-Mobile-Viewer": "false",
850 | "CloudFront-Is-SmartTV-Viewer": "false",
851 | "CloudFront-Is-Tablet-Viewer": "false",
852 | "CloudFront-Viewer-Country": "DK",
853 | "Host": "3z6kd9fbb1.execute-api.us-east-1.amazonaws.com",
854 | "Postman-Token": "778a706e-d6b0-48d5-94dd-9e98c22f12fe",
855 | "User-Agent": "PostmanRuntime/3.0.11-hotfix.2",
856 | "Via": "1.1 b8fa.cloudfront.net (CloudFront)",
857 | "X-Amz-Cf-Id": "jx0Bvz9rm--Mz3wAj4i46FdOQQK3RHF4H0moJjBsQ==",
858 | "X-Amzn-Trace-Id": "Root=1-58d534a5-1e7cffe644b086304dce7a1e",
859 | "X-Forwarded-For": "76.20.166.147, 205.251.218.72",
860 | "X-Forwarded-Port": "443",
861 | "X-Forwarded-Proto": "https",
862 | "cache-control": "no-cache",
863 | },
864 | "queryStringParameters": {"param1": "value1", "param2": "value2,value3"},
865 | "requestContext": {
866 | "accountId": "16794",
867 | "apiId": "3z6kd9fbb1",
868 | "authorizer": {"principalId": "wile_e_coyote"},
869 | "domainName": "id.execute-api.us-east-1.amazonaws.com",
870 | "domainPrefix": "id",
871 | "http": {
872 | "method": "GET",
873 | "path": "/some/path",
874 | "protocol": "HTTP/1.1",
875 | "sourceIp": "76.20.166.147",
876 | "userAgent": "agent",
877 | },
878 | "requestId": "ad2db740-10a2-11e7-8ced-35048084babb",
879 | "stage": "dev",
880 | "routeKey": "$default",
881 | "time": "12/Mar/2020:19:03:58 +0000",
882 | "timeEpoch": 1583348638390,
883 | },
884 | "pathParameters": {"proxy": "some/path"},
885 | "isBase64Encoded": False,
886 | "stageVariables": None,
887 | }
888 |
889 |
890 | def test_handler_v2(mock_wsgi_app_file, mock_app, event_v2, capsys, wsgi_handler):
891 | response = wsgi_handler.handler(event_v2, {"memory_limit_in_mb": "128"})
892 |
893 | assert response == {
894 | "body": "Hello World ☃!",
895 | "headers": {
896 | "set-cookie": "CUSTOMER=WILE_E_COYOTE; Path=/",
897 | "Content-Length": "16",
898 | "Content-Type": "text/plain; charset=utf-8",
899 | "sEt-cookie": "LOT_NUMBER=42; Path=/",
900 | "Set-cookie": "PART_NUMBER=ROCKET_LAUNCHER_0002; Path=/",
901 | },
902 | "statusCode": 200,
903 | "isBase64Encoded": False,
904 | }
905 |
906 | assert wsgi_handler.wsgi_app.last_environ == {
907 | "CONTENT_LENGTH": "0",
908 | "CONTENT_TYPE": "",
909 | "HTTP_ACCEPT": "*/*",
910 | "HTTP_ACCEPT_ENCODING": "gzip, deflate",
911 | "HTTP_CACHE_CONTROL": "no-cache",
912 | "HTTP_CLOUDFRONT_FORWARDED_PROTO": "https",
913 | "HTTP_CLOUDFRONT_IS_DESKTOP_VIEWER": "true",
914 | "HTTP_CLOUDFRONT_IS_MOBILE_VIEWER": "false",
915 | "HTTP_CLOUDFRONT_IS_SMARTTV_VIEWER": "false",
916 | "HTTP_CLOUDFRONT_IS_TABLET_VIEWER": "false",
917 | "HTTP_CLOUDFRONT_VIEWER_COUNTRY": "DK",
918 | "HTTP_COOKIE": "CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKET_LAUNCHER_0001",
919 | "HTTP_HOST": "3z6kd9fbb1.execute-api.us-east-1.amazonaws.com",
920 | "HTTP_POSTMAN_TOKEN": "778a706e-d6b0-48d5-94dd-9e98c22f12fe",
921 | "HTTP_USER_AGENT": "PostmanRuntime/3.0.11-hotfix.2",
922 | "HTTP_VIA": "1.1 b8fa.cloudfront.net (CloudFront)",
923 | "HTTP_X_AMZN_TRACE_ID": "Root=1-58d534a5-1e7cffe644b086304dce7a1e",
924 | "HTTP_X_AMZ_CF_ID": "jx0Bvz9rm--Mz3wAj4i46FdOQQK3RHF4H0moJjBsQ==",
925 | "HTTP_X_FORWARDED_FOR": "76.20.166.147, 205.251.218.72",
926 | "HTTP_X_FORWARDED_PORT": "443",
927 | "HTTP_X_FORWARDED_PROTO": "https",
928 | "PATH_INFO": "/some/path",
929 | "QUERY_STRING": "param1=value1¶m2=value2¶m2=value3",
930 | "REMOTE_ADDR": "76.20.166.147",
931 | "REMOTE_USER": "wile_e_coyote",
932 | "REQUEST_METHOD": "GET",
933 | "SCRIPT_NAME": "/dev",
934 | "SERVER_NAME": "3z6kd9fbb1.execute-api.us-east-1.amazonaws.com",
935 | "SERVER_PORT": "443",
936 | "SERVER_PROTOCOL": "HTTP/1.1",
937 | "wsgi.errors": wsgi_handler.wsgi_app.last_environ["wsgi.errors"],
938 | "wsgi.input": wsgi_handler.wsgi_app.last_environ["wsgi.input"],
939 | "wsgi.multiprocess": False,
940 | "wsgi.multithread": False,
941 | "wsgi.run_once": False,
942 | "wsgi.url_scheme": "https",
943 | "wsgi.version": (1, 0),
944 | "serverless.authorizer": {"principalId": "wile_e_coyote"},
945 | "serverless.context": {"memory_limit_in_mb": "128"},
946 | "serverless.event": event_v2,
947 | }
948 |
949 | out, err = capsys.readouterr()
950 | assert out == ""
951 | assert err == "application debug #1\n"
952 |
953 |
954 | def test_handler_with_encoded_characters_in_path_v2(
955 | mock_wsgi_app_file, mock_app, event_v2, capsys, wsgi_handler
956 | ):
957 | event_v2["rawPath"] = "/city/new%20york"
958 | wsgi_handler.handler(event_v2, {"memory_limit_in_mb": "128"})
959 | assert wsgi_handler.wsgi_app.last_environ["PATH_INFO"] == "/city/new york"
960 |
961 |
962 | @pytest.fixture
963 | def event_lambda_integration():
964 | return {
965 | "body": {},
966 | "method": "GET",
967 | "principalId": "testuser",
968 | "stage": "dev",
969 | "cognitoPoolClaims": {"sub": ""},
970 | "enhancedAuthContext": {
971 | "principalId": "testuser",
972 | "integrationLatency": "1031",
973 | "contextTest": "123",
974 | },
975 | "headers": {
976 | "Accept": "*/*",
977 | "Authorization": "Bearer f14a720d62e1d1295d9",
978 | "CloudFront-Forwarded-Proto": "https",
979 | "CloudFront-Is-Desktop-Viewer": "true",
980 | "CloudFront-Is-Mobile-Viewer": "false",
981 | "CloudFront-Is-SmartTV-Viewer": "false",
982 | "CloudFront-Is-Tablet-Viewer": "false",
983 | "CloudFront-Viewer-Country": "FI",
984 | "Host": "k3k8rkx1mf.execute-api.us-east-1.amazonaws.com",
985 | "User-Agent": "curl/7.68.0",
986 | "Via": "2.0 3bf180720d62e0d1295d99086d103efb.cloudfront.net (CloudFront)",
987 | "X-Amz-Cf-Id": "9Z6K736EDx_vlsij1PA-ZVxIPPi-vAIMaLNOvJ2FrbpvGMisAISY8Q==",
988 | "X-Amzn-Trace-Id": "Root=1-5055b7d3-751afb497f81bab2759b6e7b",
989 | "X-Forwarded-For": "83.23.10.243, 130.166.149.164",
990 | "X-Forwarded-Port": "443",
991 | "X-Forwarded-Proto": "https",
992 | },
993 | "query": {"q": "test"},
994 | "path": {"p": "path2"},
995 | "identity": {
996 | "cognitoIdentityPoolId": "",
997 | "accountId": "",
998 | "cognitoIdentityId": "",
999 | "caller": "",
1000 | "sourceIp": "83.23.100.243",
1001 | "principalOrgId": "",
1002 | "accessKey": "",
1003 | "cognitoAuthenticationType": "",
1004 | "cognitoAuthenticationProvider": "",
1005 | "userArn": "",
1006 | "userAgent": "curl/7.68.0",
1007 | "user": "",
1008 | },
1009 | "stageVariables": {},
1010 | "requestPath": "/some/{p}",
1011 | }
1012 |
1013 |
1014 | def test_handler_lambda(
1015 | mock_wsgi_app_file, mock_app, event_lambda_integration, capsys, wsgi_handler
1016 | ):
1017 | response = wsgi_handler.handler(
1018 | event_lambda_integration, {"memory_limit_in_mb": "128"}
1019 | )
1020 |
1021 | assert response == {
1022 | "body": "Hello World ☃!",
1023 | "headers": {
1024 | "set-cookie": "CUSTOMER=WILE_E_COYOTE; Path=/",
1025 | "Content-Length": "16",
1026 | "Content-Type": "text/plain; charset=utf-8",
1027 | "sEt-cookie": "LOT_NUMBER=42; Path=/",
1028 | "Set-cookie": "PART_NUMBER=ROCKET_LAUNCHER_0002; Path=/",
1029 | },
1030 | "statusCode": 200,
1031 | "isBase64Encoded": False,
1032 | }
1033 |
1034 | assert wsgi_handler.wsgi_app.last_environ == {
1035 | "CONTENT_LENGTH": "0",
1036 | "CONTENT_TYPE": "",
1037 | "HTTP_ACCEPT": "*/*",
1038 | "HTTP_AUTHORIZATION": "Bearer f14a720d62e1d1295d9",
1039 | "HTTP_CLOUDFRONT_FORWARDED_PROTO": "https",
1040 | "HTTP_CLOUDFRONT_IS_DESKTOP_VIEWER": "true",
1041 | "HTTP_CLOUDFRONT_IS_MOBILE_VIEWER": "false",
1042 | "HTTP_CLOUDFRONT_IS_SMARTTV_VIEWER": "false",
1043 | "HTTP_CLOUDFRONT_IS_TABLET_VIEWER": "false",
1044 | "HTTP_CLOUDFRONT_VIEWER_COUNTRY": "FI",
1045 | "HTTP_HOST": "k3k8rkx1mf.execute-api.us-east-1.amazonaws.com",
1046 | "HTTP_USER_AGENT": "curl/7.68.0",
1047 | "HTTP_VIA": "2.0 3bf180720d62e0d1295d99086d103efb.cloudfront.net (CloudFront)",
1048 | "HTTP_X_AMZN_TRACE_ID": "Root=1-5055b7d3-751afb497f81bab2759b6e7b",
1049 | "HTTP_X_AMZ_CF_ID": "9Z6K736EDx_vlsij1PA-ZVxIPPi-vAIMaLNOvJ2FrbpvGMisAISY8Q==",
1050 | "HTTP_X_FORWARDED_FOR": "83.23.10.243, 130.166.149.164",
1051 | "HTTP_X_FORWARDED_PORT": "443",
1052 | "HTTP_X_FORWARDED_PROTO": "https",
1053 | "PATH_INFO": "/some/path2",
1054 | "QUERY_STRING": "q=test",
1055 | "REMOTE_ADDR": "83.23.100.243",
1056 | "REMOTE_USER": "testuser",
1057 | "REQUEST_METHOD": "GET",
1058 | "SCRIPT_NAME": "/dev",
1059 | "SERVER_NAME": "k3k8rkx1mf.execute-api.us-east-1.amazonaws.com",
1060 | "SERVER_PORT": "443",
1061 | "SERVER_PROTOCOL": "HTTP/1.1",
1062 | "wsgi.errors": wsgi_handler.wsgi_app.last_environ["wsgi.errors"],
1063 | "wsgi.input": wsgi_handler.wsgi_app.last_environ["wsgi.input"],
1064 | "wsgi.multiprocess": False,
1065 | "wsgi.multithread": False,
1066 | "wsgi.run_once": False,
1067 | "wsgi.url_scheme": "https",
1068 | "wsgi.version": (1, 0),
1069 | "serverless.authorizer": {
1070 | "principalId": "testuser",
1071 | "integrationLatency": "1031",
1072 | "contextTest": "123",
1073 | },
1074 | "serverless.context": {"memory_limit_in_mb": "128"},
1075 | "serverless.event": event_lambda_integration,
1076 | }
1077 |
1078 | out, err = capsys.readouterr()
1079 | assert out == ""
1080 | assert err == "application debug #1\n"
1081 |
1082 |
1083 | def test_handler_lambda_error(
1084 | mock_wsgi_app_file, mock_app, event_lambda_integration, capsys, wsgi_handler
1085 | ):
1086 | mock_app.status_code = 400
1087 | with pytest.raises(Exception, match='"statusCode": 400'):
1088 | wsgi_handler.handler(event_lambda_integration, {
1089 | "memory_limit_in_mb": "128"})
1090 |
--------------------------------------------------------------------------------
3 | 
36 | 
207 | 
240 |