Debian Codegraph @

tests/websocket_test.py

raw
1 import errno
2 import socket
3 import sys
4
5 import eventlet
6 from eventlet import event
7 from eventlet import greenio
8 from eventlet.green import httplib
9 from eventlet.websocket import WebSocket, WebSocketWSGI
10
11 import tests
12 from tests import mock
13 import tests.wsgi_test
14
15
16 # demo app
17 def handle(ws):
18 if ws.path == '/echo':
19 while True:
20 m = ws.wait()
21 if m is None:
22 break
23 ws.send(m)
24 elif ws.path == '/range':
25 for i in range(10):
26 ws.send("msg %d" % i)
27 eventlet.sleep(0.01)
28 elif ws.path == '/error':
29 # some random socket error that we shouldn't normally get
30 raise OSError(errno.ENOTSOCK)
31 else:
32 ws.close()
33
34
35 wsapp = WebSocketWSGI(handle)
36
37
38 class TestWebSocket(tests.wsgi_test._TestBase):
39 TEST_TIMEOUT = 5
40
41 def set_site(self):
42 self.site = wsapp
43
44 def test_incorrect_headers(self):
45 http = httplib.HTTPConnection(*self.server_addr)
46 http.request("GET", "/echo")
47 response = http.getresponse()
48 assert response.status == 400
49
50 def test_incomplete_headers_75(self):
51 headers = dict(kv.split(': ') for kv in [
52 "Upgrade: WebSocket",
53 # NOTE: intentionally no connection header
54 "Host: %s:%s" % self.server_addr,
55 "Origin: http://%s:%s" % self.server_addr,
56 "WebSocket-Protocol: ws",
57 ])
58 http = httplib.HTTPConnection(*self.server_addr)
59 http.request("GET", "/echo", headers=headers)
60 resp = http.getresponse()
61
62 self.assertEqual(resp.status, 400)
63 self.assertEqual(resp.getheader('connection'), 'close')
64 self.assertEqual(resp.read(), b'')
65
66 def test_incomplete_headers_76(self):
67 # First test: Missing Connection:
68 headers = dict(kv.split(': ') for kv in [
69 "Upgrade: WebSocket",
70 # NOTE: intentionally no connection header
71 "Host: %s:%s" % self.server_addr,
72 "Origin: http://%s:%s" % self.server_addr,
73 "Sec-WebSocket-Protocol: ws",
74 ])
75 http = httplib.HTTPConnection(*self.server_addr)
76 http.request("GET", "/echo", headers=headers)
77 resp = http.getresponse()
78
79 self.assertEqual(resp.status, 400)
80 self.assertEqual(resp.getheader('connection'), 'close')
81 self.assertEqual(resp.read(), b'')
82
83 # Now, miss off key2
84 headers = dict(kv.split(': ') for kv in [
85 "Upgrade: WebSocket",
86 "Connection: Upgrade",
87 "Host: %s:%s" % self.server_addr,
88 "Origin: http://%s:%s" % self.server_addr,
89 "Sec-WebSocket-Protocol: ws",
90 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
91 # NOTE: Intentionally no Key2 header
92 ])
93 http = httplib.HTTPConnection(*self.server_addr)
94 http.request("GET", "/echo", headers=headers)
95 resp = http.getresponse()
96
97 self.assertEqual(resp.status, 400)
98 self.assertEqual(resp.getheader('connection'), 'close')
99 self.assertEqual(resp.read(), b'')
100
101 def test_correct_upgrade_request_75(self):
102 connect = [
103 "GET /echo HTTP/1.1",
104 "Upgrade: WebSocket",
105 "Connection: Upgrade",
106 "Host: %s:%s" % self.server_addr,
107 "Origin: http://%s:%s" % self.server_addr,
108 "WebSocket-Protocol: ws",
109 ]
110 sock = eventlet.connect(self.server_addr)
111
112 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n')
113 result = sock.recv(1024)
114 # The server responds the correct Websocket handshake
115 self.assertEqual(result, '\r\n'.join([
116 'HTTP/1.1 101 Web Socket Protocol Handshake',
117 'Upgrade: WebSocket',
118 'Connection: Upgrade',
119 'WebSocket-Origin: http://%s:%s' % self.server_addr,
120 'WebSocket-Location: ws://%s:%s/echo\r\n\r\n' % self.server_addr,
121 ]).encode())
122
123 def test_correct_upgrade_request_76(self):
124 connect = [
125 "GET /echo HTTP/1.1",
126 "Upgrade: WebSocket",
127 "Connection: Upgrade",
128 "Host: %s:%s" % self.server_addr,
129 "Origin: http://%s:%s" % self.server_addr,
130 "Sec-WebSocket-Protocol: ws",
131 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
132 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
133 ]
134 sock = eventlet.connect(self.server_addr)
135
136 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
137 result = sock.recv(1024)
138 # The server responds the correct Websocket handshake
139 self.assertEqual(result, '\r\n'.join([
140 'HTTP/1.1 101 WebSocket Protocol Handshake',
141 'Upgrade: WebSocket',
142 'Connection: Upgrade',
143 'Sec-WebSocket-Origin: http://%s:%s' % self.server_addr,
144 'Sec-WebSocket-Protocol: ws',
145 'Sec-WebSocket-Location: ws://%s:%s/echo\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.server_addr,
146 ]).encode())
147
148 def test_query_string(self):
149 # verify that the query string comes out the other side unscathed
150 connect = [
151 "GET /echo?query_string HTTP/1.1",
152 "Upgrade: WebSocket",
153 "Connection: Upgrade",
154 "Host: %s:%s" % self.server_addr,
155 "Origin: http://%s:%s" % self.server_addr,
156 "Sec-WebSocket-Protocol: ws",
157 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
158 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
159 ]
160 sock = eventlet.connect(self.server_addr)
161
162 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
163 result = sock.recv(1024)
164 self.assertEqual(result, '\r\n'.join([
165 'HTTP/1.1 101 WebSocket Protocol Handshake',
166 'Upgrade: WebSocket',
167 'Connection: Upgrade',
168 'Sec-WebSocket-Origin: http://%s:%s' % self.server_addr,
169 'Sec-WebSocket-Protocol: ws',
170 'Sec-WebSocket-Location: '
171 'ws://%s:%s/echo?query_string\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.server_addr,
172 ]).encode())
173
174 def test_empty_query_string(self):
175 # verify that a single trailing ? doesn't get nuked
176 connect = [
177 "GET /echo? HTTP/1.1",
178 "Upgrade: WebSocket",
179 "Connection: Upgrade",
180 "Host: %s:%s" % self.server_addr,
181 "Origin: http://%s:%s" % self.server_addr,
182 "Sec-WebSocket-Protocol: ws",
183 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
184 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
185 ]
186 sock = eventlet.connect(self.server_addr)
187
188 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
189 result = sock.recv(1024)
190 self.assertEqual(result, '\r\n'.join([
191 'HTTP/1.1 101 WebSocket Protocol Handshake',
192 'Upgrade: WebSocket',
193 'Connection: Upgrade',
194 'Sec-WebSocket-Origin: http://%s:%s' % self.server_addr,
195 'Sec-WebSocket-Protocol: ws',
196 'Sec-WebSocket-Location: ws://%s:%s/echo?\r\n\r\n8jKS\'y:G*Co,Wxa-' % self.server_addr,
197 ]).encode())
198
199 def test_sending_messages_to_websocket_75(self):
200 connect = [
201 "GET /echo HTTP/1.1",
202 "Upgrade: WebSocket",
203 "Connection: Upgrade",
204 "Host: %s:%s" % self.server_addr,
205 "Origin: http://%s:%s" % self.server_addr,
206 "WebSocket-Protocol: ws",
207 ]
208 sock = eventlet.connect(self.server_addr)
209
210 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n')
211 sock.recv(1024)
212 sock.sendall(b'\x00hello\xFF')
213 result = sock.recv(1024)
214 self.assertEqual(result, b'\x00hello\xff')
215 sock.sendall(b'\x00start')
216 eventlet.sleep(0.001)
217 sock.sendall(b' end\xff')
218 result = sock.recv(1024)
219 self.assertEqual(result, b'\x00start end\xff')
220 sock.shutdown(socket.SHUT_RDWR)
221 sock.close()
222 eventlet.sleep(0.01)
223
224 def test_sending_messages_to_websocket_76(self):
225 connect = [
226 "GET /echo HTTP/1.1",
227 "Upgrade: WebSocket",
228 "Connection: Upgrade",
229 "Host: %s:%s" % self.server_addr,
230 "Origin: http://%s:%s" % self.server_addr,
231 "Sec-WebSocket-Protocol: ws",
232 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
233 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
234 ]
235 sock = eventlet.connect(self.server_addr)
236
237 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
238 sock.recv(1024)
239 sock.sendall(b'\x00hello\xFF')
240 result = sock.recv(1024)
241 self.assertEqual(result, b'\x00hello\xff')
242 sock.sendall(b'\x00start')
243 eventlet.sleep(0.001)
244 sock.sendall(b' end\xff')
245 result = sock.recv(1024)
246 self.assertEqual(result, b'\x00start end\xff')
247 sock.shutdown(socket.SHUT_RDWR)
248 sock.close()
249 eventlet.sleep(0.01)
250
251 def test_getting_messages_from_websocket_75(self):
252 connect = [
253 "GET /range HTTP/1.1",
254 "Upgrade: WebSocket",
255 "Connection: Upgrade",
256 "Host: %s:%s" % self.server_addr,
257 "Origin: http://%s:%s" % self.server_addr,
258 "WebSocket-Protocol: ws",
259 ]
260 sock = eventlet.connect(self.server_addr)
261
262 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n')
263 resp = sock.recv(1024)
264 headers, result = resp.split(b'\r\n\r\n')
265 msgs = [result.strip(b'\x00\xff')]
266 cnt = 10
267 while cnt:
268 msgs.append(sock.recv(20).strip(b'\x00\xff'))
269 cnt -= 1
270 # Last item in msgs is an empty string
271 self.assertEqual(msgs[:-1], [('msg %d' % i).encode() for i in range(10)])
272
273 def test_getting_messages_from_websocket_76(self):
274 connect = [
275 "GET /range HTTP/1.1",
276 "Upgrade: WebSocket",
277 "Connection: Upgrade",
278 "Host: %s:%s" % self.server_addr,
279 "Origin: http://%s:%s" % self.server_addr,
280 "Sec-WebSocket-Protocol: ws",
281 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
282 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
283 ]
284 sock = eventlet.connect(self.server_addr)
285
286 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
287 resp = sock.recv(1024)
288 headers, result = resp.split(b'\r\n\r\n')
289 msgs = [result[16:].strip(b'\x00\xff')]
290 cnt = 10
291 while cnt:
292 msgs.append(sock.recv(20).strip(b'\x00\xff'))
293 cnt -= 1
294 # Last item in msgs is an empty string
295 self.assertEqual(msgs[:-1], [('msg %d' % i).encode() for i in range(10)])
296
297 def test_breaking_the_connection_75(self):
298 error_detected = [False]
299 done_with_request = event.Event()
300 site = self.site
301
302 def error_detector(environ, start_response):
303 try:
304 try:
305 return site(environ, start_response)
306 except:
307 error_detected[0] = True
308 raise
309 finally:
310 done_with_request.send(True)
311 self.site = error_detector
312 self.spawn_server()
313 connect = [
314 "GET /range HTTP/1.1",
315 "Upgrade: WebSocket",
316 "Connection: Upgrade",
317 "Host: %s:%s" % self.server_addr,
318 "Origin: http://%s:%s" % self.server_addr,
319 "WebSocket-Protocol: ws",
320 ]
321 sock = eventlet.connect(self.server_addr)
322 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n')
323 sock.recv(1024) # get the headers
324 sock.close() # close while the app is running
325 done_with_request.wait()
326 assert not error_detected[0]
327
328 def test_breaking_the_connection_76(self):
329 error_detected = [False]
330 done_with_request = event.Event()
331 site = self.site
332
333 def error_detector(environ, start_response):
334 try:
335 try:
336 return site(environ, start_response)
337 except:
338 error_detected[0] = True
339 raise
340 finally:
341 done_with_request.send(True)
342 self.site = error_detector
343 self.spawn_server()
344 connect = [
345 "GET /range HTTP/1.1",
346 "Upgrade: WebSocket",
347 "Connection: Upgrade",
348 "Host: %s:%s" % self.server_addr,
349 "Origin: http://%s:%s" % self.server_addr,
350 "Sec-WebSocket-Protocol: ws",
351 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
352 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
353 ]
354 sock = eventlet.connect(self.server_addr)
355 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
356 sock.recv(1024) # get the headers
357 sock.close() # close while the app is running
358 done_with_request.wait()
359 assert not error_detected[0]
360
361 def test_client_closing_connection_76(self):
362 error_detected = [False]
363 done_with_request = event.Event()
364 site = self.site
365
366 def error_detector(environ, start_response):
367 try:
368 try:
369 return site(environ, start_response)
370 except:
371 error_detected[0] = True
372 raise
373 finally:
374 done_with_request.send(True)
375 self.site = error_detector
376 self.spawn_server()
377 connect = [
378 "GET /echo HTTP/1.1",
379 "Upgrade: WebSocket",
380 "Connection: Upgrade",
381 "Host: %s:%s" % self.server_addr,
382 "Origin: http://%s:%s" % self.server_addr,
383 "Sec-WebSocket-Protocol: ws",
384 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
385 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
386 ]
387 sock = eventlet.connect(self.server_addr)
388 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
389 sock.recv(1024) # get the headers
390 sock.sendall(b'\xff\x00') # "Close the connection" packet.
391 done_with_request.wait()
392 assert not error_detected[0]
393
394 def test_client_invalid_packet_76(self):
395 error_detected = [False]
396 done_with_request = event.Event()
397 site = self.site
398
399 def error_detector(environ, start_response):
400 try:
401 try:
402 return site(environ, start_response)
403 except:
404 error_detected[0] = True
405 raise
406 finally:
407 done_with_request.send(True)
408 self.site = error_detector
409 self.spawn_server()
410 connect = [
411 "GET /echo HTTP/1.1",
412 "Upgrade: WebSocket",
413 "Connection: Upgrade",
414 "Host: %s:%s" % self.server_addr,
415 "Origin: http://%s:%s" % self.server_addr,
416 "Sec-WebSocket-Protocol: ws",
417 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
418 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
419 ]
420 sock = eventlet.connect(self.server_addr)
421 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
422 sock.recv(1024) # get the headers
423 sock.sendall(b'\xef\x00') # Weird packet.
424 done_with_request.wait()
425 assert error_detected[0]
426
427 def test_server_closing_connect_76(self):
428 connect = [
429 "GET / HTTP/1.1",
430 "Upgrade: WebSocket",
431 "Connection: Upgrade",
432 "Host: %s:%s" % self.server_addr,
433 "Origin: http://%s:%s" % self.server_addr,
434 "Sec-WebSocket-Protocol: ws",
435 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
436 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
437 ]
438 sock = eventlet.connect(self.server_addr)
439 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
440 resp = sock.recv(1024)
441 headers, result = resp.split(b'\r\n\r\n')
442 # The remote server should have immediately closed the connection.
443 self.assertEqual(result[16:], b'\xff\x00')
444
445 def test_app_socket_errors_75(self):
446 error_detected = [False]
447 done_with_request = event.Event()
448 site = self.site
449
450 def error_detector(environ, start_response):
451 try:
452 try:
453 return site(environ, start_response)
454 except:
455 error_detected[0] = True
456 raise
457 finally:
458 done_with_request.send(True)
459 self.site = error_detector
460 self.spawn_server()
461 connect = [
462 "GET /error HTTP/1.1",
463 "Upgrade: WebSocket",
464 "Connection: Upgrade",
465 "Host: %s:%s" % self.server_addr,
466 "Origin: http://%s:%s" % self.server_addr,
467 "WebSocket-Protocol: ws",
468 ]
469 sock = eventlet.connect(self.server_addr)
470 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n')
471 sock.recv(1024)
472 done_with_request.wait()
473 assert error_detected[0]
474
475 def test_app_socket_errors_76(self):
476 error_detected = [False]
477 done_with_request = event.Event()
478 site = self.site
479
480 def error_detector(environ, start_response):
481 try:
482 try:
483 return site(environ, start_response)
484 except:
485 error_detected[0] = True
486 raise
487 finally:
488 done_with_request.send(True)
489 self.site = error_detector
490 self.spawn_server()
491 connect = [
492 "GET /error HTTP/1.1",
493 "Upgrade: WebSocket",
494 "Connection: Upgrade",
495 "Host: %s:%s" % self.server_addr,
496 "Origin: http://%s:%s" % self.server_addr,
497 "Sec-WebSocket-Protocol: ws",
498 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
499 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
500 ]
501 sock = eventlet.connect(self.server_addr)
502 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
503 sock.recv(1024)
504 done_with_request.wait()
505 assert error_detected[0]
506
507 def test_close_idle(self):
508 pool = eventlet.GreenPool()
509 # use log=stderr when test runner can capture it
510 self.spawn_server(custom_pool=pool, log=sys.stdout)
511 connect = (
512 'GET /echo HTTP/1.1',
513 'Upgrade: WebSocket',
514 'Connection: Upgrade',
515 'Host: %s:%s' % self.server_addr,
516 'Origin: http://%s:%s' % self.server_addr,
517 'Sec-WebSocket-Protocol: ws',
518 'Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5',
519 'Sec-WebSocket-Key2: 12998 5 Y3 1 .P00',
520 )
521 sock = eventlet.connect(self.server_addr)
522 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
523 sock.recv(1024)
524 sock.sendall(b'\x00hello\xff')
525 result = sock.recv(1024)
526 assert result, b'\x00hello\xff'
527 self.killer.kill(KeyboardInterrupt)
528 with eventlet.Timeout(1):
529 pool.waitall()
530
531 def test_wrapped_wsgi(self):
532 site = self.site
533
534 def wrapper(environ, start_response):
535 yield from site(environ, start_response)
536
537 self.site = wrapper
538 self.spawn_server()
539 connect = [
540 "GET /range HTTP/1.1",
541 "Upgrade: WebSocket",
542 "Connection: Upgrade",
543 "Host: {}:{}".format(*self.server_addr),
544 "Origin: http://{}:{}".format(*self.server_addr),
545 "WebSocket-Protocol: ws",
546 ]
547 sock = eventlet.connect(self.server_addr)
548
549 sock.sendall("\r\n".join(connect).encode() + b"\r\n\r\n")
550 resp = sock.recv(1024)
551 headers, result = resp.split(b"\r\n\r\n")
552 msgs = [result.strip(b"\x00\xff")]
553 msgs.extend(sock.recv(20).strip(b"\x00\xff") for _ in range(10))
554 expect = ["msg {}".format(i).encode() for i in range(10)] + [b""]
555 assert msgs == expect
556 # In case of server error, server will write HTTP 500 response to the socket
557 msg = sock.recv(20)
558 assert not msg
559 sock.close()
560 eventlet.sleep(0.01)
561
562
563 class TestWebSocketSSL(tests.wsgi_test._TestBase):
564 def set_site(self):
565 self.site = wsapp
566
567 @tests.skip_if_no_ssl
568 def test_ssl_sending_messages(self):
569 s = eventlet.wrap_ssl(eventlet.listen(('localhost', 0)),
570 certfile=tests.certificate_file,
571 keyfile=tests.private_key_file,
572 server_side=True)
573 self.spawn_server(sock=s)
574 connect = [
575 "GET /echo HTTP/1.1",
576 "Upgrade: WebSocket",
577 "Connection: Upgrade",
578 "Host: %s:%s" % self.server_addr,
579 "Origin: http://%s:%s" % self.server_addr,
580 "Sec-WebSocket-Protocol: ws",
581 "Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5",
582 "Sec-WebSocket-Key2: 12998 5 Y3 1 .P00",
583 ]
584 sock = eventlet.wrap_ssl(eventlet.connect(self.server_addr))
585
586 sock.sendall('\r\n'.join(connect).encode() + b'\r\n\r\n^n:ds[4U')
587 first_resp = b''
588 while b'\r\n\r\n' not in first_resp:
589 first_resp += sock.recv()
590 print('resp now:')
591 print(first_resp)
592 # make sure it sets the wss: protocol on the location header
593 loc_line = [x for x in first_resp.split(b"\r\n")
594 if x.lower().startswith(b'sec-websocket-location')][0]
595 expect_wss = ('wss://%s:%s' % self.server_addr).encode()
596 assert expect_wss in loc_line, "Expecting wss protocol in location: %s" % loc_line
597
598 sock.sendall(b'\x00hello\xFF')
599 result = sock.recv(1024)
600 self.assertEqual(result, b'\x00hello\xff')
601 sock.sendall(b'\x00start')
602 eventlet.sleep(0.001)
603 sock.sendall(b' end\xff')
604 result = sock.recv(1024)
605 self.assertEqual(result, b'\x00start end\xff')
606 greenio.shutdown_safe(sock)
607 sock.close()
608 eventlet.sleep(0.01)
609
610
611 class TestWebSocketObject(tests.LimitedTestCase):
612
613 def setUp(self):
614 self.mock_socket = s = mock.Mock()
615 self.environ = env = dict(HTTP_ORIGIN='http://localhost', HTTP_WEBSOCKET_PROTOCOL='ws',
616 PATH_INFO='test')
617
618 self.test_ws = WebSocket(s, env)
619 super().setUp()
620
621 def test_recieve(self):
622 ws = self.test_ws
623 ws.socket.recv.return_value = b'\x00hello\xFF'
624 self.assertEqual(ws.wait(), 'hello')
625 self.assertEqual(ws._buf, b'')
626 self.assertEqual(len(ws._msgs), 0)
627 ws.socket.recv.return_value = b''
628 self.assertEqual(ws.wait(), None)
629 self.assertEqual(ws._buf, b'')
630 self.assertEqual(len(ws._msgs), 0)
631
632 def test_send_to_ws(self):
633 ws = self.test_ws
634 ws.send('hello')
635 assert ws.socket.sendall.called_with("\x00hello\xFF")
636 ws.send(10)
637 assert ws.socket.sendall.called_with("\x0010\xFF")
638
639 def test_close_ws(self):
640 ws = self.test_ws
641 ws.close()
642 assert ws.socket.shutdown.called_with(True)