Esempio n. 1
0
    def test_process(self):

        logging.info('*** process ***')

        listener = Listener(engine=self.engine)
        listener.DEFER_DURATION = 0.0

        self.engine.set('listener.counter', 22)
        with self.assertRaises(AssertionError):
            listener.process('hello world')
        self.assertEqual(self.engine.get('listener.counter'), 23)

        listener.on_message = mock.Mock()
        listener.process(str(my_message))
        self.assertEqual(self.engine.get('listener.counter'), 24)
        self.assertTrue(listener.on_message.called)

        listener.on_message = mock.Mock()
        listener.process(str(my_private_message))
        self.assertEqual(self.engine.get('listener.counter'), 25)
        self.assertTrue(listener.on_message.called)

        listener.on_join = mock.Mock()
        listener.process(str(my_join))
        self.assertEqual(self.engine.get('listener.counter'), 26)
        self.assertTrue(listener.on_join.called)

        listener.on_leave = mock.Mock()
        listener.process(str(my_leave))
        self.assertEqual(self.engine.get('listener.counter'), 27)
        self.assertTrue(listener.on_leave.called)

        listener.on_inbound = mock.Mock()
        listener.process(str(my_event))
        self.assertEqual(self.engine.get('listener.counter'), 28)
        self.assertTrue(listener.on_inbound.called)
Esempio n. 2
0
    def test_on_join(self):

        logging.info('*** on_join ***')

        class Handler(object):
            def __init__(self):
                self.entered = False
                self.joined = False

            def on_enter(self, **kwargs):
                self.entered = True

            def on_join(self, **kwargs):
                self.joined = True

        handler = Handler()
        self.engine.register('enter', handler)
        self.engine.register('join', handler)

        listener = Listener(engine=self.engine)
        listener.DEFER_DURATION = 0.0
        with self.assertRaises(AssertionError):
            listener.on_join(my_message)
        with self.assertRaises(AssertionError):
            listener.on_join(my_private_message)

        self.assertFalse(handler.entered)
        self.assertFalse(handler.joined)

        listener.on_join(my_enter)

        self.assertTrue(handler.entered)
        self.assertFalse(handler.joined)

        listener.on_join(my_join)

        self.assertTrue(handler.entered)
        self.assertTrue(handler.joined)

        with self.assertRaises(AssertionError):
            listener.on_join(my_leave)
        with self.assertRaises(AssertionError):
            listener.on_join(my_event)

        with mock.patch.object(self.engine, 'dispatch',
                               return_value=None) as mocked:
            listener.on_join(my_join)
            self.assertTrue(mocked.called)