def test_can_connect(self):
     with serve(60000):
         stream = CocaineStream(socket.socket(), self.io_loop)
         stream.connect(('127.0.0.1', 60000))
         self.assertFalse(stream.closed())
         self.assertTrue(stream.connecting())
         self.assertFalse(stream.connected())
    def test_throws_timeout_error_when_connection_timeout(self):
        def on_connect(future):
            self.assertRaises(TimeoutError, future.get)
            self.stop()

        with serve(60000):
            connector = Connector('localhost', 60000, timeout=0.000001, io_loop=self.io_loop)
            deferred = connector.connect()
            deferred.add_callback(stack_context.wrap(on_connect))
            self.wait()
    def test_connect(self):
        def on_connect(future):
            stream = future.get()
            self.assertIsInstance(stream, IOStream)
            self.stop()

        with serve(60000):
            connector = Connector('localhost', 60000, io_loop=self.io_loop)
            deferred = connector.connect()
            deferred.add_callback(stack_context.wrap(on_connect))
            self.wait()
    def test_triggers_close_callback_when_closed(self):
        def on_closed():
            self.stop()

        def on_connect():
            server.stop()

        with serve(60000) as server:
            stream = CocaineStream(socket.socket(), self.io_loop)
            stream.connect(('127.0.0.1', 60000), on_connect)
            stream.set_close_callback(on_closed)
            self.wait()
    def test_triggers_on_message_callback_with_message(self):
        def on_message(message):
            self.assertEqual([4, 1, ['name']], message)
            self.stop()

        def on_connect():
            server.connections[stream.address()].write(msgpack.dumps([4, 1, ['name']]))

        with serve(60000) as server:
            stream = CocaineStream(socket.socket(), self.io_loop)
            stream.connect(('127.0.0.1', 60000))
            server.on_connect(on_connect)
            stream.set_read_callback(on_message)
            self.wait()
    def test_allow_multiple_invocation_of_connect_method(self):
        def on_connect(future):
            stream = future.get()
            self.assertIsInstance(stream, IOStream)
            self.stop()

        with serve(60000):
            connector = Connector('localhost', 60000, io_loop=self.io_loop)
            deferred = connector.connect()
            deferred_2 = connector.connect()
            deferred_3 = connector.connect()
            deferred.add_callback(stack_context.wrap(on_connect))
            self.assertEqual(deferred, deferred_2)
            self.assertEqual(deferred, deferred_3)
            self.wait()
    def test_consequentially_connect(self):
        def on_connect(future):
            stream = future.get()
            self.assertIsInstance(stream, IOStream)
            self.stop()

        with serve(60000):
            when(socket).getaddrinfo('localhost', 60000, 0, socket.SOCK_STREAM).thenReturn([
                (30, 1, 6, '', ('::1', 59999, 0, 0)),
                (30, 1, 6, '', ('::1', 60000, 0, 0))
            ])

            connector = Connector('localhost', 60000, io_loop=self.io_loop)
            deferred = connector.connect()
            deferred.add_callback(stack_context.wrap(on_connect))
            self.wait()