Orange-OpenSource/hurl
1
1
Fork 0
mirror of https://github.com/Orange-OpenSource/hurl.git synced 2024-11-23 00:44:55 +03:00
Code Issues Packages Projects Releases Wiki Activity

Format python files with black formater

Browse Source
This commit is contained in:
Fabrice Reix 2022-02-05 06:56:33 +01:00 committed by Fabrice Reix
parent b3246fef1b
commit 5e9a94a430
89 changed files with 621 additions and 551 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
integration/check_json_output.py
View File

@ -2,6 +2,7 @@
import json
import sys
def check(expected, actual):
expected_test = json.loads(expected)
actual_test = json.loads(actual)
@ -9,68 +10,67 @@ def check(expected, actual):
def check_output(expected_test, actual_test):
expected_entries = expected_test['entries']
actual_entries = actual_test['entries']
expected_entries = expected_test["entries"]
actual_entries = actual_test["entries"]
if len(expected_entries) != len(actual_entries):
print('expected entries: %d' % len(expected_entries))
print('actual entries: %d' % len(actual_entries))
print("expected entries: %d" % len(expected_entries))
print("actual entries: %d" % len(actual_entries))
sys.exit(1)
for i in range(len(expected_entries)):
check_entry(i, expected_entries[i], actual_entries[i])
def check_entry(entry_index, expected_entry, actual_entry):
check_request(entry_index, expected_entry['request'], actual_entry['request'])
check_response(entry_index, expected_entry['response'], actual_entry['response'])
if expected_entry.get('asserts') is not None:
check_asserts(entry_index, expected_entry['asserts'], actual_entry['asserts'])
check_request(entry_index, expected_entry["request"], actual_entry["request"])
check_response(entry_index, expected_entry["response"], actual_entry["response"])
if expected_entry.get("asserts") is not None:
check_asserts(entry_index, expected_entry["asserts"], actual_entry["asserts"])
def check_request(entry_index, expected_request, actual_request):
check_method(entry_index, expected_request['method'], actual_request['method'])
check_url(entry_index, expected_request['url'], actual_request['url'])
check_method(entry_index, expected_request["method"], actual_request["method"])
check_url(entry_index, expected_request["url"], actual_request["url"])
def check_response(entry_index, expected_response, actual_response):
check_status(entry_index, expected_response['status'], actual_response['status'])
check_status(entry_index, expected_response["status"], actual_response["status"])
def check_method(entry_index, expected, actual):
if expected != actual:
print('Invalid entry %d' % entry_index)
print('expected method: %s' % expected)
print('actual method : %s' % actual)
print("Invalid entry %d" % entry_index)
print("expected method: %s" % expected)
print("actual method : %s" % actual)
sys.exit(1)
def check_url(entry_index, expected, actual):
if expected != actual:
print('Invalid entry %d' % entry_index)
print('expected url: %s' % expected)
print('actual url : %s' % actual)
print("Invalid entry %d" % entry_index)
print("expected url: %s" % expected)
print("actual url : %s" % actual)
sys.exit(1)
def check_status(entry_index, expected, actual):
if expected != actual:
print('Invalid entry %d' % entry_index)
print('expected status: %s' % expected)
print('actual status : %s' % actual)
print("Invalid entry %d" % entry_index)
print("expected status: %s" % expected)
print("actual status : %s" % actual)
sys.exit(1)
def check_asserts(entry_index, expected, actual):
if expected != actual:
print('Invalid entry %d' % entry_index)
print('expected asserts:\n%s' % json.dumps(expected, indent=2))
print('actual asserts:\n%s' % json.dumps(actual, indent=2))
print("Invalid entry %d" % entry_index)
print("expected asserts:\n%s" % json.dumps(expected, indent=2))
print("actual asserts:\n%s" % json.dumps(actual, indent=2))
sys.exit(1)
def main():
if len(sys.argv) < 3:
print('usage: check_output.py expected_file actual_file')
print("usage: check_output.py expected_file actual_file")
sys.exit(1)
expected_file = sys.argv[1]
actual_file = sys.argv[2]
@ -79,9 +79,5 @@ def main():
check_file(expected, actual)
if __name__ == '__main__':
if __name__ == "__main__":
main()

24
integration/integration.py
View File

@ -7,23 +7,25 @@ import test_hurl
def get_files(glob_expr):
return sorted([f.replace('\\', '/') for f in glob.glob(glob_expr)])
return sorted([f.replace("\\", "/") for f in glob.glob(glob_expr)])
def main():
# Static run (without server)
[test_echo.test(f) for f in get_files('tests/*.hurl') + get_files('tests_error_lint/*.hurl')]
[test_format.test('json', f) for f in get_files('tests/*.hurl')]
[test_format.test('html', f) for f in get_files('tests/*.hurl')]
[test_lint.test(f) for f in get_files('tests_error_lint/*.hurl')]
[test_hurl.test(f) for f in get_files('tests_error_parser/*.hurl')]
[
test_echo.test(f)
for f in get_files("tests/*.hurl") + get_files("tests_error_lint/*.hurl")
]
[test_format.test("json", f) for f in get_files("tests/*.hurl")]
[test_format.test("html", f) for f in get_files("tests/*.hurl")]
[test_lint.test(f) for f in get_files("tests_error_lint/*.hurl")]
[test_hurl.test(f) for f in get_files("tests_error_parser/*.hurl")]
# Dynamic run (with server)
[test_hurl.test(f) for f in get_files('tests/*.hurl') + get_files('ssl/*.hurl')]
[test_hurl.test(f) for f in get_files("tests/*.hurl") + get_files("ssl/*.hurl")]
print('test integration ok!')
print("test integration ok!")
if __name__ == '__main__':
if __name__ == "__main__":
main()

4
integration/server.py
View File

@ -1,4 +1,4 @@
from tests import app
if __name__ == '__main__':
app.run(host='0.0.0.0', port=8000)
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8000)

5
integration/ssl/server.py
View File

@ -4,11 +4,12 @@ import os
app = Flask(__name__)
@app.route("/hello")
def hello():
return "Hello World!"
if __name__ == "__main__":
ssl_dir = os.path.dirname(os.path.realpath(__file__))
app.run(port=8001, ssl_context=(ssl_dir + '/cert.pem', ssl_dir + '/key.pem'))
app.run(port=8001, ssl_context=(ssl_dir + "/cert.pem", ssl_dir + "/key.pem"))

21
integration/test_echo.py
View File

@ -6,34 +6,35 @@ import sys
import subprocess
import codecs
def decode_string(encoded):
if encoded.startswith(codecs.BOM_UTF8):
return encoded.decode('utf-8-sig')
return encoded.decode("utf-8-sig")
elif encoded.startswith(codecs.BOM_UTF16):
encoded = encoded[len(codecs.BOM_UTF16) :]
return encoded.decode('utf-16')
return encoded.decode("utf-16")
else:
return encoded.decode()
def test(hurl_file):
cmd = ['hurlfmt', '--no-format', hurl_file]
print(' '.join(cmd))
cmd = ["hurlfmt", "--no-format", hurl_file]
print(" ".join(cmd))
result = subprocess.run(cmd, stdout=subprocess.PIPE)
expected = codecs.open(hurl_file, encoding='utf-8-sig').read() # Input file can be saved with a BOM
expected = codecs.open(
hurl_file, encoding="utf-8-sig"
).read() # Input file can be saved with a BOM
actual = decode_string(result.stdout)
if actual != expected:
print('>>> error in stdout')
print(f'actual: <{actual}>\nexpected: <{expected}>')
print(">>> error in stdout")
print(f"actual: <{actual}>\nexpected: <{expected}>")
sys.exit(1)
def main():
for hurl_file in sys.argv[1:]:
test(hurl_file)
if __name__ == '__main__':
if __name__ == "__main__":
main()

22
integration/test_format.py
View File

