class TestMessageQueue(unittest.TestCase):
def setUp(self):
self.client = Redis(decode_responses=True)
self.client.flushdb()
self.mq = MessageQueue(self.client, "mq")
self.msg = "hello world"
self.blocktime = 1
def test_add(self):
self.mq.add_message(self.msg)
self.assertEqual(
self.mq.len(),
1
)
def test_get_message_non_block(self):
self.mq.add_message(self.msg)
self.assertEqual(
self.mq.get_message(),
self.msg
)
def test_get_message_blocking(self):
before = time()
print("blocking, wait for {0} second(s)".format(self.blocktime))
self.assertIsNone(
self.mq.get_message(self.blocktime)
)
self.assertTrue(
time() - before >= self.blocktime
)
def test_len(self):
self.assertEqual(
self.mq.len(),
0
)
self.mq.add_message(self.msg)
self.assertEqual(
self.mq.len(),
1
)
class TestMessageQueue:
def setup_class(self):
self.client = Redis()
self.mq = MessageQueue(self.client, "email_queue")
self.mq.add_message("*****@*****.**")
self.mq.add_message("*****@*****.**")
self.mq.add_message("*****@*****.**")
def test_len(self):
assert self.mq.len() == 3
def test_consume(self):
assert self.mq.get_message() == "*****@*****.**"
assert self.mq.get_message() == "*****@*****.**"
assert self.mq.get_message() == "*****@*****.**"
class TestMessageQueue(unittest.TestCase):
def setUp(self):
self.client = Redis(decode_responses=True)
self.stream_key = "test_message_queue"
self.q = MessageQueue(self.client, self.stream_key)
self.message = {"name":"peter", "age":"36", "location":"UK"}
self.tearDown()
def tearDown(self):
self.client.delete(self.stream_key)
def make_a_none_empty_queue(self, queue, size):
for i in range(size):
key = "key{0}".format(i)
value = "value{0}".format(i)
self.q.add_message({key:value,})
def test_add_message(self):
message_id = self.q.add_message(self.message)
self.assertIsNotNone(message_id)
def test_add_message_return_utf8_id(self):
message_id = self.q.add_message(self.message)
self.assertIsInstance(message_id, str)
def test_get_message_return_none_when_msg_not_exists(self):
self.assertIsNone(self.q.get_message("10086-0"))
def test_get_message_return_msg_when_its_exists(self):
message_id = self.q.add_message(self.message)
self.assertEqual(
self.message,
self.q.get_message(message_id)
)
def test_remove_message(self):
message_id = self.q.add_message(self.message)
self.q.remove_message(message_id)
self.assertIsNone(self.q.get_message(message_id))
def test_len_return_zero_when_queue_empty(self):
self.assertEqual(self.q.len(), 0)
def test_len_retrun_non_zero_when_queue_not_empty(self):
id = self.q.add_message(self.message)
self.assertEqual(self.q.len(), 1)
self.q.remove_message(id)
self.assertEqual(self.q.len(), 0)
def test_get_by_range_return_empty_list_when_queue_empty(self):
self.assertEqual(self.q.get_by_range("-", "+"), list())
def test_get_by_range_return_none_empty_list_when_queue_not_empty(self):
self.make_a_none_empty_queue(self.q, 10)
result = self.q.get_by_range("-", "+")
self.assertEqual(len(result), 10)
self.assertEqual(type(result), list)
for msg in result:
self.assertEqual(type(msg), dict)
def test_get_by_range_return_right_size(self):
self.make_a_none_empty_queue(self.q, 10)
result = self.q.get_by_range("-", "+", 5)
self.assertEqual(len(result), 5)
def test_get_by_range_return_empty_list_when_stream_empty(self):
self.assertEqual(
self.q.get_by_range("-", "+"),
list()
)
def test_iterate_return_right_size(self):
self.make_a_none_empty_queue(self.q, 10)
self.assertEqual(
len(self.q.iterate(0, 5)),
5
)
self.assertEqual(
len(self.q.iterate(0, 10)),
10
)
def test_iterate_return_right_message(self):
self.make_a_none_empty_queue(self.q, 10)
full_message_list = self.q.get_by_range("-", "+", 10)
self.assertEqual(
self.q.iterate(0, 5),
full_message_list[0:5]
)
self.assertEqual(
self.q.iterate(0, 10),
full_message_list
)
def test_iterate_return_empty_list_when_stream_empty(self):
self.assertEqual(
self.q.iterate(0),
list()
)
class TestGroup(unittest.TestCase):
def setUp(self):
self.client = Redis(decode_responses=True)
self.stream = "test_stream"
self.group = "test_group"
# objs
self.q = MessageQueue(self.client, self.stream)
self.g = Group(self.client, self.stream, self.group)
# create a empty stream key
self.msg_id = self.q.add_message({"k":"v"})
self.q.remove_message(self.msg_id)
def tearDown(self):
self.client.delete(self.stream)
def create_group(self):
self.g.create(0)
def add_msg_to_stream(self):
self.q.add_message({"k":"v"})
def test_create(self):
self.create_group()
self.assertNotEqual(
self.g.info(),
[]
)
def test_read_message(self):
self.create_group()
self.assertEqual(
self.g.read_message("worker1", ">"),
[]
)
self.add_msg_to_stream()
self.assertNotEqual(
self.g.read_message("worker1", ">"),
[]
)
def test_ack_message(self):
self.create_group()
self.add_msg_to_stream()
msgs = self.g.read_message("worker1", ">")
msg_id = list(msgs[0].keys())[0]
self.g.ack_message(msg_id)
pending_count = self.g.info()['pending']
self.assertEqual(
pending_count,
0
)
def test_info(self):
self.assertEqual(
self.g.info(),
dict()
)
self.create_group()
self.assertIsNotNone(
self.g.info()
)
def test_consumer_info(self):
self.create_group()
self.assertEqual(
self.g.consumer_info(),
[]
)
self.add_msg_to_stream()
msgs = self.g.read_message("worker1", ">")
self.assertNotEqual(
self.g.consumer_info(),
[]
)
def test_delete_consumer(self):
self.create_group()
self.add_msg_to_stream()
msgs = self.g.read_message("worker1", ">")
self.g.delete_consumer("worker1")
self.assertEqual(
self.g.consumer_info(),
[]
)
def test_destroy_group(self):
self.create_group()
self.g.destroy()
self.assertEqual(
self.g.info(),
dict()
)
