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')