@ -7,34 +7,35 @@ import os
import sys
import subprocess
def decode_string(encoded):
if encoded.startswith(codecs.BOM_UTF8):
return encoded.decode('utf-8-sig')
return encoded.decode("utf-8-sig")
elif encoded.startswith(codecs.BOM_UTF16):
encoded = encoded[len(codecs.BOM_UTF16) :]
return encoded.decode('utf-16')
return encoded.decode("utf-16")
else:
return encoded.decode()
def test(format_type, hurl_file):
output_file = hurl_file.replace('.hurl','.' + format_type)
output_file = hurl_file.replace(".hurl", "." + format_type)
if not os.path.exists(output_file):
return
cmd = ['hurlfmt', '--format', format_type, hurl_file]
print(' '.join(cmd))
cmd = ["hurlfmt", "--format", format_type, hurl_file]
print(" ".join(cmd))
result = subprocess.run(cmd, stdout=subprocess.PIPE)
expected = open(output_file, encoding='utf-8').read().strip()
expected = open(output_file, encoding="utf-8").read().strip()
actual = decode_string(result.stdout)
if actual != expected:
print('>>> error in stdout')
print(f'actual: <{actual}>\nexpected: <{expected}>')
print(">>> error in stdout")
print(f"actual: <{actual}>\nexpected: <{expected}>")
sys.exit(1)
def main():
if len(sys.argv) < 2:
print('usage: test_format.py json|html HURL_FILE..')
print("usage: test_format.py json|html HURL_FILE..")
sys.exit(1)
format_type = sys.argv[1]
@ -42,6 +43,5 @@ def main():
test(format_type, hurl_file)
if __name__ == '__main__':
if __name__ == "__main__":
main()

15
integration/test_html_output.py
View File

@ -5,17 +5,20 @@ from bs4 import BeautifulSoup
import os
import codecs
def test(html_file):
print(html_file)
actual = extract_hurl_content(html_file)
hurl_file = os.path.splitext(html_file)[0] + '.hurl'
hurl_file = os.path.splitext(html_file)[0] + ".hurl"
if not os.path.isfile(hurl_file):
return
expected = codecs.open(hurl_file, encoding='utf-8-sig').read() # Input file can be saved with a BOM
expected = codecs.open(
hurl_file, encoding="utf-8-sig"
).read() # Input file can be saved with a BOM
if actual != expected:
print('>>> error in html file')
print(f'actual: <{actual}>\nexpected: <{expected}>')
print(">>> error in html file")
print(f"actual: <{actual}>\nexpected: <{expected}>")
sys.exit(1)
@ -25,10 +28,10 @@ def extract_hurl_content(hurl_file):
def main():
print('** test html output')
print("** test html output")
for html_file in sys.argv[1:]:
test(html_file)
if __name__ == '__main__':
if __name__ == "__main__":
main()

98
integration/test_hurl.py
View File

@ -12,84 +12,86 @@ import tempfile
def decode_string(encoded):
if encoded.startswith(codecs.BOM_UTF8):
return encoded.decode('utf-8-sig')
return encoded.decode("utf-8-sig")
elif encoded.startswith(codecs.BOM_UTF16):
encoded = encoded[len(codecs.BOM_UTF16) :]
return encoded.decode('utf-16')
return encoded.decode("utf-16")
else:
return encoded.decode()
# return linux, osx or windows
def get_os():
if platform.system() == 'Linux':
return 'linux'
elif platform.system() == 'Darwin':
return 'osx'
elif platform.system() == 'Windows':
return 'windows'
if platform.system() == "Linux":
return "linux"
elif platform.system() == "Darwin":
return "osx"
elif platform.system() == "Windows":
return "windows"
else:
raise Error('Invalid Platform ' + platform.system())
raise Error("Invalid Platform " + platform.system())
def test(hurl_file):
options_file = hurl_file.replace('.hurl', '.options')
options_file = hurl_file.replace(".hurl", ".options")
# For .curl file, we can have specific os expected file in order to test
# os differences like included path (/ vs \ path components separator)
os_curl_file = hurl_file.replace('.hurl', '.' + get_os() + '.curl')
os_curl_file = hurl_file.replace(".hurl", "." + get_os() + ".curl")
if os.path.exists(os_curl_file):
curl_file = os_curl_file
else:
curl_file = hurl_file.replace('.hurl', '.curl')
curl_file = hurl_file.replace(".hurl", ".curl")
json_output_file = hurl_file.replace('.hurl', '.output.json')
profile_file = hurl_file.replace('.hurl', '.profile')
json_output_file = hurl_file.replace(".hurl", ".output.json")
profile_file = hurl_file.replace(".hurl", ".profile")
options = []
if os.path.exists(options_file):
options = open(options_file).read().strip().split('\n')
options = open(options_file).read().strip().split("\n")
if os.path.exists(curl_file):
options.append('--verbose')
options.append("--verbose")
if os.path.exists(json_output_file):
options.append('--json')
options.append("--json")
env = os.environ.copy()
if os.path.exists(profile_file):
for line in open(profile_file).readlines():
line = line.strip()
if line == '':
if line == "":
continue
index = line.index('=')
index = line.index("=")
name = line[:index]
value = line[(index + 1) :]
env[name] = value
cmd = ['hurl', hurl_file] + options
print(' '.join(cmd))
result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE,env=env)
cmd = ["hurl", hurl_file] + options
print(" ".join(cmd))
result = subprocess.run(
cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env
)
# exit code
f = hurl_file.replace('.hurl','.exit')
f = hurl_file.replace(".hurl", ".exit")
expected = int(open(f).read().strip())
if result.returncode != expected:
print('>>> error in return code')
print(f'expected: {expected} actual:{result.returncode}')
print(">>> error in return code")
print(f"expected: {expected} actual:{result.returncode}")
stderr = decode_string(result.stderr).strip()
if stderr != '':
if stderr != "":
print(stderr)
sys.exit(1)
# stdout
f = hurl_file.replace('.hurl','.out')
f = hurl_file.replace(".hurl", ".out")
if os.path.exists(f):
expected = open(f, 'rb').read()
expected = open(f, "rb").read()
actual = result.stdout
if expected != actual:
print('>>> error in stdout')
print(f'actual: <{actual}>\nexpected: <{expected}>')
print(">>> error in stdout")
print(f"actual: <{actual}>\nexpected: <{expected}>")
sys.exit(1)
# stdout (json)
@ -99,47 +101,49 @@ def test(hurl_file):
check_json_output.check(expected, actual)
# stderr
f = hurl_file.replace('.hurl', '.' + get_os() + '.err')
f = hurl_file.replace(".hurl", "." + get_os() + ".err")
if os.path.exists(f):
expected = open(f).read().strip()
actual = decode_string(result.stderr).strip()
if expected != actual:
print('>>> error in stderr')
print(f'actual: <{actual}>\nexpected: <{expected}>')
print(">>> error in stderr")
print(f"actual: <{actual}>\nexpected: <{expected}>")
sys.exit(1)
else:
f = hurl_file.replace('.hurl', '.err')
f = hurl_file.replace(".hurl", ".err")
if os.path.exists(f):
expected = open(f).read().strip()
actual = decode_string(result.stderr).strip()
if expected != actual:
print('>>> error in stderr')
print(f'actual: <{actual}>\nexpected: <{expected}>')
print(">>> error in stderr")
print(f"actual: <{actual}>\nexpected: <{expected}>")
sys.exit(1)
# curl output
if os.path.exists(curl_file):
expected_commands = []
for line in open(curl_file, 'r').readlines():
for line in open(curl_file, "r").readlines():
line = line.strip()
if line == "" or line.startswith("#"):
continue
expected_commands.append(line)
actual = decode_string(result.stderr).strip()
actual_commands= [line[2:] for line in actual.split('\n') if line.startswith('* curl')]
actual_commands = [
line[2:] for line in actual.split("\n") if line.startswith("* curl")
]
if len(actual_commands) != len(expected_commands):
print('Assert error at %s' % (f))
print('expected: %d commands' % len(expected_commands))
print('actual: %d commands' % len(actual_commands))
print("Assert error at %s" % (f))
print("expected: %d commands" % len(expected_commands))
print("actual: %d commands" % len(actual_commands))
sys.exit(1)
for i in range(len(expected_commands)):
if actual_commands[i] != expected_commands[i]:
print('Assert error at %s:%i' % (curl_file, i+1))
print('expected: %s' % expected_commands[i])
print('actual: %s' % actual_commands[i])
print("Assert error at %s:%i" % (curl_file, i + 1))
print("expected: %s" % expected_commands[i])
print("actual: %s" % actual_commands[i])
sys.exit(1)
@ -148,9 +152,5 @@ def main():
test(hurl_file)
if __name__ == '__main__':
if __name__ == "__main__":
main()

