def test_cors_origin_single(self):
self._app.mod_opts["cors_origin"] = "http://example.com"
response = yield self.http_client.fetch(
self.get_url("/login"),
method="POST",
body=urllib.parse.urlencode(self.auth_creds),
headers={"Content-Type": self.content_type_map["form"]},
)
token = salt.utils.json.loads(self.decode_body(response).body)["return"][0][
"token"
]
url = "ws://127.0.0.1:{}/all_events/{}".format(self.get_http_port(), token)
# Example.com should works
request = HTTPRequest(
url, headers={"Origin": "http://example.com", "Host": "example.com"}
)
ws = yield websocket_connect(request)
ws.write_message("websocket client ready")
ws.close()
# But foo.bar not
request = HTTPRequest(
url, headers={"Origin": "http://foo.bar", "Host": "example.com"}
)
try:
ws = yield websocket_connect(request)
except HTTPError as error:
self.assertEqual(error.code, 403)
def test_cors_origin_multiple(self):
self._app.mod_opts["cors_origin"] = ["http://example.com", "http://foo.bar"]
response = yield self.http_client.fetch(
self.get_url("/login"),
method="POST",
body=urlencode(self.auth_creds),
headers={"Content-Type": self.content_type_map["form"]},
)
token = salt.utils.json.loads(self.decode_body(response).body)["return"][0][
"token"
]
url = "ws://127.0.0.1:{0}/all_events/{1}".format(self.get_http_port(), token)
# Example.com should works
request = HTTPRequest(
url, headers={"Origin": "http://example.com", "Host": "example.com"}
)
ws = yield websocket_connect(request)
ws.write_message("websocket client ready")
ws.close()
# Foo.bar too
request = HTTPRequest(
url, headers={"Origin": "http://foo.bar", "Host": "example.com"}
)
ws = yield websocket_connect(request)
ws.write_message("websocket client ready")
ws.close()
async def test_cors_origin_single(app, http_client, auth_creds,
content_type_map, http_server_port):
app.mod_opts["cors_origin"] = "http://example.com"
response = await http_client.fetch(
"/login",
method="POST",
body=urllib.parse.urlencode(auth_creds),
headers={"Content-Type": content_type_map["form"]},
)
token = salt.utils.json.loads(response.body)["return"][0]["token"]
url = "ws://127.0.0.1:{}/all_events/{}".format(http_server_port, token)
# Example.com should works
request = HTTPRequest(url,
headers={
"Origin": "http://example.com",
"Host": "example.com"
})
ws = await websocket_connect(request)
ws.write_message("websocket client ready")
ws.close()
# But foo.bar not
request = HTTPRequest(url,
headers={
"Origin": "http://foo.bar",
"Host": "example.com"
})
with pytest.raises(HTTPError) as exc:
await websocket_connect(request)
assert exc.value.code == 403
def test_error_with_response(self):
resp = HTTPResponse(HTTPRequest('http://example.com/'), 403)
with self.assertRaises(HTTPError) as cm:
resp.rethrow()
e = cm.exception
self.assertEqual(str(e), "HTTP 403: Forbidden")
self.assertEqual(repr(e), "HTTP 403: Forbidden")
def test_str(self):
response = HTTPResponse(HTTPRequest('http://example.com'),
200,
headers={},
buffer=BytesIO())
s = str(response)
self.assertTrue(s.startswith('HTTPResponse('))
self.assertIn('code=200', s)
def test_websocket_headers(self):
# Ensure that arbitrary headers can be passed through websocket_connect.
ws = yield websocket_connect(
HTTPRequest('ws://127.0.0.1:%d/header' % self.get_http_port(),
headers={'X-Test': 'hello'}))
response = yield ws.read_message()
self.assertEqual(response, 'hello')
yield self.close(ws)
def test_check_origin_invalid_partial_url(self):
port = self.get_http_port()
url = 'ws://127.0.0.1:%d/echo' % port
headers = {'Origin': '127.0.0.1:%d' % port}
with self.assertRaises(HTTPError) as cm:
yield websocket_connect(HTTPRequest(url, headers=headers),
io_loop=self.io_loop)
self.assertEqual(cm.exception.code, 403)
def test_websocket_header_echo(self):
# Ensure that headers can be returned in the response.
# Specifically, that arbitrary headers passed through websocket_connect
# can be returned.
ws = yield websocket_connect(
HTTPRequest('ws://127.0.0.1:%d/header_echo' % self.get_http_port(),
headers={'X-Test-Hello': 'hello'}))
self.assertEqual(ws.headers.get('X-Test-Hello'), 'hello')
self.assertEqual(ws.headers.get('X-Extra-Response-Header'),
'Extra-Response-Value')
yield self.close(ws)
def test_check_origin_valid_with_path(self):
port = self.get_http_port()
url = 'ws://127.0.0.1:%d/echo' % port
headers = {'Origin': 'http://127.0.0.1:%d/something' % port}
ws = yield websocket_connect(HTTPRequest(url, headers=headers),
io_loop=self.io_loop)
ws.write_message('hello')
response = yield ws.read_message()
self.assertEqual(response, 'hello')
yield self.close(ws)
def test_websocket_handler_bad_token(self):
"""
A bad token should returns a 401 during a websocket connect
"""
token = 'A'*len(getattr(hashlib, self.opts.get('hash_type', 'md5'))().hexdigest())
url = 'ws://127.0.0.1:{0}/all_events/{1}'.format(self.get_http_port(), token)
request = HTTPRequest(url, headers={'Origin': 'http://example.com',
'Host': 'example.com'})
try:
ws = yield websocket_connect(request)
except HTTPError as error:
self.assertEqual(error.code, 401)
def test_check_origin_invalid_subdomains(self):
port = self.get_http_port()
url = 'ws://localhost:%d/echo' % port
# Subdomains should be disallowed by default. If we could pass a
# resolver to websocket_connect we could test sibling domains as well.
headers = {'Origin': 'http://subtenant.localhost'}
with self.assertRaises(HTTPError) as cm:
yield websocket_connect(HTTPRequest(url, headers=headers),
io_loop=self.io_loop)
self.assertEqual(cm.exception.code, 403)
def test_websocket_handler_upgrade_to_websocket(self):
response = yield self.http_client.fetch(self.get_url('/login'),
method='POST',
body=urlencode(self.auth_creds),
headers={'Content-Type': self.content_type_map['form']})
token = salt.utils.json.loads(self.decode_body(response).body)['return'][0]['token']
url = 'ws://127.0.0.1:{0}/all_events/{1}'.format(self.get_http_port(), token)
request = HTTPRequest(url, headers={'Origin': 'http://example.com',
'Host': 'example.com'})
ws = yield websocket_connect(request)
ws.write_message('websocket client ready')
ws.close()
def test_check_origin_invalid(self):
port = self.get_http_port()
url = 'ws://127.0.0.1:%d/echo' % port
# Host is 127.0.0.1, which should not be accessible from some other
# domain
headers = {'Origin': 'http://somewhereelse.com'}
with self.assertRaises(HTTPError) as cm:
yield websocket_connect(HTTPRequest(url, headers=headers),
io_loop=self.io_loop)
self.assertEqual(cm.exception.code, 403)
def test_cors_origin_multiple(self):
self._app.mod_opts['cors_origin'] = ['http://example.com', 'http://foo.bar']
response = yield self.http_client.fetch(self.get_url('/login'),
method='POST',
body=urlencode(self.auth_creds),
headers={'Content-Type': self.content_type_map['form']})
token = salt.utils.json.loads(self.decode_body(response).body)['return'][0]['token']
url = 'ws://127.0.0.1:{0}/all_events/{1}'.format(self.get_http_port(), token)
# Example.com should works
request = HTTPRequest(url, headers={'Origin': 'http://example.com',
'Host': 'example.com'})
ws = yield websocket_connect(request)
ws.write_message('websocket client ready')
ws.close()
# Foo.bar too
request = HTTPRequest(url, headers={'Origin': 'http://foo.bar',
'Host': 'example.com'})
ws = yield websocket_connect(request)
ws.write_message('websocket client ready')
ws.close()
def test_prepare_curl_callback_stack_context(self):
exc_info = []
def error_handler(typ, value, tb):
exc_info.append((typ, value, tb))
self.stop()
return True
with ExceptionStackContext(error_handler):
request = HTTPRequest(self.get_url('/'),
prepare_curl_callback=lambda curl: 1 / 0)
self.http_client.fetch(request, callback=self.stop)
self.wait()
self.assertEqual(1, len(exc_info))
self.assertIs(exc_info[0][0], ZeroDivisionError)
def test_websocket_handler_bad_token(self):
"""
A bad token should returns a 401 during a websocket connect
"""
token = "A" * len(
getattr(hashlib, self.opts.get("hash_type", "md5"))().hexdigest()
)
url = "ws://127.0.0.1:{0}/all_events/{1}".format(self.get_http_port(), token)
request = HTTPRequest(
url, headers={"Origin": "http://example.com", "Host": "example.com"}
)
try:
ws = yield websocket_connect(request)
except HTTPError as error:
self.assertEqual(error.code, 401)
async def test_websocket_handler_bad_token(client_config, http_server):
"""
A bad token should returns a 401 during a websocket connect
"""
token = "A" * len(
getattr(hashlib, client_config.get("hash_type", "md5"))().hexdigest())
url = "ws://127.0.0.1:{}/all_events/{}".format(http_server.port, token)
request = HTTPRequest(url,
headers={
"Origin": "http://example.com",
"Host": "example.com"
})
with pytest.raises(HTTPError) as exc:
await websocket_connect(request)
assert exc.value.code == 401
def test_websocket_handler_upgrade_to_websocket(self):
response = yield self.http_client.fetch(
self.get_url("/login"),
method="POST",
body=urlencode(self.auth_creds),
headers={"Content-Type": self.content_type_map["form"]},
)
token = salt.utils.json.loads(self.decode_body(response).body)["return"][0][
"token"
]
url = "ws://127.0.0.1:{0}/all_events/{1}".format(self.get_http_port(), token)
request = HTTPRequest(
url, headers={"Origin": "http://example.com", "Host": "example.com"}
)
ws = yield websocket_connect(request)
ws.write_message("websocket client ready")
ws.close()
async def test_websocket_handler_upgrade_to_websocket(http_client, auth_creds,
content_type_map,
http_server_port):
response = await http_client.fetch(
"/login",
method="POST",
body=urllib.parse.urlencode(auth_creds),
headers={"Content-Type": content_type_map["form"]},
)
token = salt.utils.json.loads(response.body)["return"][0]["token"]
url = "ws://127.0.0.1:{}/all_events/{}".format(http_server_port, token)
request = HTTPRequest(url,
headers={
"Origin": "http://example.com",
"Host": "example.com"
})
ws = await websocket_connect(request)
ws.write_message("websocket client ready")
ws.close()
def test_request_set(self):
proxy = _RequestProxy(
HTTPRequest('http://example.com/', user_agent='foo'), dict())
self.assertEqual(proxy.user_agent, 'foo')
def test_neither_set(self):
proxy = _RequestProxy(HTTPRequest('http://example.com/'), dict())
self.assertIs(proxy.auth_username, None)
def test_null_headers_setter(self):
request = HTTPRequest('http://example.com')
request.headers = None
self.assertEqual(request.headers, {})
def test_headers(self):
request = HTTPRequest('http://example.com', headers={'foo': 'bar'})
self.assertEqual(request.headers, {'foo': 'bar'})
def test_default_set(self):
proxy = _RequestProxy(HTTPRequest('http://example.com/'),
dict(network_interface='foo'))
self.assertEqual(proxy.network_interface, 'foo')
def test_defaults_none(self):
proxy = _RequestProxy(HTTPRequest('http://example.com/'), None)
self.assertIs(proxy.auth_username, None)
def test_bad_attribute(self):
proxy = _RequestProxy(HTTPRequest('http://example.com/'), dict())
with self.assertRaises(AttributeError):
proxy.foo
def test_body_setter(self):
request = HTTPRequest('http://example.com')
request.body = 'foo'
self.assertEqual(request.body, utf8('foo'))
def test_if_modified_since(self):
http_date = datetime.datetime.utcnow()
request = HTTPRequest('http://example.com',
if_modified_since=http_date)
self.assertEqual(request.headers,
{'If-Modified-Since': format_timestamp(http_date)})
def test_headers_setter(self):
request = HTTPRequest('http://example.com')
request.headers = {'bar': 'baz'}
self.assertEqual(request.headers, {'bar': 'baz'})
def test_both_set(self):
proxy = _RequestProxy(
HTTPRequest('http://example.com/', proxy_host='foo'),
dict(proxy_host='bar'))
self.assertEqual(proxy.proxy_host, 'foo')
