def test_dispatchermiddleware():
def null_application(environ, start_response):
start_response('404 NOT FOUND', [('Content-Type', 'text/plain')])
yield b'NOT FOUND'
def dummy_application(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/plain')])
yield to_bytes(environ['SCRIPT_NAME'])
app = wsgi.DispatcherMiddleware(null_application, {
'/test1': dummy_application,
'/test2/very': dummy_application,
})
tests = {
'/test1': ('/test1', '/test1/asfd', '/test1/very'),
'/test2/very': ('/test2/very', '/test2/very/long/path/after/script/name')
}
for name, urls in tests.items():
for p in urls:
environ = create_environ(p)
app_iter, status, headers = run_wsgi_app(app, environ)
assert status == '200 OK'
assert b''.join(app_iter).strip() == to_bytes(name)
app_iter, status, headers = run_wsgi_app(
app, create_environ('/missing'))
assert status == '404 NOT FOUND'
assert b''.join(app_iter).strip() == b'NOT FOUND'
def test_shared_data_middleware(tmpdir):
def null_application(environ, start_response):
start_response("404 NOT FOUND", [("Content-Type", "text/plain")])
yield b"NOT FOUND"
test_dir = str(tmpdir)
with open(path.join(test_dir, to_native(u"äöü", "utf-8")), "w") as test_file:
test_file.write(u"FOUND")
app = wsgi.SharedDataMiddleware(
null_application,
{
"/": path.join(path.dirname(__file__), "res"),
"/sources": path.join(path.dirname(__file__), "res"),
"/pkg": ("werkzeug.debug", "shared"),
"/foo": test_dir,
},
)
for p in "/test.txt", "/sources/test.txt", "/foo/äöü":
app_iter, status, headers = run_wsgi_app(app, create_environ(p))
assert status == "200 OK"
with closing(app_iter) as app_iter:
data = b"".join(app_iter).strip()
assert data == b"FOUND"
app_iter, status, headers = run_wsgi_app(app, create_environ("/pkg/debugger.js"))
with closing(app_iter) as app_iter:
contents = b"".join(app_iter)
assert b"$(function() {" in contents
app_iter, status, headers = run_wsgi_app(app, create_environ("/missing"))
assert status == "404 NOT FOUND"
assert b"".join(app_iter).strip() == b"NOT FOUND"
def test_shared_data_middleware(tmpdir):
def null_application(environ, start_response):
start_response('404 NOT FOUND', [('Content-Type', 'text/plain')])
yield b'NOT FOUND'
test_dir = str(tmpdir)
with open(path.join(test_dir, to_native(u'äöü', 'utf-8')), 'w') as test_file:
test_file.write(u'FOUND')
app = wsgi.SharedDataMiddleware(null_application, {
'/': path.join(path.dirname(__file__), 'res'),
'/sources': path.join(path.dirname(__file__), 'res'),
'/pkg': ('werkzeug.debug', 'shared'),
'/foo': test_dir
})
for p in '/test.txt', '/sources/test.txt', '/foo/äöü':
app_iter, status, headers = run_wsgi_app(app, create_environ(p))
assert status == '200 OK'
with closing(app_iter) as app_iter:
data = b''.join(app_iter).strip()
assert data == b'FOUND'
app_iter, status, headers = run_wsgi_app(
app, create_environ('/pkg/debugger.js'))
with closing(app_iter) as app_iter:
contents = b''.join(app_iter)
assert b'$(function() {' in contents
app_iter, status, headers = run_wsgi_app(
app, create_environ('/missing'))
assert status == '404 NOT FOUND'
assert b''.join(app_iter).strip() == b'NOT FOUND'
def test_shared_data_middleware(self):
def null_application(environ, start_response):
start_response("404 NOT FOUND", [("Content-Type", "text/plain")])
yield b"NOT FOUND"
app = wsgi.SharedDataMiddleware(
null_application,
{
"/": path.join(path.dirname(__file__), "res"),
"/sources": path.join(path.dirname(__file__), "res"),
"/pkg": ("werkzeug.debug", "shared"),
},
)
for p in "/test.txt", "/sources/test.txt":
app_iter, status, headers = run_wsgi_app(app, create_environ(p))
self.assert_equal(status, "200 OK")
with closing(app_iter) as app_iter:
data = b"".join(app_iter).strip()
self.assert_equal(data, b"FOUND")
app_iter, status, headers = run_wsgi_app(app, create_environ("/pkg/debugger.js"))
with closing(app_iter) as app_iter:
contents = b"".join(app_iter)
self.assert_in(b"$(function() {", contents)
app_iter, status, headers = run_wsgi_app(app, create_environ("/missing"))
self.assert_equal(status, "404 NOT FOUND")
self.assert_equal(b"".join(app_iter).strip(), b"NOT FOUND")
def test_shared_data_middleware(self):
def null_application(environ, start_response):
start_response('404 NOT FOUND', [('Content-Type', 'text/plain')])
yield b'NOT FOUND'
app = wsgi.SharedDataMiddleware(null_application, {
'/': path.join(path.dirname(__file__), 'res'),
'/sources': path.join(path.dirname(__file__), 'res'),
'/pkg': ('werkzeug.debug', 'shared')
})
for p in '/test.txt', '/sources/test.txt':
app_iter, status, headers = run_wsgi_app(app, create_environ(p))
self.assert_equal(status, '200 OK')
with closing(app_iter) as app_iter:
data = b''.join(app_iter).strip()
self.assert_equal(data, b'FOUND')
app_iter, status, headers = run_wsgi_app(
app, create_environ('/pkg/debugger.js'))
with closing(app_iter) as app_iter:
contents = b''.join(app_iter)
self.assert_in(b'$(function() {', contents)
app_iter, status, headers = run_wsgi_app(
app, create_environ('/missing'))
self.assert_equal(status, '404 NOT FOUND')
self.assert_equal(b''.join(app_iter).strip(), b'NOT FOUND')
def test_run_wsgi_app_closing_iterator():
got_close = []
@implements_iterator
class CloseIter(object):
def __init__(self):
self.iterated = False
def __iter__(self):
return self
def close(self):
got_close.append(None)
def __next__(self):
if self.iterated:
raise StopIteration()
self.iterated = True
return 'bar'
def bar(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/plain')])
return CloseIter()
app_iter, status, headers = run_wsgi_app(bar, {})
assert status == '200 OK'
assert list(headers) == [('Content-Type', 'text/plain')]
assert next(app_iter) == 'bar'
pytest.raises(StopIteration, partial(next, app_iter))
app_iter.close()
assert run_wsgi_app(bar, {}, True)[0] == ['bar']
assert len(got_close) == 2
def send_invitations(self):
"""Call each application via our partyline connection protocol."""
operator = self.operator_class(self)
for script, application in [('', self.app)] + self.mounts.items():
base_url = (self.base_url or '/'.rstrip('/')) + script
environ = create_environ(path=self.invite_path, base_url=base_url)
environ[self.partyline_key] = operator
run_wsgi_app(application, environ)
def _handle(self, parser):
parser.add_argument("command", type=str, help="See ReadMe")
parser.add_argument("-d", action='store_true', default=False, help="Open Debug")
parser.add_argument("-s", action='store_true', default=False, help="Single Model")
parser.add_argument("-i", action='store_true', default=False, help="Show Command info")
self.options, arg = parser.parse_known_args()
# 是否开启DEBUG模式，会忽略配置中的DEBUG，用于线上调试
if self.options.d:
open_debug(True)
# 单元测试模式
app = self.options.command.split('/')[0]
if app in TEST_MODULE:
argv = sys.argv
argv.pop(1)
# if len(argv) == 1:
# argv.append('discover')
unittest.main(module=self.options.command.replace('/', '.'), argv=argv)
exit()
# 减少并发，单模式
# 如果发现之前的还在执行则停止当前
basedir = os.path.dirname('./tmp/')
file_name = '%s/%s' % (basedir, self.options.command.replace('/', '.'))
if self.options.s:
if os.path.isfile(file_name):
print 'Process is running'
exit()
if not os.path.exists(basedir):
os.makedirs(basedir)
with file(file_name, 'w'):
os.utime(file_name, None)
param_dict = {}
for param in arg:
mat = re.match(r'^--(.*)=(.*)', param)
if mat and mat.lastindex:
# 作为参数，通过manager.get_param()获取
param_dict[mat.group(1)] = mat.group(2)
else:
pass
application = PathDispatcher(create_app=create_app)
builder = EnvironBuilder(path=self.options.command, method='get')
builder.query_string = '&'.join(
["%s=%s" % (quote_plus(key), quote_plus(value)) for key, value in param_dict.items()])
try:
run_wsgi_app(application, builder.get_environ())
if self.options.s:
os.remove(file_name)
except AppNotExist as e:
return e.code
return 0
def send_invitations(self, apps):
'''Call each app at the invite route to establish a partyline. Called
on init.'''
PATH = '/__invite__/'
for app_name, app in apps.items():
environ = create_environ(path=PATH)
environ[self.partyline_key] = self.operator_class(self)
# A reference to the handling app. Used to id the app when
# responding to a handling request.
environ['partyline_handling_app'] = app_name
run_wsgi_app(app, environ)
def test_run_wsgi_app():
def foo(environ, start_response):
start_response("200 OK", [("Content-Type", "text/plain")])
yield "1"
yield "2"
yield "3"
app_iter, status, headers = run_wsgi_app(foo, {})
assert status == "200 OK"
assert list(headers) == [("Content-Type", "text/plain")]
assert next(app_iter) == "1"
assert next(app_iter) == "2"
assert next(app_iter) == "3"
pytest.raises(StopIteration, partial(next, app_iter))
got_close = []
@implements_iterator
class CloseIter(object):
def __init__(self):
self.iterated = False
def __iter__(self):
return self
def close(self):
got_close.append(None)
def __next__(self):
if self.iterated:
raise StopIteration()
self.iterated = True
return "bar"
def bar(environ, start_response):
start_response("200 OK", [("Content-Type", "text/plain")])
return CloseIter()
app_iter, status, headers = run_wsgi_app(bar, {})
assert status == "200 OK"
assert list(headers) == [("Content-Type", "text/plain")]
assert next(app_iter) == "bar"
pytest.raises(StopIteration, partial(next, app_iter))
app_iter.close()
assert run_wsgi_app(bar, {}, True)[0] == ["bar"]
assert len(got_close) == 2
def test_closing_iterator():
class Namespace(object):
got_close = False
got_additional = False
class Response(object):
def __init__(self, environ, start_response):
self.start = start_response
# Return a generator instead of making the object its own
# iterator. This ensures that ClosingIterator calls close on
# the iterable (the object), not the iterator.
def __iter__(self):
self.start('200 OK', [('Content-Type', 'text/plain')])
yield 'some content'
def close(self):
Namespace.got_close = True
def additional():
Namespace.got_additional = True
def app(environ, start_response):
return ClosingIterator(Response(environ, start_response), additional)
app_iter, status, headers = run_wsgi_app(
app, create_environ(), buffered=True)
assert ''.join(app_iter) == 'some content'
assert Namespace.got_close
assert Namespace.got_additional
def test_hsts_subdomains():
app = sslify(testapp.test_app, subdomains=True)
env = create_environ()
env['wsgi.url_scheme'] = 'https'
app_iter, status, headers = run_wsgi_app(app, env)
assert status == '200 OK'
assert headers['Strict-Transport-Security'] == 'max-age=31536000; includeSubDomains'
def test_hsts_off():
app = sslify(testapp.test_app, hsts=False)
env = create_environ()
env['wsgi.url_scheme'] = 'https'
app_iter, status, headers = run_wsgi_app(app, env)
assert status == '200 OK'
assert 'Strict-Transport-Security' not in headers
def test_hsts_defaults():
app = sslify(testapp.test_app)
env = create_environ()
env['wsgi.url_scheme'] = 'https'
app_iter, status, headers = run_wsgi_app(app, env)
assert status == '200 OK'
assert headers['Strict-Transport-Security'] == 'max-age=31536000'
def test_run_wsgi_app(self):
def foo(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/plain')])
yield '1'
yield '2'
yield '3'
app_iter, status, headers = run_wsgi_app(foo, {})
assert status == '200 OK'
assert headers == [('Content-Type', 'text/plain')]
assert app_iter.next() == '1'
assert app_iter.next() == '2'
assert app_iter.next() == '3'
self.assert_raises(StopIteration, app_iter.next)
got_close = []
class CloseIter(object):
def __init__(self):
self.iterated = False
def __iter__(self):
return self
def close(self):
got_close.append(None)
def next(self):
if self.iterated:
raise StopIteration()
self.iterated = True
return 'bar'
def bar(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/plain')])
return CloseIter()
app_iter, status, headers = run_wsgi_app(bar, {})
assert status == '200 OK'
assert headers == [('Content-Type', 'text/plain')]
assert app_iter.next() == 'bar'
self.assert_raises(StopIteration, app_iter.next)
app_iter.close()
assert run_wsgi_app(bar, {}, True)[0] == ['bar']
assert len(got_close) == 2
def test_run_wsgi_apps(self):
def simple_app(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return ['Hello World!']
app_iter, status, headers = run_wsgi_app(simple_app, {})
assert status == '200 OK'
assert headers == [('Content-Type', 'text/html')]
assert app_iter == ['Hello World!']
def yielding_app(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
yield 'Hello '
yield 'World!'
app_iter, status, headers = run_wsgi_app(yielding_app, {})
assert status == '200 OK'
assert headers == [('Content-Type', 'text/html')]
assert list(app_iter) == ['Hello ', 'World!']
def test_run_wsgi_apps(self):
def simple_app(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return ['Hello World!']
app_iter, status, headers = run_wsgi_app(simple_app, {})
self.assert_strict_equal(status, '200 OK')
self.assert_strict_equal(list(headers), [('Content-Type', 'text/html')])
self.assert_strict_equal(app_iter, ['Hello World!'])
def yielding_app(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
yield 'Hello '
yield 'World!'
app_iter, status, headers = run_wsgi_app(yielding_app, {})
self.assert_strict_equal(status, '200 OK')
self.assert_strict_equal(list(headers), [('Content-Type', 'text/html')])
self.assert_strict_equal(list(app_iter), ['Hello ', 'World!'])
def test_base_response():
# unicode
response = wrappers.BaseResponse(u'öäü')
strict_eq(response.get_data(), u'öäü'.encode('utf-8'))
# writing
response = wrappers.Response('foo')
response.stream.write('bar')
strict_eq(response.get_data(), b'foobar')
# set cookie
response = wrappers.BaseResponse()
response.set_cookie('foo', value='bar', max_age=60, expires=0,
path='/blub', domain='example.org', samesite='Strict')
strict_eq(response.headers.to_wsgi_list(), [
('Content-Type', 'text/plain; charset=utf-8'),
('Set-Cookie', 'foo=bar; Domain=example.org; Expires=Thu, '
'01-Jan-1970 00:00:00 GMT; Max-Age=60; Path=/blub; '
'SameSite=Strict')
])
# delete cookie
response = wrappers.BaseResponse()
response.delete_cookie('foo')
strict_eq(response.headers.to_wsgi_list(), [
('Content-Type', 'text/plain; charset=utf-8'),
('Set-Cookie', 'foo=; Expires=Thu, 01-Jan-1970 00:00:00 GMT; Max-Age=0; Path=/')
])
# close call forwarding
closed = []
@implements_iterator
class Iterable(object):
def __next__(self):
raise StopIteration()
def __iter__(self):
return self
def close(self):
closed.append(True)
response = wrappers.BaseResponse(Iterable())
response.call_on_close(lambda: closed.append(True))
app_iter, status, headers = run_wsgi_app(response,
create_environ(),
buffered=True)
strict_eq(status, '200 OK')
strict_eq(''.join(app_iter), '')
strict_eq(len(closed), 2)
# with statement
del closed[:]
response = wrappers.BaseResponse(Iterable())
with response:
pass
assert len(closed) == 1
def test_run_wsgi_app(self):
def foo(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/plain')])
yield '1'
yield '2'
yield '3'
app_iter, status, headers = run_wsgi_app(foo, {})
self.assert_equal(status, '200 OK')
self.assert_equal(list(headers), [('Content-Type', 'text/plain')])
self.assert_equal(next(app_iter), '1')
self.assert_equal(next(app_iter), '2')
self.assert_equal(next(app_iter), '3')
self.assert_raises(StopIteration, partial(next, app_iter))
got_close = []
@implements_iterator
class CloseIter(object):
def __init__(self):
self.iterated = False
def __iter__(self):
return self
def close(self):
got_close.append(None)
def __next__(self):
if self.iterated:
raise StopIteration()
self.iterated = True
return 'bar'
def bar(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/plain')])
return CloseIter()
app_iter, status, headers = run_wsgi_app(bar, {})
self.assert_equal(status, '200 OK')
self.assert_equal(list(headers), [('Content-Type', 'text/plain')])
self.assert_equal(next(app_iter), 'bar')
self.assert_raises(StopIteration, partial(next, app_iter))
app_iter.close()
self.assert_equal(run_wsgi_app(bar, {}, True)[0], ['bar'])
self.assert_equal(len(got_close), 2)
def test_run_wsgi_apps():
def simple_app(environ, start_response):
start_response("200 OK", [("Content-Type", "text/html")])
return ["Hello World!"]
app_iter, status, headers = run_wsgi_app(simple_app, {})
strict_eq(status, "200 OK")
strict_eq(list(headers), [("Content-Type", "text/html")])
strict_eq(app_iter, ["Hello World!"])
def yielding_app(environ, start_response):
start_response("200 OK", [("Content-Type", "text/html")])
yield "Hello "
yield "World!"
app_iter, status, headers = run_wsgi_app(yielding_app, {})
strict_eq(status, "200 OK")
strict_eq(list(headers), [("Content-Type", "text/html")])
strict_eq(list(app_iter), ["Hello ", "World!"])
def test_shared_data_middleware(self):
def null_application(environ, start_response):
start_response('404 NOT FOUND', [('Content-Type', 'text/plain')])
yield 'NOT FOUND'
app = wsgi.SharedDataMiddleware(null_application, {
'/': path.join(path.dirname(__file__), 'res'),
'/sources': path.join(path.dirname(__file__), 'res'),
'/pkg': ('werkzeug.debug', 'shared')
})
for p in '/test.txt', '/sources/test.txt':
app_iter, status, headers = run_wsgi_app(app, create_environ(p))
assert status == '200 OK'
assert ''.join(app_iter).strip() == 'FOUND'
app_iter, status, headers = run_wsgi_app(app, create_environ('/pkg/debugger.js'))
contents = ''.join(app_iter)
assert '$(function() {' in contents
app_iter, status, headers = run_wsgi_app(app, create_environ('/missing'))
assert status == '404 NOT FOUND'
assert ''.join(app_iter).strip() == 'NOT FOUND'
def test_dispatchermiddleware():
def null_application(environ, start_response):
start_response("404 NOT FOUND", [("Content-Type", "text/plain")])
yield b"NOT FOUND"
def dummy_application(environ, start_response):
start_response("200 OK", [("Content-Type", "text/plain")])
yield to_bytes(environ["SCRIPT_NAME"])
app = wsgi.DispatcherMiddleware(null_application, {"/test1": dummy_application, "/test2/very": dummy_application})
tests = {
"/test1": ("/test1", "/test1/asfd", "/test1/very"),
"/test2/very": ("/test2/very", "/test2/very/long/path/after/script/name"),
}
for name, urls in tests.items():
for p in urls:
environ = create_environ(p)
app_iter, status, headers = run_wsgi_app(app, environ)
assert status == "200 OK"
assert b"".join(app_iter).strip() == to_bytes(name)
app_iter, status, headers = run_wsgi_app(app, create_environ("/missing"))
assert status == "404 NOT FOUND"
assert b"".join(app_iter).strip() == b"NOT FOUND"
def test_base_response(self):
# unicode
response = wrappers.BaseResponse(u"öäü")
assert response.data == "öäü"
# writing
response = wrappers.Response("foo")
response.stream.write("bar")
assert response.data == "foobar"
# set cookie
response = wrappers.BaseResponse()
response.set_cookie("foo", "bar", 60, 0, "/blub", "example.org", False)
assert response.headers.to_list() == [
("Content-Type", "text/plain; charset=utf-8"),
(
"Set-Cookie",
"foo=bar; Domain=example.org; expires=Thu, " "01-Jan-1970 00:00:00 GMT; Max-Age=60; Path=/blub",
),
]
# delete cookie
response = wrappers.BaseResponse()
response.delete_cookie("foo")
assert response.headers.to_list() == [
("Content-Type", "text/plain; charset=utf-8"),
("Set-Cookie", "foo=; expires=Thu, 01-Jan-1970 00:00:00 GMT; Max-Age=0; Path=/"),
]
# close call forwarding
closed = []
class Iterable(object):
def next(self):
raise StopIteration()
def __iter__(self):
return self
def close(self):
closed.append(True)
response = wrappers.BaseResponse(Iterable())
response.call_on_close(lambda: closed.append(True))
app_iter, status, headers = run_wsgi_app(response, create_environ(), buffered=True)
assert status == "200 OK"
assert "".join(app_iter) == ""
assert len(closed) == 2
def test_base_response(self):
# unicode
response = wrappers.BaseResponse(u'öäü')
assert response.data == 'öäü'
# writing
response = wrappers.Response('foo')
response.stream.write('bar')
assert response.data == 'foobar'
# set cookie
response = wrappers.BaseResponse()
response.set_cookie('foo', 'bar', 60, 0, '/blub', 'example.org', False)
assert response.headers.to_list() == [
('Content-Type', 'text/plain; charset=utf-8'),
('Set-Cookie', 'foo=bar; Domain=example.org; expires=Thu, '
'01-Jan-1970 00:00:00 GMT; Max-Age=60; Path=/blub')
]
# delete cookie
response = wrappers.BaseResponse()
response.delete_cookie('foo')
assert response.headers.to_list() == [
('Content-Type', 'text/plain; charset=utf-8'),
('Set-Cookie', 'foo=; expires=Thu, 01-Jan-1970 00:00:00 GMT; Max-Age=0; Path=/')
]
# close call forwarding
closed = []
class Iterable(object):
def next(self):
raise StopIteration()
def __iter__(self):
return self
def close(self):
closed.append(True)
response = wrappers.BaseResponse(Iterable())
response.call_on_close(lambda: closed.append(True))
app_iter, status, headers = run_wsgi_app(response,
create_environ(),
buffered=True)
assert status == '200 OK'
assert ''.join(app_iter) == ''
assert len(closed) == 2
def test_run_wsgi_apps(buffered, iterable):
leaked_data = []
def simple_app(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return ['Hello World!']
def yielding_app(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
yield 'Hello '
yield 'World!'
def late_start_response(environ, start_response):
yield 'Hello '
yield 'World'
start_response('200 OK', [('Content-Type', 'text/html')])
yield '!'
def depends_on_close(environ, start_response):
leaked_data.append('harhar')
start_response('200 OK', [('Content-Type', 'text/html')])
class Rv(object):
def __iter__(self):
yield 'Hello '
yield 'World'
yield '!'
def close(self):
assert leaked_data.pop() == 'harhar'
return Rv()
for app in (simple_app, yielding_app, late_start_response,
depends_on_close):
if iterable:
app = iterable_middleware(app)
app_iter, status, headers = run_wsgi_app(app, {}, buffered=buffered)
strict_eq(status, '200 OK')
strict_eq(list(headers), [('Content-Type', 'text/html')])
strict_eq(''.join(app_iter), 'Hello World!')
if hasattr(app_iter, 'close'):
app_iter.close()
assert not leaked_data
def test_run_wsgi_apps(buffered, iterable):
leaked_data = []
def simple_app(environ, start_response):
start_response("200 OK", [("Content-Type", "text/html")])
return ["Hello World!"]
def yielding_app(environ, start_response):
start_response("200 OK", [("Content-Type", "text/html")])
yield "Hello "
yield "World!"
def late_start_response(environ, start_response):
yield "Hello "
yield "World"
start_response("200 OK", [("Content-Type", "text/html")])
yield "!"
def depends_on_close(environ, start_response):
leaked_data.append("harhar")
start_response("200 OK", [("Content-Type", "text/html")])
class Rv(object):
def __iter__(self):
yield "Hello "
yield "World"
yield "!"
def close(self):
assert leaked_data.pop() == "harhar"
return Rv()
for app in (simple_app, yielding_app, late_start_response, depends_on_close):
if iterable:
app = iterable_middleware(app)
app_iter, status, headers = run_wsgi_app(app, {}, buffered=buffered)
strict_eq(status, "200 OK")
strict_eq(list(headers), [("Content-Type", "text/html")])
strict_eq("".join(app_iter), "Hello World!")
if hasattr(app_iter, "close"):
app_iter.close()
assert not leaked_data
def test_lazy_start_response_empty_response_app(buffered, iterable):
@implements_iterator
class app:
def __init__(self, environ, start_response):
self.start_response = start_response
def __iter__(self):
return self
def __next__(self):
self.start_response('200 OK', [('Content-Type', 'text/html')])
raise StopIteration
if iterable:
app = iterable_middleware(app)
app_iter, status, headers = run_wsgi_app(app, {}, buffered=buffered)
strict_eq(status, '200 OK')
strict_eq(list(headers), [('Content-Type', 'text/html')])
strict_eq(''.join(app_iter), '')
def test_base_response():
# unicode
response = wrappers.BaseResponse(u"öäü")
strict_eq(response.get_data(), u"öäü".encode("utf-8"))
# writing
response = wrappers.Response("foo")
response.stream.write("bar")
strict_eq(response.get_data(), b"foobar")
# set cookie
response = wrappers.BaseResponse()
response.set_cookie("foo", "bar", 60, 0, "/blub", "example.org")
strict_eq(
response.headers.to_wsgi_list(),
[
("Content-Type", "text/plain; charset=utf-8"),
(
"Set-Cookie",
"foo=bar; Domain=example.org; Expires=Thu, " "01-Jan-1970 00:00:00 GMT; Max-Age=60; Path=/blub",
),
],
)
# delete cookie
response = wrappers.BaseResponse()
response.delete_cookie("foo")
strict_eq(
response.headers.to_wsgi_list(),
[
("Content-Type", "text/plain; charset=utf-8"),
("Set-Cookie", "foo=; Expires=Thu, 01-Jan-1970 00:00:00 GMT; Max-Age=0; Path=/"),
],
)
# close call forwarding
closed = []
@implements_iterator
class Iterable(object):
def __next__(self):
raise StopIteration()
def __iter__(self):
return self
def close(self):
closed.append(True)
response = wrappers.BaseResponse(Iterable())
response.call_on_close(lambda: closed.append(True))
app_iter, status, headers = run_wsgi_app(response, create_environ(), buffered=True)
strict_eq(status, "200 OK")
strict_eq("".join(app_iter), "")
strict_eq(len(closed), 2)
# with statement
del closed[:]
response = wrappers.BaseResponse(Iterable())
with response:
pass
assert len(closed) == 1
def send_invitations(self, invites):
"""Call each invite route to establish a partyline."""
for invite in invites:
environ = create_environ(path=invite)
environ[self.partyline_key] = self.operator_class(self)
run_wsgi_app(self.application, environ)
def test_https_proxy_custom_header():
app = sslify(testapp.test_app, proxy_header='X-PROTO')
env = create_environ()
env['HTTP_X_PROTO'] = 'https'
app_iter, status, headers = run_wsgi_app(app, env)
assert status == '200 OK'
def test_https_proxy_doesnt_redirect():
app = sslify(testapp.test_app)
env = create_environ()
env['HTTP_X_FORWARDED_PROTO'] = 'https'
app_iter, status, headers = run_wsgi_app(app, env)
assert status == '200 OK'
def test_redirect_to_http():
app = sslify(testapp.test_app)
env = create_environ()
app_iter, status, headers = run_wsgi_app(app, env)
assert status == '301 Moved Permanently'
assert headers['Location'].startswith('https://')
def test_https_doesnt_redirect():
app = sslify(testapp.test_app)
env = create_environ()
env['wsgi.url_scheme'] = 'https'
app_iter, status, headers = run_wsgi_app(app, env)
assert status == '200 OK'
def test_permanent():
app = sslify(testapp.test_app, permanent=False)
env = create_environ()
app_iter, status, headers = run_wsgi_app(app, env)
assert status == '302 Found'
assert headers['Location'].startswith('https://')
def test_base_response():
# unicode
response = wrappers.BaseResponse(u'öäü')
strict_eq(response.get_data(), u'öäü'.encode('utf-8'))
# writing
response = wrappers.Response('foo')
response.stream.write('bar')
strict_eq(response.get_data(), b'foobar')
# set cookie
response = wrappers.BaseResponse()
response.set_cookie('foo',
value='bar',
max_age=60,
expires=0,
path='/blub',
domain='example.org')
strict_eq(response.headers.to_wsgi_list(),
[('Content-Type', 'text/plain; charset=utf-8'),
('Set-Cookie', 'foo=bar; Domain=example.org; Expires=Thu, '
'01-Jan-1970 00:00:00 GMT; Max-Age=60; Path=/blub')])
# delete cookie
response = wrappers.BaseResponse()
response.delete_cookie('foo')
strict_eq(
response.headers.to_wsgi_list(),
[('Content-Type', 'text/plain; charset=utf-8'),
('Set-Cookie',
'foo=; Expires=Thu, 01-Jan-1970 00:00:00 GMT; Max-Age=0; Path=/')])
# close call forwarding
closed = []
@implements_iterator
class Iterable(object):
def __next__(self):
raise StopIteration()
def __iter__(self):
return self
def close(self):
closed.append(True)
response = wrappers.BaseResponse(Iterable())
response.call_on_close(lambda: closed.append(True))
app_iter, status, headers = run_wsgi_app(response,
create_environ(),
buffered=True)
strict_eq(status, '200 OK')
strict_eq(''.join(app_iter), '')
strict_eq(len(closed), 2)
# with statement
del closed[:]
response = wrappers.BaseResponse(Iterable())
with response:
pass
assert len(closed) == 1
def test_redirect_to_http():
app = sslify(testapp.test_app)
env = create_environ()
app_iter, status, headers = run_wsgi_app(app, env)
assert status == '301 Moved Permanently'
assert headers['Location'].startswith('https://')