32
integration/test_lint.py
View File

@ -5,41 +5,42 @@ import codecs
import sys
import subprocess
def decode_string(encoded):
if encoded.startswith(codecs.BOM_UTF8):
return encoded.decode('utf-8-sig')
return encoded.decode("utf-8-sig")
elif encoded.startswith(codecs.BOM_UTF16):
encoded = encoded[len(codecs.BOM_UTF16) :]
return encoded.decode('utf-16')
return encoded.decode("utf-16")
else:
return encoded.decode()
def test(hurl_file):
cmd = ['hurlfmt', '--check', hurl_file]
print(' '.join(cmd))
cmd = ["hurlfmt", "--check", hurl_file]
print(" ".join(cmd))
result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
if result.returncode != 1:
print(f'return code => expected: 1 actual {result.returncode}')
print(f"return code => expected: 1 actual {result.returncode}")
sys.exit(1)
err_file = hurl_file.replace('.hurl','.err')
err_file = hurl_file.replace(".hurl", ".err")
expected = open(err_file).read().strip()
actual = decode_string(result.stderr).strip()
if actual != expected:
print('>>> error in stderr')
print(f'actual: <{actual}>\nexpected: <{expected}>')
print(">>> error in stderr")
print(f"actual: <{actual}>\nexpected: <{expected}>")
sys.exit(1)
cmd = ['hurlfmt', hurl_file]
print(' '.join(cmd))
cmd = ["hurlfmt", hurl_file]
print(" ".join(cmd))
result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
err_file = hurl_file.replace('.hurl','.hurl.lint')
err_file = hurl_file.replace(".hurl", ".hurl.lint")
expected = open(err_file).read().strip()
actual = decode_string(result.stdout).strip()
if actual != expected:
print('>>> error in stdout')
print(f'actual: <{actual}>\nexpected: <{expected}>')
print(">>> error in stdout")
print(f"actual: <{actual}>\nexpected: <{expected}>")
sys.exit(1)
@ -48,8 +49,5 @@ def main():
test(hurl_file)
if __name__ == '__main__':
if __name__ == "__main__":
main()

12
integration/tests/__init__.py
View File

@ -6,18 +6,18 @@ import os
app = Flask(__name__)
current_dir = os.path.basename(os.path.dirname(__file__))
for python_file in glob.glob(current_dir + '/*.py'):
if python_file.endswith('__init__.py'):
for python_file in glob.glob(current_dir + "/*.py"):
if python_file.endswith("__init__.py"):
continue
module_name = python_file.split('.')[0].replace(os.path.sep, '.')
print('loading %s' % module_name)
module_name = python_file.split(".")[0].replace(os.path.sep, ".")
print("loading %s" % module_name)
try:
importlib.import_module(module_name)
except ImportError as err:
print('Error:', err)
print("Error:", err)
@app.after_request
def remove_header(response):
response.headers['Server'] = 'Flask Server'
response.headers["Server"] = "Flask Server"
return response

3
integration/tests/assert_base64.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/assert-base64")
def assert_base64():
return 'line1\nline2\r\nline3\n'
return "line1\nline2\r\nline3\n"

13
integration/tests/assert_header.py
View File

@ -1,14 +1,13 @@
from tests import app
from flask import make_response
@app.route("/assert-header")
def assert_header():
resp = make_response()
resp.headers['Header1'] = 'value1'
resp.headers['ETag'] = '"33a64df551425fcc55e4d42a148795d9f25f89d4"'
resp.set_cookie('cookie1', 'value1')
resp.set_cookie('cookie2', 'value2')
resp.set_cookie('cookie3', 'value3')
resp.headers["Header1"] = "value1"
resp.headers["ETag"] = '"33a64df551425fcc55e4d42a148795d9f25f89d4"'
resp.set_cookie("cookie1", "value1")
resp.set_cookie("cookie2", "value2")
resp.set_cookie("cookie3", "value3")
return resp

25
integration/tests/assert_json.py
View File

