wsgi: websocket: Reformat code + tests (PEP-8)

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