def test006_thread(self):
        ws = websocket_rails.WebsocketRails(self.URL)
        ws.start()
        thread = ws.thread
        self.assertTrue(ws.running)
        ws.start()
        self.assertTrue(ws.thread == thread)
        self.assertTrue(ws.running)
        ev = websocket_rails.Event.simple('client_connected',
                                          {'connection_id': 15})
        self.conn._mock_message(ev)
        time.sleep(0.1)
        self.assertTrue(ws.conn_id == 15)

        ev = websocket_rails.Event.simple('websocket_rails.ping', {})
        self.conn._mock_message(ev)
        time.sleep(0.1)
        msg = self.conn._get_message()
        ev2 = websocket_rails.Event(msg)
        self.assertTrue(ev2.name == 'websocket_rails.pong')
        self.assertTrue(ev2.data['connection_id'] == 15)
        ws.stop()
        self.assertFalse(ws.running)
        ws.stop()
        self.assertFalse(ws.running)
    def test003_recv(self):
        ws = websocket_rails.WebsocketRails(self.URL)
        self.assertTrue(self.conn.connected)
        self.assertTrue(self.conn._pop()['f'] == 'create_connection')

        ev = websocket_rails.Event.simple('event', 'message')
        self.conn._mock_message(ev)
        self.assertTrue(repr(ws._recv()) == repr(ev))
        self.conn._mock_message(None)
        self.assertTrue(ws._recv() is None)
    def test005_channel(self):
        ws = websocket_rails.WebsocketRails(self.URL)
        self.conn._mock_message(
            websocket_rails.Event.simple('client_connected',
                                         {'connection_id': 15}))
        ws.run()

        name = 'test'
        ws.channel(name).subscribe()
        ev = websocket_rails.Event(self.conn._get_message())
        self.assertTrue(ev.name == 'websocket_rails.subscribe')
        self.assertTrue(ev.data.get('channel') == name)

        self.temp = None

        def _action(data):
            self.temp = data

        # Send message to channel
        chan = ws.channel(name)
        chan.actions.update({'action': _action})
        ev2 = websocket_rails.Event.simple('action', {'foobar': 'test'})
        chan.send(ev2)

        msg = self.conn._get_message()

        ev3 = websocket_rails.Event(msg)
        self.assertTrue(ev3.channel == name)
        self.assertTrue(ev2.name == ev3.name)
        self.assertTrue(ev2.data == ev3.data)
        self.assertTrue(ev2.id == ev3.id)

        # Received a message from channel (pretend not from us)
        del ws.queue[ev3.id]
        self.conn._mock_message(ev3)
        ws.run()
        self.assertTrue(self.temp)
        self.assertTrue(self.temp.get('foobar') == 'test')

        self.assertTrue(len(self.conn.messages_out) == 0)
        self.conn.fail = True
        ws.run()
        self.assertTrue(len(self.conn.messages_out) == 0)
        self.conn.fail = False
        ws.run()
        self.assertTrue(len(self.conn.messages_out) == 1)

        ev = websocket_rails.Event(self.conn._get_message())
        self.assertTrue(ev.name == 'websocket_rails.subscribe')
        self.assertTrue(ev.data.get('channel') == name)

        chan.unsubscribe()
        ev = websocket_rails.Event(self.conn._get_message())
        self.assertTrue(ev.name == 'websocket_rails.unsubscribe')
        self.assertTrue(ev.data.get('channel') == name)
    def test004_run(self):
        ws = websocket_rails.WebsocketRails(self.URL)
        ev = websocket_rails.Event.simple('client_connected',
                                          {'connection_id': 15})
        self.conn._mock_message(ev)
        ws.run()
        self.assertTrue(ws.conn_id == 15)

        ev = websocket_rails.Event.simple('websocket_rails.ping', {})
        self.conn._mock_message(ev)
        ws.run()
        msg = self.conn._get_message()
        ev2 = websocket_rails.Event(msg)
        self.assertTrue(ev2.name == 'websocket_rails.pong')
        self.assertTrue(ev2.data['connection_id'] == 15)
    def test002_send(self):
        self.conn.fail = True  # CONNECTION FAILING
        ws = websocket_rails.WebsocketRails(self.URL)

        self.assertTrue(self.conn._pop()['f'] == 'create_connection')
        self.assertFalse(self.conn.connected)

        ev1 = websocket_rails.Event.simple('event', 'message')
        ws.send(ev1)
        self.assertTrue(self.conn._pop()['f'] == 'create_connection')
        self.assertTrue(len(ws.messages) == 1)
        self.assertTrue(ws.messages[0] == ev1)

        self.conn.fail = False  # CONNECTIONS OK
        ws._connect()
        self.assertTrue(self.conn._pop()['f'] == 'create_connection')
        self.assertTrue(self.conn.connected)
        self.assertTrue(self.conn._pop()['f'] == 'send')
        self.assertTrue(self.conn._get_message() == repr(ev1))
        self.assertTrue(len(ws.messages) == 0)

        self.conn.fail = True  # CONNECTION FAILING
        ev2 = websocket_rails.Event.simple('event', 'message2')
        ws.send(ev2)
        self.assertTrue(self.conn._pop()['f'] == 'send')
        self.assertTrue(self.conn._pop()['f'] == 'create_connection')
        self.assertFalse(self.conn.connected)
        self.assertTrue(len(ws.messages) == 1)

        self.conn.fail = False  # CONNECTIONS OK
        ev3 = websocket_rails.Event.simple('event', 'message3')
        ws.send(ev3)
        self.assertTrue(self.conn._pop()['f'] == 'send')
        self.assertTrue(self.conn._pop()['f'] == 'create_connection')
        self.assertTrue(self.conn._pop()['f'] == 'send')
        self.assertTrue(self.conn._pop()['f'] == 'send')
        self.assertTrue(self.conn.connected)
        self.assertTrue(len(ws.messages) == 0)

        self.assertTrue(self.conn._get_message() == repr(ev2))
        self.assertTrue(self.conn._get_message() == repr(ev3))
 def setUp(self):
     self.ws = websocket_rails.WebsocketRails(None)
 def test001_constructor(self):
     ws = websocket_rails.WebsocketRails(self.URL)
     self.assertTrue(self.conn._pop()['a'][0] == self.URL)
     self.assertTrue(self.conn.connected)
     ws.close()
     self.assertFalse(self.conn.connected)