@ -1,9 +1,11 @@
from tests import app
from flask import Response
@app.route("/assert-json")
def assert_json():
return Response('''{
return Response(
"""{
"count": 5,
"success": false,
"errors": [{"id":"error1"},{"id":"error2"}],
@ -11,23 +13,31 @@ def assert_json():
"duration": 1.5,
"tags": ["test"],
"nullable": null
}''', mimetype='application/json')
}""",
mimetype="application/json",
)
@app.route("/assert-json/index")
def assert_json_index():
return "1"
@app.route("/assert-json/list")
def assert_json_list():
return Response('''[
return Response(
"""[
{ "id": 1, "name": "Bob"},
{ "id": 2, "name": "Bill"}
]''', mimetype='application/json')
]""",
mimetype="application/json",
)
@app.route("/assert-json/filter")
def assert_json_filter():
return Response('''{
return Response(
"""{
"fruit": [
{
"name": "apple",
@ -44,5 +54,6 @@ def assert_json_filter():
}
}
]
}''', mimetype='application/json')
}""",
mimetype="application/json",
)

10
integration/tests/assert_match.py
View File

@ -1,13 +1,15 @@
from tests import app
from flask import Response
@app.route("/assert-match")
def assert_match():
return Response('''{
return Response(
"""{
"date1": "2014-01-01",
"date2": "x2014-01-01",
"path1": "aa/bb",
"path2": "aa\\\\bb"
}''', mimetype='application/json')
}""",
mimetype="application/json",
)

3
integration/tests/assert_regex.py
View File

@ -4,5 +4,4 @@ from tests import app
@app.route("/assert-regex")
def assert_regex():
return 'Hello World!'
return "Hello World!"

4
integration/tests/assert_status_code.py
View File

@ -2,7 +2,7 @@
from tests import app
from flask import Response
@app.route("/assert-status-code")
def assert_status_code():
return Response('', status=201)
return Response("", status=201)

3
integration/tests/assert_xpath.py
View File

@ -4,5 +4,4 @@ from tests import app
@app.route("/assert-xpath")
def assert_xpath():
return '<data>café</data>'
return "<data>café</data>"

10
integration/tests/basic_authentication.py
View File

@ -1,10 +1,8 @@
from tests import app
from flask import request
@app.route('/basic-authentication')
@app.route("/basic-authentication")
def basic_authentication():
assert request.headers['Authorization'] == 'Basic Ym9iOnNlY3JldA=='
return 'You are authenticated'
assert request.headers["Authorization"] == "Basic Ym9iOnNlY3JldA=="
return "You are authenticated"

10
integration/tests/basic_authentication_per_request.py
View File

@ -1,10 +1,8 @@
from tests import app
from flask import request
@app.route('/basic-authentication-per-request')
@app.route("/basic-authentication-per-request")
def basic_authentication_per_request():
assert request.headers['Authorization'] == 'Basic Ym9iOnNlY3JldA=='
return 'You are authenticated'
assert request.headers["Authorization"] == "Basic Ym9iOnNlY3JldA=="
return "You are authenticated"

4
integration/tests/bom.py
View File

@ -1,7 +1,7 @@
from tests import app
from flask import request
@app.route("/utf8_bom")
def utf8_bom():
return 'Hello World!'
return "Hello World!"

9
integration/tests/bytes.py
View File

@ -3,14 +3,11 @@ from flask import make_response, request
from io import BytesIO
@app.route('/bytes')
@app.route("/bytes")
def bytes():
result = BytesIO()
result.write(b'\x01\x02\x03')
result.write(b"\x01\x02\x03")
data = result.getvalue()
resp = make_response(data)
resp.content_type = 'application/octet-stream'
resp.content_type = "application/octet-stream"
return resp

3
integration/tests/capture_and_assert.py
View File

@ -3,5 +3,4 @@ from tests import app
@app.route("/capture-and-assert")
def capture_and_assert():
return 'Hello World!'
return "Hello World!"

17
integration/tests/captures.py
View File

@ -2,22 +2,21 @@ from tests import app
from flask import make_response, request
@app.route('/captures')
@app.route("/captures")
def captures():
resp = make_response()
resp.headers['Header1'] = 'value1'
resp.headers['Header2'] = 'Hello Bob!'
resp.headers["Header1"] = "value1"
resp.headers["Header2"] = "Hello Bob!"
return resp
@app.route('/captures-check')
@app.route("/captures-check")
def captures_check():
assert request.args.get('param1') == 'value1'
assert request.args.get('param2') == 'Bob'
return ''
assert request.args.get("param1") == "value1"
assert request.args.get("param2") == "Bob"
return ""
@app.route('/captures-json')
@app.route("/captures-json")
def captures_json():
return '{ "a_null": null, "an_object": {"id": "123"}, "a_list": [1,2,3], "an_integer": 1, "a_float": 1.1, "a_bool": true, "a_string": "hello" }'

36
integration/tests/compressed.py
View File

@ -2,50 +2,60 @@ from tests import app
from flask import make_response, request
from io import BytesIO
@app.route("/compressed/gzip")
def compressed_gzip():
assert 'gzip' in request.headers['Accept-Encoding']
assert "gzip" in request.headers["Accept-Encoding"]
result = BytesIO()
result.write(b'\x1f\x8b\x08\x00\xed\x0c\x84\x5f\x00\x03\xf3\x48\xcd\xc9\xc9\x57\x08\xcf\x2f\xca\x49\x51\x04\x00\xa3\x1c\x29\x1c\x0c\x00\x00\x00')
result.write(
b"\x1f\x8b\x08\x00\xed\x0c\x84\x5f\x00\x03\xf3\x48\xcd\xc9\xc9\x57\x08\xcf\x2f\xca\x49\x51\x04\x00\xa3\x1c\x29\x1c\x0c\x00\x00\x00"
)
data = result.getvalue()
resp = make_response(data)
resp.headers['Content-Encoding'] = 'gzip'
resp.headers["Content-Encoding"] = "gzip"
return resp
@app.route("/compressed/zlib")
def compressed_zlib():
assert 'deflate' in request.headers['Accept-Encoding']
assert "deflate" in request.headers["Accept-Encoding"]
result = BytesIO()
result.write(b'\x78\x9c\xf3\x48\xcd\xc9\xc9\x57\x08\xcf\x2f\xca\x49\x51\x04\x00\x1c\x49\x04\x3e')
result.write(
b"\x78\x9c\xf3\x48\xcd\xc9\xc9\x57\x08\xcf\x2f\xca\x49\x51\x04\x00\x1c\x49\x04\x3e"
)
data = result.getvalue()
resp = make_response(data)
resp.headers['Content-Encoding'] = 'deflate'
resp.headers["Content-Encoding"] = "deflate"
return resp
@app.route("/compressed/brotli")
def compressed_brotli():
assert 'br' in request.headers['Accept-Encoding']
assert "br" in request.headers["Accept-Encoding"]
result = BytesIO()
result.write(b'\x21\x2c\x00\x04\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21\x03')
result.write(
b"\x21\x2c\x00\x04\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21\x03"
)
data = result.getvalue()
resp = make_response(data)
resp.headers['Content-Encoding'] = 'br'
resp.headers["Content-Encoding"] = "br"
return resp
@app.route("/compressed/brotli_identity")
def compressed_brotli_identity():
assert 'br' in request.headers['Accept-Encoding']
assert "br" in request.headers["Accept-Encoding"]
result = BytesIO()
result.write(b'\x21\x2c\x00\x04\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21\x03')
result.write(
b"\x21\x2c\x00\x04\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21\x03"
)
data = result.getvalue()
resp = make_response(data)
resp.headers['Content-Encoding'] = 'br, identity'
resp.headers["Content-Encoding"] = "br, identity"
return resp
@app.route("/compressed/none")
def compressed_none():
return 'Hello World!'
return "Hello World!"

9
integration/tests/cookie_file.py
View File

@ -4,10 +4,5 @@ from tests import app
@app.route("/cookie_file")
def cookie_file():
assert request.cookies['cookie1'] == 'valueA'
return ''
assert request.cookies["cookie1"] == "valueA"
return ""

12
integration/tests/cookie_storage.py
View File

@ -4,13 +4,11 @@ from tests import app
@app.route("/cookie-storage/assert-that-cookie1-is-valueA")
def cookiestorage_assert_that_cookie1_is_valuea():
assert request.cookies['cookie1'] == 'valueA'
return ''
assert request.cookies["cookie1"] == "valueA"
return ""
@app.route("/cookie-storage/assert-that-cookie1-is-not-in-session")
def cookiestorage_assert_that_cookie1_is_not_in_session():
assert'cookie1' not in request.cookies
return ''
assert "cookie1" not in request.cookies
return ""

87
integration/tests/cookies.py
View File

@ -4,29 +4,30 @@ from tests import app
@app.route("/cookies/set-request-cookie1-valueA")
def set_request_cookie1_value1():
assert request.cookies['cookie1'] == 'valueA'
assert request.headers['Cookie'] == 'cookie1=valueA'
return ''
assert request.cookies["cookie1"] == "valueA"
assert request.headers["Cookie"] == "cookie1=valueA"
return ""
@app.route("/cookies/set-multiple-request-cookies")
def set_multiple_request_cookies():
assert request.cookies['user1'] == 'Bob'
assert request.cookies['user2'] == 'Bill'
assert request.headers['Cookie'] == 'user1=Bob; user2=Bill'
return ''
assert request.cookies["user1"] == "Bob"
assert request.cookies["user2"] == "Bill"
assert request.headers["Cookie"] == "user1=Bob; user2=Bill"
return ""
@app.route("/cookies/set-session-cookie2-valueA")
def set_session_cookie2_valuea():
resp = make_response()
resp.set_cookie('cookie2', 'valueA')
resp.set_cookie("cookie2", "valueA")
return resp
@app.route("/cookies/set-request-cookie2-valueB")
def set_request_cookie2_valueb():
assert request.cookies['cookie2'] == 'valueB'
return ''
assert request.cookies["cookie2"] == "valueB"
return ""
# @app.route("/cookies/send-cookie2-value1")
@ -45,49 +46,53 @@ def set_request_cookie2_valueb():
@app.route("/cookies/delete-cookie2")
def delete_cookie2():
resp = make_response()
resp.set_cookie('cookie2', '', max_age=0)
resp.set_cookie("cookie2", "", max_age=0)
return resp
@app.route("/cookies/assert-that-cookie1-is-not-in-session")
def assert_that_cookie1_is_not_in_session():
assert'cookie1' not in request.cookies
assert 'Cookie' not in request.headers
return ''
assert "cookie1" not in request.cookies
assert "Cookie" not in request.headers
return ""
@app.route("/cookies/assert-that-cookie2-is-not-in-session")
def assert_that_cookie2_is_not_in_session():
assert'cookie2' not in request.cookies
return ''
assert "cookie2" not in request.cookies
return ""
@app.route("/cookies/assert-that-cookie2-is-valueA")
def assert_that_cookie2_is_valuea():
assert request.cookies['cookie2'] == 'valueA'
return ''
assert request.cookies["cookie2"] == "valueA"
return ""
@app.route("/cookies/assert-that-cookie2-is-valueB")
def assert_that_cookie2_is_valueb():
assert request.cookies['cookie2'] == 'valueB'
return ''
assert request.cookies["cookie2"] == "valueB"
return ""
@app.route("/cookies/assert-that-cookie2-is-valueA-and-valueB")
def assert_that_cookie2_is_valuea_and_valueb():
assert 'cookie2=valueA' in request.headers['Cookie']
assert 'cookie2=valueB' in request.headers['Cookie']
return ''
assert "cookie2=valueA" in request.headers["Cookie"]
assert "cookie2=valueB" in request.headers["Cookie"]
return ""
@app.route("/cookies/set-session-cookie2-valueA-subdomain")
def set_session_cookie2_valuea_subdomain():
resp = make_response()
resp.set_cookie('cookie2', 'valueA', domain='myshop.orange.localhost')
resp.set_cookie("cookie2", "valueA", domain="myshop.orange.localhost")
return resp
@app.route("/cookies/set-session-cookie2-valueA-subdomain2")
def set_session_cookie2_valuea_subdomain2():
resp = make_response()
resp.set_cookie('cookie2', 'valueA', domain='orange.localhost')
resp.set_cookie("cookie2", "valueA", domain="orange.localhost")
return resp
@ -97,11 +102,29 @@ def set_session_cookie2_valuea_subdomain2():
@app.route("/cookies/set")
def set_cookies():
resp = make_response()
resp.set_cookie('LSID', 'DQAAAKEaem_vYg', path='/accounts', secure=True, httponly=True, expires='Wed, 13 Jan 2021 22:23:01 GMT')
resp.set_cookie('HSID', 'AYQEVnDKrdst', domain='.localhost', path='/', expires='Wed, 13 Jan 2021 22:23:01 GMT', httponly=True)
resp.set_cookie('SSID', 'Ap4PGTEq', domain='.localhost', path='/', expires='Wed, 13 Jan 2021 22:23:01 GMT', secure=True, httponly=True)
resp.set_cookie(
"LSID",
"DQAAAKEaem_vYg",
path="/accounts",
secure=True,
httponly=True,
expires="Wed, 13 Jan 2021 22:23:01 GMT",
)
resp.set_cookie(
"HSID",
"AYQEVnDKrdst",
domain=".localhost",
path="/",
expires="Wed, 13 Jan 2021 22:23:01 GMT",
httponly=True,
)
resp.set_cookie(
"SSID",
"Ap4PGTEq",
domain=".localhost",
path="/",
expires="Wed, 13 Jan 2021 22:23:01 GMT",
secure=True,
httponly=True,
)
return resp

7
integration/tests/delete.py
View File

@ -1,7 +1,6 @@
from tests import app
@app.route('/delete', methods=['DELETE'])
@app.route("/delete", methods=["DELETE"])
def delete():
return ''
return ""

12
integration/tests/encoding.py
View File

@ -5,18 +5,14 @@ from io import BytesIO
@app.route("/encoding/utf8")
def encoding_utf8():
return 'café'
return "café"
@app.route("/encoding/latin1")
def encoding_latin1():
result = BytesIO()
result.write(b'\x63\x61\x66\xe9')
result.write(b"\x63\x61\x66\xe9")
data = result.getvalue()
resp = make_response(data)
resp.content_type = 'text/html; charset=ISO-8859-1'
resp.content_type = "text/html; charset=ISO-8859-1"
return resp

8
integration/tests/env_var.py
View File

@ -1,8 +1,8 @@
from flask import request
from tests import app
@app.route('/env-var')
def env_var():
assert request.args.get('name') == 'Bob'
return ''
@app.route("/env-var")
def env_var():
assert request.args.get("name") == "Bob"
return ""

3
integration/tests/error_assert_base64.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/error-assert-base64")
def error_assert_base64():
return 'line1\nline2\r\nline3\n'
return "line1\nline2\r\nline3\n"

5
integration/tests/error_assert_bytearray.py
View File

@ -2,11 +2,12 @@ from tests import app
from flask import make_response, request
from io import BytesIO
@app.route("/error-assert-bytearray")
def error_assert_bytearray():
result = BytesIO()
result.write(b'\xff')
result.write(b"\xff")
data = result.getvalue()
resp = make_response(data)
resp.content_type = 'application/octet-stream'
resp.content_type = "application/octet-stream"
return resp

5
integration/tests/error_assert_content_encoding.py
View File

@ -1,7 +1,8 @@
from tests import app
from flask import Response
@app.route("/error/content-encoding")
def error_assert_content_encoding():
headers = {'Content-Encoding': 'unknown'}
return Response('Hello', headers=headers)
headers = {"Content-Encoding": "unknown"}
return Response("Hello", headers=headers)

5
integration/tests/error_assert_decompressed.py
View File

@ -1,8 +1,9 @@
from tests import app
from flask import Response
@app.route("/error-assert-decompress")
def error_assert_decompress():
headers = {}
headers['Content-Encoding'] = 'gzip'
return Response('Hello', headers=headers)
headers["Content-Encoding"] = "gzip"
return Response("Hello", headers=headers)

3
integration/tests/error_assert_file.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/error-assert-file")
def error_assert_file():
return 'Hello'
return "Hello"

4
integration/tests/error_assert_header_not_found.py
View File

@ -1,6 +1,6 @@
from tests import app
@app.route("/error-assert-header-not-found")
def error_assert_header_not_found():
return 'Hello World!'
return "Hello World!"

4
integration/tests/error_assert_header_value.py
View File

@ -1,6 +1,6 @@
from tests import app
@app.route("/error-assert-header-value")
def error_assert_header_value():
return 'Hello World!'
return "Hello World!"

7
integration/tests/error_assert_http_version.py
View File

@ -1,7 +1,6 @@
from tests import app
@app.route('/error-assert/http-version')
@app.route("/error-assert/http-version")
def http_version():
return ''
return ""

3
integration/tests/error_assert_invalid_predicate_type.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/error-assert-invalid-predicate-type")
def error_assert_invalid_predicate_type():
return ''
return ""

6
integration/tests/error_assert_match_utf8.py
View File

@ -3,12 +3,10 @@ from flask import make_response
from io import BytesIO
@app.route('/error-assert/match-utf8')
@app.route("/error-assert/match-utf8")
def error_assert_match_utf8():
result = BytesIO()
result.write(b'\xff')
result.write(b"\xff")
data = result.getvalue()
resp = make_response(data)
return resp

4
integration/tests/error_assert_newline.py
View File

@ -1,6 +1,6 @@
from tests import app
@app.route("/error-assert-newline")
def error_assert_newline():
return '<p>Hello</p>\n\n'
return "<p>Hello</p>\n\n"

6
integration/tests/error_assert_query_cookie.py
View File

@ -1,10 +1,10 @@
from flask import request, make_response
from tests import app
@app.route("/error-assert-query-cookie")
def error_assert_query_cookie():
resp = make_response()
resp.set_cookie('cookie1', 'value1')
resp.set_cookie('cookie2', 'value2', secure=True)
resp.set_cookie("cookie1", "value1")
resp.set_cookie("cookie2", "value2", secure=True)
return resp

3
integration/tests/error_assert_query_invalid_regex.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/error-assert-query-invalid-regex")
def error_assert_query_invalid_regex():
return ''
return ""

3
integration/tests/error_assert_query_invalid_xpath.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/error-assert-query-invalid-xpath")
def error_assert_query_invalid_xpath():
return ''
return ""

4
integration/tests/error_assert_template_variable_not_found.py
View File

@ -1,6 +1,6 @@
from tests import app
@app.route("/error-assert-template-variable-not-found")
def error_assert_template_variable_not_found():
return ''
return ""

2
integration/tests/error_assert_value_error.py
View File

@ -1,6 +1,6 @@
from tests import app
@app.route("/error-assert-value")
def error_assert_value():
return '{ "values": [1,2,3], "count": 2}'

4
integration/tests/error_assert_variable.py
View File

@ -1,6 +1,6 @@
from tests import app
@app.route("/error-assert-variable")
def error_assert_variable():
return ''
return ""

4
integration/tests/error_assert_xpath.py
View File

@ -1,6 +1,6 @@
from tests import app
@app.route("/error-assert-xpath")
def error_assert_xpath():
return '<html><head><title>Test</title></head></html>'
return "<html><head><title>Test</title></head></html>"

3
integration/tests/error_file_read_access.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/error-file-read-access")
def error_file_read_access():
return ''
return ""

6
integration/tests/error_invalid_jsonpath.py
View File

@ -1,6 +1,10 @@
from tests import app
from flask import Response
@app.route("/error-invalid-jsonpath")
def error_invalid_jsonpath():
return Response('{"success":false,"errors":[{"id":"error1"},{"id":"error2"}]}', mimetype='application/json')
return Response(
'{"success":false,"errors":[{"id":"error1"},{"id":"error2"}]}',
mimetype="application/json",
)

3
integration/tests/error_invalid_xml.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/error-invalid-xml")
def error_invalid_xml():
return ''
return ""

9
integration/tests/error_max_redirect.py
View File

@ -1,11 +1,10 @@
from tests import app
from flask import redirect
@app.route('/redirect/<number>', methods=['GET'])
@app.route("/redirect/<number>", methods=["GET"])
def redirect_n(number):
n = int(number)
if n == 0:
return ''
return redirect('http://localhost:8000/redirect/' + str(n-1))
return ""
return redirect("http://localhost:8000/redirect/" + str(n - 1))

5
integration/tests/error_output_decompress.py
View File

@ -1,8 +1,9 @@
from tests import app
from flask import Response
@app.route("/error-output-decompress")
def error_output_decompress():
headers = {}
headers['Content-Encoding'] = 'gzip'
return Response('Hello', headers=headers)
headers["Content-Encoding"] = "gzip"
return Response("Hello", headers=headers)

5
integration/tests/error_predicate.py
View File

@ -1,12 +1,13 @@
from tests import app
@app.route("/predicate/error/type")
def predicate_error_type():
return '''{
return """{
"status": true,
"message": "0",
"count": 1,
"empty": "",
"number": 1.0,
"list": [1,2,3]
}'''
}"""

3
integration/tests/error_query_header_not_found.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/error-query-header-not-found")
def error_query_header_not_found():
return 'Hello World!'
return "Hello World!"

3
integration/tests/error_query_invalid_json.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/error-query-invalid-json")
def error_query_invalid_json():
return 'Hello World!'
return "Hello World!"

3
integration/tests/error_query_invalid_utf8.py
View File

@ -2,10 +2,11 @@ from tests import app
from flask import make_response
from io import BytesIO
@app.route("/error-query-invalid-utf8")
def error_query_invalid_utf8():
result = BytesIO()
result.write(b'\xff')
result.write(b"\xff")
data = result.getvalue()
resp = make_response(data)
return resp

1
integration/tests/error_template_variable_not_renderable.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route("/get-list")
def get_list():
return '{"values":[1,2,3]}'

7
integration/tests/error_timeout.py
View File

@ -1,9 +1,8 @@
from tests import app
import time
@app.route('/timeout')
@app.route("/timeout")
def timeout():
time.sleep(2)
return ''
return ""

11
integration/tests/expect.py
View File

@ -1,11 +1,10 @@
from tests import app
from flask import request
@app.route("/expect", methods=['POST'])
@app.route("/expect", methods=["POST"])
def expect():
assert request.headers['Expect'] == '100-continue'
assert request.headers["Expect"] == "100-continue"
s = request.data.decode("utf-8")
assert s == '''data'''
return ''
assert s == """data"""
return ""

3
integration/tests/float.py
View File

@ -1,6 +1,7 @@
from tests import app
from flask import Response
@app.route("/float")
def float():
return '[ -2.2, 0.0, 0.0000000000000001, 0.000000000000001, 0.333, 0.3333333333333333, 0.333333333333333333, 1.0, 1.001, 1.07, 1.070, 1.1, 1.5 ]'
return "[ -2.2, 0.0, 0.0000000000000001, 0.000000000000001, 0.333, 0.3333333333333333, 0.333333333333333333, 1.0, 1.001, 1.07, 1.070, 1.1, 1.5 ]"

15
integration/tests/follow_redirect.py
View File

@ -1,14 +1,17 @@
from tests import app
from flask import redirect
@app.route('/follow-redirect')
@app.route("/follow-redirect")
def follow_redirect():
return redirect('http://localhost:8000/following-redirect')
return redirect("http://localhost:8000/following-redirect")
@app.route('/following-redirect')
@app.route("/following-redirect")
def following_redirect():
return redirect('http://localhost:8000/followed-redirect')
return redirect("http://localhost:8000/followed-redirect")
@app.route('/followed-redirect')
@app.route("/followed-redirect")
def followed_redirect():
return 'Followed redirect!'
return "Followed redirect!"

19
integration/tests/form_params.py
View File

@ -1,14 +1,13 @@
from tests import app
from flask import request
@app.route("/form-params", methods=['POST'])
@app.route("/form-params", methods=["POST"])
def form_params():
assert request.form['param1'] == 'value1'
assert request.form['param2'] == ''
assert request.form['param3'] == 'a=b'
assert request.form['param4'] == 'a%3db'
assert request.form['values[0]'] == '0'
assert request.form['values[1]'] == '1'
return ''
assert request.form["param1"] == "value1"
assert request.form["param2"] == ""
assert request.form["param3"] == "a=b"
assert request.form["param4"] == "a%3db"
assert request.form["values[0]"] == "0"
assert request.form["values[1]"] == "1"
return ""

36
integration/tests/headers.py
View File

@ -2,42 +2,48 @@
from flask import request, make_response
from tests import app
@app.route("/default-headers")
def default_headers():
assert 'hurl' in request.headers['User-Agent'] or 'curl' in request.headers['User-Agent']
assert request.headers['Host'] == 'localhost:8000'
assert 'Content-Length' not in request.headers
return ''
assert (
"hurl" in request.headers["User-Agent"]
or "curl" in request.headers["User-Agent"]
)
assert request.headers["Host"] == "localhost:8000"
assert "Content-Length" not in request.headers
return ""
@app.route("/custom-headers")
def custom_headers():
# TODO: what is expected when request header has multiple values ?
assert request.headers['Fruit'] == "Raspberry,Apple,Banana,Grape"
assert request.headers['Color'] == 'Green'
return ''
assert request.headers["Fruit"] == "Raspberry,Apple,Banana,Grape"
assert request.headers["Color"] == "Green"
return ""
@app.route("/custom-headers-utf8")
def custom_headers_utf8():
assert len(request.headers['Beverage']) == 5
assert request.headers['Beverage'] == '\x63\x61\x66\xc3\xa9'
return ''
assert len(request.headers["Beverage"]) == 5
assert request.headers["Beverage"] == "\x63\x61\x66\xc3\xa9"
return ""
@app.route("/custom-headers-value")
def custom_headers_value():
assert request.headers['Id'] == '#123'
return ''
assert request.headers["Id"] == "#123"
return ""
@app.route("/custom-headers-quote")
def custom_headers_quotes():
assert request.headers['Header1'] == "'"
return ''
assert request.headers["Header1"] == "'"
return ""
@app.route("/response-headers")
def response_headers():
resp = make_response()
# resp.headers['Beverage'] = '\x63\x61\x66\xc3\xa9'
resp.headers['Beverage'] = 'cafe'
resp.headers["Beverage"] = "cafe"
return resp

8
integration/tests/hello.py
View File

@ -1,10 +1,10 @@
from tests import app
from flask import request
@app.route("/hello")
def hello():
assert 'Content-Type' not in request.headers
assert 'Content-Length' not in request.headers
assert "Content-Type" not in request.headers
assert "Content-Length" not in request.headers
assert len(request.data) == 0
return 'Hello World!'
return "Hello World!"

3
integration/tests/ignore_asserts.py
View File

@ -1,6 +1,7 @@
from tests import app
from flask import Response
@app.route("/ignore_asserts")
def ignore_asserts():
return 'Hello'
return "Hello"

5
integration/tests/include.py
View File

@ -1,7 +1,8 @@
from tests import app
from flask import Response
@app.route("/include")
def include():
headers = {'Date': 'DATE'}
return Response('Hello', headers=headers)
headers = {"Date": "DATE"}
return Response("Hello", headers=headers)

8
integration/tests/large.py
View File

@ -3,14 +3,12 @@ from flask import make_response
from io import BytesIO
@app.route('/large')
@app.route("/large")
def large():
result = BytesIO()
for _ in range(1024 * 1024 * 32):
result.write(b'0123456789abcdef')
result.write(b"0123456789abcdef")
data = result.getvalue()
resp = make_response(data)
resp.content_type = 'application/octet-stream'
resp.content_type = "application/octet-stream"
return resp

5
integration/tests/multilines.py
View File

@ -1,7 +1,6 @@
from tests import app
@app.route("/multilines")
def multilines():
return 'line1\nline2\nline3\n'
return "line1\nline2\nline3\n"

35
integration/tests/multipart_form_data.py
View File

@ -2,27 +2,26 @@
from tests import app
from flask import request
@app.route("/multipart-form-data", methods=['POST'])
@app.route("/multipart-form-data", methods=["POST"])
def multipart_form_data():
assert request.form['key1'] == 'value1'
assert 'Expect' not in request.headers
assert request.form["key1"] == "value1"
assert "Expect" not in request.headers
upload1 = request.files['upload1']
assert upload1.filename == 'data.txt'
assert upload1.content_type == 'text/plain'
assert upload1.read() == b'Hello World!'
upload1 = request.files["upload1"]
assert upload1.filename == "data.txt"
assert upload1.content_type == "text/plain"
assert upload1.read() == b"Hello World!"
upload2 = request.files['upload2']
assert upload2.filename == 'data.html'
assert upload2.content_type == 'text/html'
assert upload2.read() == b'<div>Hello <b>World</b>!</div>'
upload3 = request.files['upload3']
assert upload3.filename == 'data.txt'
assert upload3.content_type == 'text/html'
assert upload3.read() == b'Hello World!'
return ''
upload2 = request.files["upload2"]
assert upload2.filename == "data.html"
assert upload2.content_type == "text/html"
assert upload2.read() == b"<div>Hello <b>World</b>!</div>"
upload3 = request.files["upload3"]
assert upload3.filename == "data.txt"
assert upload3.content_type == "text/html"
assert upload3.read() == b"Hello World!"
return ""

4
integration/tests/non_utf8.py
View File

@ -2,12 +2,12 @@ from tests import app
from flask import make_response, request
from io import BytesIO
@app.route("/non-utf8")
def non_utf8():
result = BytesIO()
result.write(b'\x41\x0a\xe9\x0a\xaa')
result.write(b"\x41\x0a\xe9\x0a\xaa")
data = result.getvalue()
resp = make_response(data)
return resp

11
integration/tests/output.py
View File

@ -2,19 +2,18 @@ from tests import app
from flask import request
@app.route("/output/endpoint1", methods=['POST'])
@app.route("/output/endpoint1", methods=["POST"])
def output_endpoint1():
assert request.headers['Content-Type'] == 'application/json'
assert request.headers["Content-Type"] == "application/json"
s = request.data.decode("utf-8")
assert s == '{ "user": "bob" }'
return app.response_class(
headers={'date': 'DATE1'},
response='Response endpoint1\n'
headers={"date": "DATE1"}, response="Response endpoint1\n"
)
@app.route("/output/endpoint2")
def output_endpoint2():
return app.response_class(
headers={'date': 'DATE2'},
response='Response endpoint2\n'
headers={"date": "DATE2"}, response="Response endpoint2\n"
)

13
integration/tests/patch.py
View File

@ -2,13 +2,12 @@ from flask import request, make_response
from tests import app
@app.route('/patch/file.txt', methods=['PATCH'])
@app.route("/patch/file.txt", methods=["PATCH"])
def patch():
assert request.headers['Host'] == 'www.example.com'
assert request.headers['Content-Type'] == 'application/example'
assert request.headers['If-Match'] == '"e0023aa4e"'
assert request.headers["Host"] == "www.example.com"
assert request.headers["Content-Type"] == "application/example"
assert request.headers["If-Match"] == '"e0023aa4e"'
resp = make_response()
resp.headers['Content-Location'] = '/file.txt'
resp.headers['ETag'] = '"e0023aa4f"'
resp.headers["Content-Location"] = "/file.txt"
resp.headers["ETag"] = '"e0023aa4f"'
return resp, 204

8
integration/tests/post_base64.py
View File

@ -1,8 +1,8 @@
from flask import request
from tests import app
@app.route('/post-base64', methods=['POST'])
def post_base64():
assert request.data == b'Hello World!'
return ''
@app.route("/post-base64", methods=["POST"])
def post_base64():
assert request.data == b"Hello World!"
return ""

8
integration/tests/post_bytes.py
View File

@ -1,8 +1,8 @@
from flask import request
from tests import app
@app.route('/post-bytes', methods=['POST'])
def post_bytes():
assert request.data == b'\x01\x02\x03'
return ''
@app.route("/post-bytes", methods=["POST"])
def post_bytes():
assert request.data == b"\x01\x02\x03"
return ""

8
integration/tests/post_file.py
View File

@ -1,8 +1,8 @@
from flask import request
from tests import app
@app.route('/post-file', methods=['POST'])
def post_file():
assert request.data == b'Hello World!'
return ''
@app.route("/post-file", methods=["POST"])
def post_file():
assert request.data == b"Hello World!"
return ""

76
integration/tests/post_json.py
View File

@ -2,74 +2,86 @@ from flask import request
from tests import app
@app.route('/post-json', methods=['POST'])
@app.route("/post-json", methods=["POST"])
def post_json():
assert request.headers['Content-Type'] == 'application/json'
assert request.headers["Content-Type"] == "application/json"
s = request.data.decode("utf-8")
print(s)
assert s == '''{
assert (
s
== """{
"name": "Bob",
"password": "&secret<>",
"age": 30,
"strict": true,
"spacing": "\\n",
"g_clef": "\\uD834\\uDD1E"
}'''
return ''
}"""
)
return ""
@app.route('/post-json-array', methods=['POST'])
@app.route("/post-json-array", methods=["POST"])
def post_json_array():
assert request.headers['Content-Type'] == 'application/json'
assert request.headers["Content-Type"] == "application/json"
s = request.data.decode("utf-8")
assert s == '[1,2,3]'
return ''
assert s == "[1,2,3]"
return ""
@app.route('/post-json-string', methods=['POST'])
@app.route("/post-json-string", methods=["POST"])
def post_json_string():
assert request.headers['Content-Type'] == 'application/json'
assert request.headers["Content-Type"] == "application/json"
s = request.data.decode("utf-8")
assert s == '"Hello"'
return ''
return ""
@app.route('/post-json-number', methods=['POST'])
@app.route("/post-json-number", methods=["POST"])
def post_json_number():
assert request.headers['Content-Type'] == 'application/json'
assert request.headers["Content-Type"] == "application/json"
s = request.data.decode("utf-8")
assert s == '100'
return ''
assert s == "100"
return ""
@app.route('/post-json-boolean', methods=['POST'])
@app.route("/post-json-boolean", methods=["POST"])
def post_json_boolean():
assert request.headers['Content-Type'] == 'application/json'
assert request.headers["Content-Type"] == "application/json"
s = request.data.decode("utf-8")
assert s == 'true'
return ''
assert s == "true"
return ""
@app.route('/post-json-numbers', methods=['POST'])
@app.route("/post-json-numbers", methods=["POST"])
def post_json_numbers():
assert request.headers['Content-Type'] == 'application/json'
assert request.headers["Content-Type"] == "application/json"
s = request.data.decode("utf-8")
assert s == '''{
assert (
s
== """{
"natural": 100,
"negative": -1,
"float": "3.333333333333333",
"exponent": 100e100
}'''
return ''
}"""
)
return ""
@app.route('/get-name')
@app.route("/get-name")
def get_name():
return 'Bob'
return "Bob"
@app.route('/check_name', methods=['POST'])
@app.route("/check_name", methods=["POST"])
def check_name():
assert request.headers['Content-Type'] == 'application/json'
assert request.headers["Content-Type"] == "application/json"
s = request.data.decode("utf-8")
assert s == '''{
assert (
s
== """{
"name": "Bob"
}'''
return ''
}"""
)
return ""

11
integration/tests/post_multilines.py
View File

@ -1,13 +1,14 @@
from flask import request
from tests import app
@app.route('/post-multilines', methods=['POST'])
@app.route("/post-multilines", methods=["POST"])
def post_multilines():
s = request.data.decode("utf-8")
assert s == "name,age\nbob,10\nbill,22\n"
return ''
return ""
@app.route('/get-bob-age', methods=['GET'])
@app.route("/get-bob-age", methods=["GET"])
def get_bob_age():
return '10'
return "10"

20
integration/tests/post_xml.py
View File

@ -2,16 +2,20 @@
from flask import request
from tests import app
@app.route('/post-xml', methods=['POST'])
@app.route("/post-xml", methods=["POST"])
def post_xml():
s = request.data.decode("utf-8")
assert s == '''<?xml version="1.0"?>
<drink>caf\u00e9</drink>'''
return ''
assert (
s
== """<?xml version="1.0"?>
<drink>caf\u00e9</drink>"""
)
return ""
@app.route('/post-xml-no-prolog', methods=['POST'])
@app.route("/post-xml-no-prolog", methods=["POST"])
def post_xml_no_prolog():
s = request.data.decode("utf-8")
assert s == '''<drink>caf\u00e9</drink>'''
return ''
assert s == """<drink>caf\u00e9</drink>"""
return ""

17
integration/tests/predicates_string.py
View File

@ -1,16 +1,17 @@
from flask import request
from tests import app
@app.route('/predicates-string')
@app.route("/predicates-string")
def predicates_string():
return 'Hello World!'
return "Hello World!"
@app.route('/predicates-string-empty')
@app.route("/predicates-string-empty")
def predicates_string_empty():
return ''
return ""
@app.route('/predicates-string-unicode')
@app.route("/predicates-string-unicode")
def predicates_string_unicode():
return '\u2708'
return "\u2708"

6
integration/tests/proxy.py
View File

@ -1,8 +1,8 @@
from tests import app
from flask import request
@app.route("/proxy")
def proxy():
assert request.headers['From-Proxy'] == 'Hello'
return ''
assert request.headers["From-Proxy"] == "Hello"
return ""

5
integration/tests/put.py
View File

@ -1,5 +1,6 @@
from tests import app
@app.route('/put', methods=['PUT'])
@app.route("/put", methods=["PUT"])
def put():
return ''
return ""

20
integration/tests/querystring_params.py
View File

@ -1,17 +1,19 @@
from tests import app
from flask import request
@app.route("/querystring-params")
def querystring_params():
assert request.args.get('param1') == 'value1'
assert request.args.get('param2') == ''
assert request.args.get('param3') == 'a=b'
assert request.args.get('param4') == '1,2,3'
return ''
assert request.args.get("param1") == "value1"
assert request.args.get("param2") == ""
assert request.args.get("param3") == "a=b"
assert request.args.get("param4") == "1,2,3"
return ""
@app.route("/querystring-params-encoded")
def querystring_params_encoded():
assert request.args.get('value1') == '/'
assert request.args.get('value2') == '/'
assert request.args.get('value3') == '/'
return ''
assert request.args.get("value1") == "/"
assert request.args.get("value2") == "/"
assert request.args.get("value3") == "/"
return ""

12
integration/tests/redirect.py
View File

@ -1,10 +1,12 @@
from tests import app
from flask import redirect
@app.route('/redirect')
def redirectme():
return redirect('http://localhost:8000/redirected')
@app.route('/redirected')
@app.route("/redirect")
def redirectme():
return redirect("http://localhost:8000/redirected")
@app.route("/redirected")
def redirected():
return ''
return ""

10
integration/tests/subquery_count.py
View File

@ -1,10 +1,12 @@
from tests import app
from flask import Response
@app.route("/subquery-count")
def subquery_count():
return Response('''{
return Response(
"""{
"users": ["Bob", "Bill", "Bruce"]
}''', mimetype='application/json')
}""",
mimetype="application/json",
)

6
integration/tests/user.py
View File

@ -1,10 +1,12 @@
# coding=utf-8
from tests import app
@app.route("/~user")
def url_with_tilde():
return 'user'
return "user"
@app.route("/!$&()*+,;=:@[]")
def url_weird():
return 'weird'
return "weird"

10
integration/tests/user_agent.py
View File

@ -1,12 +1,14 @@
from tests import app
from flask import request
@app.route("/user-agent/a")
def useragent_a():
assert 'Mozilla/5.0 A' == request.headers['User-Agent']
return ''
assert "Mozilla/5.0 A" == request.headers["User-Agent"]
return ""
@app.route("/user-agent/b")
def useragent_b():
assert 'Mozilla/5.0 B' == request.headers['User-Agent']
return ''
assert "Mozilla/5.0 B" == request.headers["User-Agent"]
return ""

3
integration/tests/utf8.py
View File

@ -1,6 +1,7 @@
# coding=utf-8
from tests import app
@app.route("/utf8")
def utf8():
return '<data>café</data>'
return "<data>café</data>"

33
integration/tests/variables.py
View File

@ -3,25 +3,22 @@ from tests import app
import json
@app.route('/variables', methods=['POST'])
@app.route("/variables", methods=["POST"])
def variables():
assert request.headers['Content-Type'] == 'application/json'
assert request.headers['Name'] == 'Jennifer'
assert request.headers['Age'] == '30'
assert request.headers['Female'] == 'true'
assert request.headers['Id'] == '123'
assert request.headers['Height'] == '1.7'
assert request.headers['A_null'] == 'null'
assert request.headers["Content-Type"] == "application/json"
assert request.headers["Name"] == "Jennifer"
assert request.headers["Age"] == "30"
assert request.headers["Female"] == "true"
assert request.headers["Id"] == "123"
assert request.headers["Height"] == "1.7"
assert request.headers["A_null"] == "null"
s = request.data.decode("utf-8")
data = json.loads(s)
assert data['name'] == 'Jennifer'
assert data['age'] == 30
assert data['female'] == True
assert data['id'] == '123'
assert data['height'] == 1.7
assert data['a_null'] is None
return ''
assert data["name"] == "Jennifer"
assert data["age"] == 30
assert data["female"] == True
assert data["id"] == "123"
assert data["height"] == 1.7
assert data["a_null"] is None
return ""