Пример #1
0
def test_process_messages_detects_match():
    matching_msg = Message(0, 'mychannel', 'rth', 'hi everyone!')
    msgs = [
        {'data': matching_msg.encode()},
        {'data': Message(1, 'mychannel', 'rth', 'one').encode()},
        {'data': Message(2, 'mychannel', 'rth', 'two').encode()},
        {'data': Message(3, 'mychannel', 'rth', 'three').encode()},
        {'data': Message(4, 'mychannel', 'rth', 'four').encode()},
        {'data': Message(5, 'mychannel', 'rth', 'five').encode()}
    ]

    def get_msg(channel, msg_id):
        if msg_id == 0:
            return matching_msg

    def get_messages(channel, ids):
        if ids == [0, 1, 2, 3, 4]:
            return msgs
        else:
            return []

    msg_store = MessageStore()
    msg_store.save_message = MagicMock()
    msg_store.get_message = MagicMock(side_effect=get_msg)
    msg_store.get_messages = MagicMock(side_effect=get_messages)
    sub = Subscriber()
    sub.listen = MagicMock(return_value=msgs)
    m_writer = MatchWriter()
    m_writer.save = MagicMock()

    process_messages(msg_store, sub, FILTS, m_writer)
    m_writer.save.assert_called_with('mychannel', [0], msgs)
Пример #2
0
def test_message_encode_and_decode_completeness():
    m = Message(0, 'mychannel', 'rth', 'message text')

    e = m.encode()
    msg = Message.decode(e)

    assert_equal(msg.msg_id, 0)
    assert_equal(msg.channel, 'mychannel')
    assert_equal(msg.nick, 'rth')
    assert_equal(msg.text, 'message text')
Пример #3
0
def test_message_to_and_from_dict_completeness():
    m = Message(0, 'mychannel', 'rth', 'message text')

    d = m.to_dict()
    msg = Message.from_dict(d)

    assert_equal(msg.msg_id, 0)
    assert_equal(msg.channel, 'mychannel')
    assert_equal(msg.nick, 'rth')
    assert_equal(msg.text, 'message text')
Пример #4
0
def test_process_messages_saves_each_message():
    msg_store = MessageStore()
    msg_store.save_message = MagicMock()
    msg_store.get_message = MagicMock(return_value=None)
    sub = Subscriber()
    msg = Message(0, 'mychannel', 'rth', 'zero')
    sub.listen = MagicMock(return_value=[
        {'data': msg.encode()}
    ])
    m_writer = MatchWriter()

    process_messages(msg_store, sub, FILTS, m_writer)

    msg_store.save_message.assert_called_with(msg)
Пример #5
0
def process_messages(msg_store, sub, filters, match_writer):

    logger.info("started processor")
    last_msg = 0

    for m in sub.listen():
        msg_data = m['data']
        msg = Message.decode(msg_data)
        last_msg = msg.msg_id

        logger.info(msg.text)

        msg_store.save_message(msg)

        # check msg from the past, so we have some
        # context for our matches
        msg_to_check = msg_store.get_message(msg.channel, last_msg - 5)

        if msg_to_check:
            matches = check_matches(msg_to_check.text, filters)
            if len(matches) > 0:
                match_context = get_context(
                    msg_store, msg_to_check.channel, msg_to_check.msg_id)
                match_writer.save(
                    msg_to_check.channel,
                    matches,
                    match_context)
Пример #6
0
    def get_messages(self, channel, msg_ids):
        pipe = self.rdis.pipeline()

        for msg_id in msg_ids:
            msg_key = self._key_name(channel, msg_id)
            pipe.hgetall(msg_key)
        return [Message.from_dict(d) for d in pipe.execute()]
Пример #7
0
def test_message_from_dict():
    mdict = {
        'msg_id': 1,
        'channel': '#myChannel',
        'nick': 'Me',
        'text': 'This is my message'
    }

    m = Message.from_dict(mdict)
    assert_equal(m.msg_id, 1)
    assert_equal(m.channel, '#myChannel')
    assert_equal(m.nick, 'Me')
    assert_equal(m.text, 'This is my message')
Пример #8
0
 def get_message(self, channel, msg_id):
     msg_key = self._key_name(channel, msg_id)
     mdict = self.rdis.hgetall(msg_key)
     return Message.from_dict(mdict)