From 99f4f18c33e3bddca2f6253e956bd8e13e7879dc Mon Sep 17 00:00:00 2001 From: Jakub Stasiak Date: Sun, 13 Jul 2014 20:43:33 +0100 Subject: [PATCH] wsgi: websocket: Reformat code + tests (PEP-8) --- eventlet/websocket.py | 27 +-- eventlet/wsgi.py | 57 +++--- tests/websocket_new_test.py | 92 +++++----- tests/websocket_test.py | 354 ++++++++++++++++++------------------ tests/wsgi_test.py | 13 +- 5 files changed, 278 insertions(+), 265 deletions(-) diff --git a/eventlet/websocket.py b/eventlet/websocket.py index 8a60816..c8b2e4a 100644 --- a/eventlet/websocket.py +++ b/eventlet/websocket.py @@ -11,7 +11,7 @@ from socket import error as SocketError try: from hashlib import md5, sha1 -except ImportError: #pragma NO COVER +except ImportError: # pragma NO COVER from md5 import md5 from sha import sha as sha1 @@ -72,6 +72,7 @@ class WebSocketWSGI(object): function. Note that the server will log the websocket request at the time of closure. """ + def __init__(self, handler): self.handler = handler self.protocol_version = None @@ -171,8 +172,8 @@ class WebSocketWSGI(object): "Connection: Upgrade\r\n" "WebSocket-Origin: %s\r\n" "WebSocket-Location: %s\r\n\r\n" % ( - environ.get('HTTP_ORIGIN'), - location)) + environ.get('HTTP_ORIGIN'), + location)) elif self.protocol_version == 76: handshake_reply = ("HTTP/1.1 101 WebSocket Protocol Handshake\r\n" "Upgrade: WebSocket\r\n" @@ -181,11 +182,11 @@ class WebSocketWSGI(object): "Sec-WebSocket-Protocol: %s\r\n" "Sec-WebSocket-Location: %s\r\n" "\r\n%s" % ( - environ.get('HTTP_ORIGIN'), - environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL', 'default'), - location, - response)) - else: #pragma NO COVER + environ.get('HTTP_ORIGIN'), + environ.get('HTTP_SEC_WEBSOCKET_PROTOCOL', 'default'), + location, + response)) + else: # pragma NO COVER raise ValueError("Unknown WebSocket protocol version.") sock.sendall(handshake_reply) return WebSocket(sock, environ, self.protocol_version) @@ -215,7 +216,7 @@ class WebSocketWSGI(object): negotiated_protocol = p break #extensions = environ.get('HTTP_SEC_WEBSOCKET_EXTENSIONS', None) - #if extensions: + # if extensions: # extensions = [i.strip() for i in extensions.split(',')] key = environ['HTTP_SEC_WEBSOCKET_KEY'] @@ -245,6 +246,7 @@ class WebSocketWSGI(object): spaces += 1 return int(out) / spaces + class WebSocket(object): """A websocket object that handles the details of serialization/deserialization to the socket. @@ -264,6 +266,7 @@ class WebSocket(object): The full WSGI environment for this request. """ + def __init__(self, sock, environ, version=76): """ :param socket: The eventlet socket @@ -310,10 +313,10 @@ class WebSocket(object): if frame_type == 0: # Normal message. end_idx = buf.find("\xFF") - if end_idx == -1: #pragma NO COVER + if end_idx == -1: # pragma NO COVER break msgs.append(buf[1:end_idx].decode('utf-8', 'replace')) - buf = buf[end_idx+1:] + buf = buf[end_idx + 1:] elif frame_type == 255: # Closing handshake. assert ord(buf[1]) == 0, "Unexpected closing handshake: %r" % buf @@ -367,7 +370,7 @@ class WebSocket(object): except SocketError: # Sometimes, like when the remote side cuts off the connection, # we don't care about this. - if not ignore_send_errors: #pragma NO COVER + if not ignore_send_errors: # pragma NO COVER raise self.websocket_closed = True diff --git a/eventlet/wsgi.py b/eventlet/wsgi.py index 94a6334..4854fb5 100644 --- a/eventlet/wsgi.py +++ b/eventlet/wsgi.py @@ -21,14 +21,14 @@ MAX_HEADER_LINE = 8192 MAX_TOTAL_HEADER_SIZE = 65536 MINIMUM_CHUNK_SIZE = 4096 # %(client_port)s is also available -DEFAULT_LOG_FORMAT= ('%(client_ip)s - - [%(date_time)s] "%(request_line)s"' - ' %(status_code)s %(body_length)s %(wall_seconds).6f') +DEFAULT_LOG_FORMAT = ('%(client_ip)s - - [%(date_time)s] "%(request_line)s"' + ' %(status_code)s %(body_length)s %(wall_seconds).6f') __all__ = ['server', 'format_date_time'] # Weekday and month names for HTTP date/time formatting; always English! _weekdayname = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"] -_monthname = [None, # Dummy so we can use 1-based month numbers +_monthname = [None, # Dummy so we can use 1-based month numbers "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] @@ -85,7 +85,7 @@ class Input(object): def _do_read(self, reader, length=None): if self.wfile is not None: - ## 100 Continue + # 100 Continue self.wfile.write(self.wfile_line) self.wfile = None self.wfile_line = None @@ -105,7 +105,7 @@ class Input(object): def _chunked_read(self, rfile, length=None, use_readline=False): if self.wfile is not None: - ## 100 Continue + # 100 Continue self.wfile.write(self.wfile_line) self.wfile = None self.wfile_line = None @@ -221,7 +221,7 @@ class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler): self.wfile = socket._fileobject(conn, "wb", self.wbufsize) else: # it's a SSLObject, or a martian - raise NotImplementedError("wsgi.py doesn't support sockets "\ + raise NotImplementedError("wsgi.py doesn't support sockets " "of type %s" % type(conn)) def handle_one_request(self): @@ -325,13 +325,13 @@ class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler): client_conn = self.headers.get('Connection', '').lower() send_keep_alive = False if self.close_connection == 0 and \ - self.server.keepalive and (client_conn == 'keep-alive' or \ - (self.request_version == 'HTTP/1.1' and - not client_conn == 'close')): + self.server.keepalive and (client_conn == 'keep-alive' or + (self.request_version == 'HTTP/1.1' and + not client_conn == 'close')): # only send keep-alives back to clients that sent them, # it's redundant for 1.1 connections - send_keep_alive = (client_conn == 'keep-alive') - self.close_connection = 0 + send_keep_alive = (client_conn == 'keep-alive') + self.close_connection = 0 else: self.close_connection = 1 @@ -351,7 +351,7 @@ class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler): # end of header writing if use_chunked[0]: - ## Write the chunked encoding + # Write the chunked encoding towrite.append("%x\r\n%s\r\n" % (len(data), data)) else: towrite.append(data) @@ -359,17 +359,18 @@ class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler): _writelines(towrite) length[0] = length[0] + sum(map(len, towrite)) except UnicodeEncodeError: - self.server.log_message("Encountered non-ascii unicode while attempting to write wsgi response: %r" % [x for x in towrite if isinstance(x, six.text_type)]) + self.server.log_message( + "Encountered non-ascii unicode while attempting to write wsgi response: %r" % [x for x in towrite if isinstance(x, six.text_type)]) self.server.log_message(traceback.format_exc()) _writelines( ["HTTP/1.1 500 Internal Server Error\r\n", - "Connection: close\r\n", - "Content-type: text/plain\r\n", - "Content-length: 98\r\n", - "Date: %s\r\n" % format_date_time(time.time()), - "\r\n", - ("Internal Server Error: wsgi application passed " - "a unicode object to the server instead of a string.")]) + "Connection: close\r\n", + "Content-type: text/plain\r\n", + "Content-length: 98\r\n", + "Date: %s\r\n" % format_date_time(time.time()), + "\r\n", + ("Internal Server Error: wsgi application passed " + "a unicode object to the server instead of a string.")]) def start_response(status, response_headers, exc_info=None): status_code[0] = status.split()[0] @@ -398,7 +399,7 @@ class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler): try: result = self.application(self.environ, start_response) if (isinstance(result, _AlreadyHandled) - or isinstance(getattr(result, '_obj', None), _AlreadyHandled)): + or isinstance(getattr(result, '_obj', None), _AlreadyHandled)): self.close_connection = 1 return @@ -441,9 +442,9 @@ class HttpProtocol(BaseHTTPServer.BaseHTTPRequestHandler): if hasattr(result, 'close'): result.close() if (self.environ['eventlet.input'].chunked_input or - self.environ['eventlet.input'].position \ + self.environ['eventlet.input'].position < self.environ['eventlet.input'].content_length): - ## Read and discard body if there was no pending 100-continue + # Read and discard body if there was no pending 100-continue if not self.environ['eventlet.input'].wfile: # NOTE: MINIMUM_CHUNK_SIZE is used here for purpose different than chunking. # We use it only cause it's at hand and has reasonable value in terms of @@ -595,7 +596,7 @@ class Server(BaseHTTPServer.HTTPServer): Please, make sure you know what you are doing. HTTP headers names are case-insensitive per RFC standard. Most likely, you need to fix HTTP parsing in your client software.""", - DeprecationWarning, stacklevel=3) + DeprecationWarning, stacklevel=3) def get_environ(self): d = { @@ -740,10 +741,10 @@ def server(sock, site, try: pool.spawn_n(serv.process_request, client_socket) except AttributeError: - warnings.warn("wsgi's pool should be an instance of " \ - "eventlet.greenpool.GreenPool, is %s. Please convert your"\ - " call site to use GreenPool instead" % type(pool), - DeprecationWarning, stacklevel=2) + warnings.warn("wsgi's pool should be an instance of " + "eventlet.greenpool.GreenPool, is %s. Please convert your" + " call site to use GreenPool instead" % type(pool), + DeprecationWarning, stacklevel=2) pool.execute_async(serv.process_request, client_socket) except ACCEPT_EXCEPTIONS as e: if get_errno(e) not in ACCEPT_ERRNO: diff --git a/tests/websocket_new_test.py b/tests/websocket_new_test.py index 284a867..4089ec1 100644 --- a/tests/websocket_new_test.py +++ b/tests/websocket_new_test.py @@ -39,11 +39,11 @@ class TestWebSocket(_TestBase): def test_incomplete_headers_13(self): headers = dict(kv.split(': ') for kv in [ - "Upgrade: websocket", - # NOTE: intentionally no connection header - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Version: 13", ]) + "Upgrade: websocket", + # NOTE: intentionally no connection header + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Version: 13", ]) http = httplib.HTTPConnection('localhost', self.port) http.request("GET", "/echo", headers=headers) resp = http.getresponse() @@ -54,11 +54,11 @@ class TestWebSocket(_TestBase): # Now, miss off key headers = dict(kv.split(': ') for kv in [ - "Upgrade: websocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Version: 13", ]) + "Upgrade: websocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Version: 13", ]) http = httplib.HTTPConnection('localhost', self.port) http.request("GET", "/echo", headers=headers) resp = http.getresponse() @@ -69,10 +69,10 @@ class TestWebSocket(_TestBase): # No Upgrade now headers = dict(kv.split(': ') for kv in [ - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Version: 13", ]) + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Version: 13", ]) http = httplib.HTTPConnection('localhost', self.port) http.request("GET", "/echo", headers=headers) resp = http.getresponse() @@ -81,7 +81,6 @@ class TestWebSocket(_TestBase): self.assertEqual(resp.getheader('connection'), 'close') self.assertEqual(resp.read(), '') - def test_correct_upgrade_request_13(self): for http_connection in ['Upgrade', 'UpGrAdE', 'keep-alive, Upgrade']: connect = [ @@ -97,7 +96,7 @@ class TestWebSocket(_TestBase): sock.sendall('\r\n'.join(connect) + '\r\n\r\n') result = sock.recv(1024) - ## The server responds the correct Websocket handshake + # The server responds the correct Websocket handshake print('Connection string: %r' % http_connection) self.assertEqual(result, '\r\n'.join([ 'HTTP/1.1 101 Switching Protocols', @@ -108,13 +107,13 @@ class TestWebSocket(_TestBase): def test_send_recv_13(self): connect = [ - "GET /echo HTTP/1.1", - "Upgrade: websocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Version: 13", - "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] + "GET /echo HTTP/1.1", + "Upgrade: websocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Version: 13", + "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] sock = eventlet.connect( ('localhost', self.port)) @@ -134,6 +133,7 @@ class TestWebSocket(_TestBase): error_detected = [False] done_with_request = event.Event() site = self.site + def error_detector(environ, start_response): try: try: @@ -146,13 +146,13 @@ class TestWebSocket(_TestBase): self.site = error_detector self.spawn_server() connect = [ - "GET /echo HTTP/1.1", - "Upgrade: websocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Version: 13", - "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] + "GET /echo HTTP/1.1", + "Upgrade: websocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Version: 13", + "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') @@ -165,6 +165,7 @@ class TestWebSocket(_TestBase): error_detected = [False] done_with_request = event.Event() site = self.site + def error_detector(environ, start_response): try: try: @@ -177,13 +178,13 @@ class TestWebSocket(_TestBase): self.site = error_detector self.spawn_server() connect = [ - "GET /echo HTTP/1.1", - "Upgrade: websocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Version: 13", - "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] + "GET /echo HTTP/1.1", + "Upgrade: websocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Version: 13", + "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') @@ -197,6 +198,7 @@ class TestWebSocket(_TestBase): error_detected = [False] done_with_request = event.Event() site = self.site + def error_detector(environ, start_response): try: try: @@ -209,17 +211,17 @@ class TestWebSocket(_TestBase): self.site = error_detector self.spawn_server() connect = [ - "GET /echo HTTP/1.1", - "Upgrade: websocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Version: 13", - "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] + "GET /echo HTTP/1.1", + "Upgrade: websocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Version: 13", + "Sec-WebSocket-Key: d9MXuOzlVQ0h+qRllvSCIg==", ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') resp = sock.recv(1024) # get the headers - sock.sendall('\x07\xff') # Weird packet. + sock.sendall('\x07\xff') # Weird packet. done_with_request.wait() assert not error_detected[0] diff --git a/tests/websocket_test.py b/tests/websocket_test.py index e2a2570..3c07248 100644 --- a/tests/websocket_test.py +++ b/tests/websocket_test.py @@ -1,13 +1,13 @@ -import socket import errno +import socket import eventlet -from eventlet.green import urllib2 -from eventlet.green import httplib -from eventlet.websocket import WebSocket, WebSocketWSGI -from eventlet import wsgi from eventlet import event from eventlet import greenio +from eventlet import wsgi +from eventlet.green import httplib +from eventlet.green import urllib2 +from eventlet.websocket import WebSocket, WebSocketWSGI from tests import mock, LimitedTestCase, certificate_file, private_key_file from tests import skip_if_no_ssl @@ -34,6 +34,7 @@ def handle(ws): wsapp = WebSocketWSGI(handle) + class TestWebSocket(_TestBase): TEST_TIMEOUT = 5 @@ -51,12 +52,12 @@ class TestWebSocket(_TestBase): def test_incomplete_headers_75(self): headers = dict(kv.split(': ') for kv in [ - "Upgrade: WebSocket", - # NOTE: intentionally no connection header - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "WebSocket-Protocol: ws", - ]) + "Upgrade: WebSocket", + # NOTE: intentionally no connection header + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "WebSocket-Protocol: ws", + ]) http = httplib.HTTPConnection('localhost', self.port) http.request("GET", "/echo", headers=headers) resp = http.getresponse() @@ -68,12 +69,12 @@ class TestWebSocket(_TestBase): def test_incomplete_headers_76(self): # First test: Missing Connection: headers = dict(kv.split(': ') for kv in [ - "Upgrade: WebSocket", - # NOTE: intentionally no connection header - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - ]) + "Upgrade: WebSocket", + # NOTE: intentionally no connection header + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + ]) http = httplib.HTTPConnection('localhost', self.port) http.request("GET", "/echo", headers=headers) resp = http.getresponse() @@ -84,14 +85,14 @@ class TestWebSocket(_TestBase): # Now, miss off key2 headers = dict(kv.split(': ') for kv in [ - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - # NOTE: Intentionally no Key2 header - ]) + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + # NOTE: Intentionally no Key2 header + ]) http = httplib.HTTPConnection('localhost', self.port) http.request("GET", "/echo", headers=headers) resp = http.getresponse() @@ -102,19 +103,19 @@ class TestWebSocket(_TestBase): def test_correct_upgrade_request_75(self): connect = [ - "GET /echo HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "WebSocket-Protocol: ws", - ] + "GET /echo HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "WebSocket-Protocol: ws", + ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') result = sock.recv(1024) - ## The server responds the correct Websocket handshake + # The server responds the correct Websocket handshake self.assertEqual(result, '\r\n'.join(['HTTP/1.1 101 Web Socket Protocol Handshake', 'Upgrade: WebSocket', @@ -124,21 +125,21 @@ class TestWebSocket(_TestBase): def test_correct_upgrade_request_76(self): connect = [ - "GET /echo HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET /echo HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') result = sock.recv(1024) - ## The server responds the correct Websocket handshake + # The server responds the correct Websocket handshake self.assertEqual(result, '\r\n'.join(['HTTP/1.1 101 WebSocket Protocol Handshake', 'Upgrade: WebSocket', @@ -147,19 +148,18 @@ class TestWebSocket(_TestBase): 'Sec-WebSocket-Protocol: ws', 'Sec-WebSocket-Location: ws://localhost:%s/echo\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.port])) - def test_query_string(self): # verify that the query string comes out the other side unscathed connect = [ - "GET /echo?query_string HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET /echo?query_string HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.connect( ('localhost', self.port)) @@ -176,38 +176,38 @@ class TestWebSocket(_TestBase): def test_empty_query_string(self): # verify that a single trailing ? doesn't get nuked connect = [ - "GET /echo? HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET /echo? HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') result = sock.recv(1024) - self.assertEqual(result, - '\r\n'.join(['HTTP/1.1 101 WebSocket Protocol Handshake', - 'Upgrade: WebSocket', - 'Connection: Upgrade', - 'Sec-WebSocket-Origin: http://localhost:%s' % self.port, - 'Sec-WebSocket-Protocol: ws', - 'Sec-WebSocket-Location: ws://localhost:%s/echo?\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.port])) - + self.assertEqual(result, '\r\n'.join([ + 'HTTP/1.1 101 WebSocket Protocol Handshake', + 'Upgrade: WebSocket', + 'Connection: Upgrade', + 'Sec-WebSocket-Origin: http://localhost:%s' % self.port, + 'Sec-WebSocket-Protocol: ws', + 'Sec-WebSocket-Location: ws://localhost:%s/echo?\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.port, + ])) def test_sending_messages_to_websocket_75(self): connect = [ - "GET /echo HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "WebSocket-Protocol: ws", - ] + "GET /echo HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "WebSocket-Protocol: ws", + ] sock = eventlet.connect( ('localhost', self.port)) @@ -227,15 +227,15 @@ class TestWebSocket(_TestBase): def test_sending_messages_to_websocket_76(self): connect = [ - "GET /echo HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET /echo HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.connect( ('localhost', self.port)) @@ -255,13 +255,13 @@ class TestWebSocket(_TestBase): def test_getting_messages_from_websocket_75(self): connect = [ - "GET /range HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "WebSocket-Protocol: ws", - ] + "GET /range HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "WebSocket-Protocol: ws", + ] sock = eventlet.connect( ('localhost', self.port)) @@ -278,15 +278,15 @@ class TestWebSocket(_TestBase): def test_getting_messages_from_websocket_76(self): connect = [ - "GET /range HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET /range HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.connect( ('localhost', self.port)) @@ -305,6 +305,7 @@ class TestWebSocket(_TestBase): error_detected = [False] done_with_request = event.Event() site = self.site + def error_detector(environ, start_response): try: try: @@ -317,13 +318,13 @@ class TestWebSocket(_TestBase): self.site = error_detector self.spawn_server() connect = [ - "GET /range HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "WebSocket-Protocol: ws", - ] + "GET /range HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "WebSocket-Protocol: ws", + ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') @@ -336,6 +337,7 @@ class TestWebSocket(_TestBase): error_detected = [False] done_with_request = event.Event() site = self.site + def error_detector(environ, start_response): try: try: @@ -348,15 +350,15 @@ class TestWebSocket(_TestBase): self.site = error_detector self.spawn_server() connect = [ - "GET /range HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET /range HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') @@ -369,6 +371,7 @@ class TestWebSocket(_TestBase): error_detected = [False] done_with_request = event.Event() site = self.site + def error_detector(environ, start_response): try: try: @@ -381,20 +384,20 @@ class TestWebSocket(_TestBase): self.site = error_detector self.spawn_server() connect = [ - "GET /echo HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET /echo HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') resp = sock.recv(1024) # get the headers - sock.sendall('\xff\x00') # "Close the connection" packet. + sock.sendall('\xff\x00') # "Close the connection" packet. done_with_request.wait() assert not error_detected[0] @@ -402,6 +405,7 @@ class TestWebSocket(_TestBase): error_detected = [False] done_with_request = event.Event() site = self.site + def error_detector(environ, start_response): try: try: @@ -414,34 +418,34 @@ class TestWebSocket(_TestBase): self.site = error_detector self.spawn_server() connect = [ - "GET /echo HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET /echo HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') resp = sock.recv(1024) # get the headers - sock.sendall('\xef\x00') # Weird packet. + sock.sendall('\xef\x00') # Weird packet. done_with_request.wait() assert error_detected[0] def test_server_closing_connect_76(self): connect = [ - "GET / HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET / HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.connect( ('localhost', self.port)) @@ -455,6 +459,7 @@ class TestWebSocket(_TestBase): error_detected = [False] done_with_request = event.Event() site = self.site + def error_detector(environ, start_response): try: try: @@ -467,13 +472,13 @@ class TestWebSocket(_TestBase): self.site = error_detector self.spawn_server() connect = [ - "GET /error HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "WebSocket-Protocol: ws", - ] + "GET /error HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "WebSocket-Protocol: ws", + ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n') @@ -485,6 +490,7 @@ class TestWebSocket(_TestBase): error_detected = [False] done_with_request = event.Event() site = self.site + def error_detector(environ, start_response): try: try: @@ -497,15 +503,15 @@ class TestWebSocket(_TestBase): self.site = error_detector self.spawn_server() connect = [ - "GET /error HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET /error HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.connect( ('localhost', self.port)) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') @@ -526,17 +532,17 @@ class TestWebSocketSSL(_TestBase): server_side=True) self.spawn_server(sock=s) connect = [ - "GET /echo HTTP/1.1", - "Upgrade: WebSocket", - "Connection: Upgrade", - "Host: localhost:%s" % self.port, - "Origin: http://localhost:%s" % self.port, - "Sec-WebSocket-Protocol: ws", - "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", - "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", - ] + "GET /echo HTTP/1.1", + "Upgrade: WebSocket", + "Connection: Upgrade", + "Host: localhost:%s" % self.port, + "Origin: http://localhost:%s" % self.port, + "Sec-WebSocket-Protocol: ws", + "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5", + "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00", + ] sock = eventlet.wrap_ssl(eventlet.connect( - ('localhost', self.port))) + ('localhost', self.port))) sock.sendall('\r\n'.join(connect) + '\r\n\r\n^n:ds[4U') first_resp = sock.recv(1024) @@ -558,7 +564,6 @@ class TestWebSocketSSL(_TestBase): eventlet.sleep(0.01) - class TestWebSocketObject(LimitedTestCase): def setUp(self): @@ -580,7 +585,6 @@ class TestWebSocketObject(LimitedTestCase): self.assertEqual(ws._buf, '') self.assertEqual(len(ws._msgs), 0) - def test_send_to_ws(self): ws = self.test_ws ws.send(u'hello') diff --git a/tests/wsgi_test.py b/tests/wsgi_test.py index 6cc6b23..9c46a89 100644 --- a/tests/wsgi_test.py +++ b/tests/wsgi_test.py @@ -262,9 +262,9 @@ class TestHttpd(_TestBase): fd.flush() result = fd.read() fd.close() - ## The server responds with the maximum version it supports + # The server responds with the maximum version it supports assert result.startswith('HTTP'), result - assert result.endswith('hello world') + assert result.endswith('hello world'), result def test_002_keepalive(self): sock = eventlet.connect( @@ -445,7 +445,8 @@ class TestHttpd(_TestBase): sock = eventlet.connect(('localhost', self.port)) sock = eventlet.wrap_ssl(sock) - sock.write(b'POST /foo HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nContent-length:3\r\n\r\nabc') + sock.write( + b'POST /foo HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nContent-length:3\r\n\r\nabc') result = sock.read(8192) self.assertEqual(result[-3:], 'abc') @@ -750,7 +751,8 @@ class TestHttpd(_TestBase): result = read_http(sock) self.assertEqual(result.status, 'HTTP/1.1 417 Expectation Failed') self.assertEqual(result.body, 'failure') - fd.write(b'PUT / HTTP/1.1\r\nHost: localhost\r\nContent-length: 7\r\nExpect: 100-continue\r\n\r\ntesting') + fd.write( + b'PUT / HTTP/1.1\r\nHost: localhost\r\nContent-length: 7\r\nExpect: 100-continue\r\n\r\ntesting') fd.flush() header_lines = [] while True: @@ -1448,7 +1450,8 @@ class TestChunkedInput(_TestBase): def test_chunked_readline(self): body = self.body() - req = "POST /lines HTTP/1.1\r\nContent-Length: %s\r\ntransfer-encoding: Chunked\r\n\r\n%s" % (len(body), body) + req = "POST /lines HTTP/1.1\r\nContent-Length: %s\r\ntransfer-encoding: Chunked\r\n\r\n%s" % ( + len(body), body) fd = self.connect() fd.sendall(req.encode())