def test_handshake_succeeds(self): """ A client can connect to a server. """ session_mock = Mock() t = FakeTransport() f = WampRawSocketClientFactory(lambda: session_mock) p = WampRawSocketClientProtocol() p.transport = t p.factory = f server_session_mock = Mock() st = FakeTransport() sf = WampRawSocketServerFactory(lambda: server_session_mock) sp = WampRawSocketServerProtocol() sp.transport = st sp.factory = sf sp.connectionMade() p.connectionMade() # Send the server the client handshake sp.dataReceived(t._written[0:1]) sp.dataReceived(t._written[1:4]) # Send the client the server handshake p.dataReceived(st._written) # The handshake succeeds, a session on each end is created # onOpen is called on the session session_mock.onOpen.assert_called_once_with(p) server_session_mock.onOpen.assert_called_once_with(sp)
def test_on_connecting_client_success(self): raise SkipTest() class TestProto(WebSocketClientProtocol): state = None wasClean = True perMessageCompressionOffers = [] version = 18 openHandshakeTimeout = 5 log = Mock() def onConnecting(self, transport_details): return ConnectingRequest( host="example.com", port=443, resource="/ws", ) from autobahn.test import FakeTransport proto = TestProto() proto.transport = FakeTransport() proto.factory = Mock() proto._connectionMade() d = proto.startHandshake() req = self.successResultOf(d) self.assertEqual("example.com", req.host) self.assertEqual(443, req.port) self.assertEqual("/ws", req.resource)
def create_client_frame(b64patch, **kwargs): """ Kind-of hack-y; maybe better to re-factor the Protocol to have a frame-encoder method-call? Anyway, makes a throwaway protocol encode a frame for us, collects the .sendData call and returns the data that would have gone out. Accepts all the kwargs that WebSocketClientProtocol.sendFrame() accepts. """ # only real way to inject a "known" secret-key for the headers # to line up... :/ b64patch.return_value = b'QIatSt9QkZPyS4QQfdufO8TgkL0=' factory = WebSocketClientFactory(protocols=['wamp.2.json']) factory.protocol = WebSocketClientProtocol factory.doStart() proto = factory.buildProtocol(IPv4Address('TCP', '127.0.0.9', 65534)) proto.transport = FakeTransport() proto.connectionMade() proto.data = mock_handshake_server proto.processHandshake() data = [] def collect(d, *args): data.append(d) proto.sendData = collect proto.sendFrame(**kwargs) return b''.join(data)
def setUp(self): self.factory = WebSocketClientFactory(protocols=['wamp.2.json']) self.factory.protocol = WebSocketClientProtocol self.factory.doStart() self.proto = self.factory.buildProtocol(IPv4Address('TCP', '127.0.0.1', 65534)) self.transport = FakeTransport() self.proto.transport = self.transport self.proto.connectionMade()
def setUp(self): t = FakeTransport() f = WebSocketClientFactory() p = WebSocketClientProtocol() p.factory = f p.transport = t p._connectionMade() p.state = p.STATE_OPEN p.websocket_version = 18 self.protocol = p self.transport = t
def setUp(self): from autobahn.twisted.websocket import WebSocketServerProtocol from autobahn.twisted.websocket import WebSocketServerFactory t = FakeTransport() f = WebSocketServerFactory() p = WebSocketServerProtocol() p.factory = f p.transport = t p._connectionMade() p.state = p.STATE_OPEN p.websocket_version = 18 self.protocol = p self.transport = t
def protocol(): from autobahn.test import FakeTransport from kiteconnect.ticker import KiteTickerClientProtocol,\ KiteTickerClientFactory t = FakeTransport() f = KiteTickerClientFactory() p = KiteTickerClientProtocol() p.factory = f p.transport = t p._connectionMade() p.state = p.STATE_OPEN p.websocket_version = 18 return p
def test_handshake_fails(self): """ A handshake from a client only supporting Hixie-76 will fail. """ t = FakeTransport() f = WebSocketServerFactory() p = WebSocketServerProtocol() p.factory = f p.transport = t # from http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 http_request = b"GET /demo HTTP/1.1\r\nHost: example.com\r\nConnection: Upgrade\r\nSec-WebSocket-Key2: 12998 5 Y3 1 .P00\r\nSec-WebSocket-Protocol: sample\r\nUpgrade: WebSocket\r\nSec-WebSocket-Key1: 4 @1 46546xW%0l 1 5\r\nOrigin: http://example.com\r\n\r\n^n:ds[4U" p.openHandshakeTimeout = 0 p._connectionMade() p.data = http_request p.processHandshake() self.assertIn(b"HTTP/1.1 400", t._written) self.assertIn(b"Hixie76 protocol not supported", t._written)
def test_on_connecting_client_fails(self): class TestProto(WebSocketClientProtocol): state = None wasClean = True log = Mock() def onConnecting(self, transport_details): raise RuntimeError("bad stuff") from autobahn.test import FakeTransport proto = TestProto() proto.transport = FakeTransport() d = proto.startHandshake() self.successResultOf(d) # error is ignored # ... but error should be logged self.assertTrue(len(proto.log.mock_calls) > 0) self.assertIn( "bad stuff", str(proto.log.mock_calls[0]), )
def connect(factory, **kw): proto = factory.buildProtocol('ws://localhost/') transport = FakeTransport() proto.makeConnection(transport) from autobahn.websocket.protocol import WebSocketProtocol from base64 import b64encode from hashlib import sha1 key = proto.websocket_key + WebSocketProtocol._WS_MAGIC proto.data = (b"HTTP/1.1 101 Switching Protocols\x0d\x0a" b"Upgrade: websocket\x0d\x0a" b"Connection: upgrade\x0d\x0a" b"Sec-Websocket-Protocol: wamp.2.json\x0d\x0a" b"Sec-Websocket-Accept: " + b64encode(sha1(key).digest()) + b"\x0d\x0a\x0d\x0a") proto.processHandshake() from autobahn.wamp import role features = role.RoleBrokerFeatures( publisher_identification=True, pattern_based_subscription=True, session_meta_api=True, subscription_meta_api=True, subscriber_blackwhite_listing=True, publisher_exclusion=True, subscription_revocation=True, payload_transparency=True, payload_encryption_cryptobox=True, ) msg = Welcome(123456, dict(broker=features), realm=u'realm') serializer = JsonSerializer() data, is_binary = serializer.serialize(msg) proto.onMessage(data, is_binary) msg = Goodbye() proto.onMessage(*serializer.serialize(msg)) proto.onClose(True, 100, "some old reason") return succeed(proto)