class TestQueue(utils.TestCase):
def setUp(self):
self.storage = MemoryQueuesStorage()
self.queues_manager = QueuesManager(self.storage)
def tearDown(self):
self.queues_manager.close()
##################################################################
def queue_manager_restart(self):
self.queues_manager.close()
self.queues_manager = QueuesManager(self.storage)
##################################################################
def test_simple_put_get(self):
"""
Few puts, few gets, no TTL or persistence
"""
queue = self.queues_manager.get_queue("testqueue")
queue.connect()
queue.push(Message(b"data a", uuid=b"a"))
queue.push(Message(b"data b", uuid=b"b"))
self.assertEqual(len(queue), 2)
self.assertEqual(queue.get().uuid, b"a")
self.assertEqual(queue.get().uuid, b"a") # must be the same
queue.pop()
self.assertEqual(len(queue), 1)
self.assertEqual(queue.get().uuid, b"b")
queue.pop()
self.assertEqual(len(queue), 0)
self.assertEqual(queue.get(), None)
##################################################################
def test_ttl(self):
"""
Push 2 items, one will expire on connect.
"""
queue = self.queues_manager.get_queue("testqueue")
with mock.patch("time.time") as time_mock:
time_results = iter([0, 3])
time_mock.side_effect = lambda: next(time_results)
queue.disconnect()
queue.push(Message(b"data a", uuid=b"a", ttl=1))
queue.push(Message(b"data b", uuid=b"b", ttl=5))
queue.connect()
self.assertEqual(len(queue), 1)
msg = queue.get()
self.assertEqual(msg.uuid, b"b")
self.assertEqual(msg.ttl, 2) # 5 - 3
##################################################################
def test_ttl_none(self):
queue = self.queues_manager.get_queue("testqueue")
queue.disconnect()
queue.push(Message(b"data a", uuid=b"a", ttl=None))
queue.connect()
self.assertEqual(len(queue), 1)
msg = queue.get()
self.assertEqual(msg.uuid, b"a")
self.assertEqual(msg.ttl, None)
##################################################################
def test_zero_ttl(self):
"""
Push item with ttl=0 into a connected or disconnected queue.
"""
queue = self.queues_manager.get_queue("testqueue")
# disconnected
queue.push(Message(b"data a", uuid=b"a", ttl=0))
self.assertEqual(len(queue), 0)
queue.connect()
queue.push(Message(b"data a", uuid=b"a", ttl=0))
self.assertEqual(len(queue), 1)
##################################################################
def test_persistence(self):
"""
Without TTL.
"""
queue = self.queues_manager.get_queue("testqueue")
queue.connect()
queue.push(Message(b"data a", uuid=b"a", ttl=1, flags=FLAG_PERSISTENT))
queue.push(Message(b"data b", uuid=b"b"))
queue.push(Message(b"data c", uuid=b"c", ttl=1, flags=FLAG_PERSISTENT))
self.assertEqual(len(queue), 3)
stored_items = self.queues_manager.storage.get_items("testqueue")
self.assertEqual(len(stored_items), 2)
self.assertEqual(stored_items[0].uuid, b"a")
self.assertEqual(stored_items[1].uuid, b"c")
# remove "a"
queue.pop()
stored_items = self.queues_manager.storage.get_items("testqueue")
self.assertEqual(len(stored_items), 1)
self.assertEqual(stored_items[0].uuid, b"c")
# remove "b", "c" remains
queue.pop()
stored_items = self.queues_manager.storage.get_items("testqueue")
self.assertEqual(len(stored_items), 1)
##################################################################
def test_persistence_restart(self):
"""
Test of persistent items load.
"""
queue1 = self.queues_manager.get_queue("testqueue1")
queue1.connect()
queue1.push(Message(b"data a", uuid=b"a", ttl=1, flags=FLAG_PERSISTENT))
queue1.push(Message(b"data b", uuid=b"b", ttl=1, flags=FLAG_PERSISTENT))
queue1.push(Message(b"data c", uuid=b"c", ttl=1, flags=FLAG_PERSISTENT))
queue2 = self.queues_manager.get_queue("testqueue2")
queue2.connect()
queue2.push(Message(b"data d", uuid=b"d", ttl=1, flags=FLAG_PERSISTENT))
queue2.push(Message(b"data e", uuid=b"e", ttl=1, flags=FLAG_PERSISTENT))
self.queue_manager_restart()
self.assertEqual(len(self.queues_manager), 2)
queue = self.queues_manager.get_queue("testqueue1")
self.assertEqual(len(queue), 3)
self.assertEqual(queue.get().uuid, b"a")
queue = self.queues_manager.get_queue("testqueue2")
self.assertEqual(len(queue), 2)
self.assertEqual(queue.get().uuid, b"d")
##################################################################
def test_persistence_ttl(self):
queue = self.queues_manager.get_queue("testqueue")
queue.connect()
queue.push(Message(b"data a", uuid=b"a", ttl=1, flags=FLAG_PERSISTENT))
queue.push(Message(b"data b", uuid=b"b"))
queue.push(Message(b"data c", uuid=b"c", ttl=5, flags=FLAG_PERSISTENT))
self.assertEqual(len(queue), 3)
self.queue_manager_restart()
queue = self.queues_manager.get_queue("testqueue")
with mock.patch("time.time") as time_mock:
time_results = iter([0, 3])
time_mock.side_effect = lambda: next(time_results)
queue.disconnect()
self.assertEqual(len(queue), 2)
queue.connect()
self.assertEqual(len(queue), 1)
class TestQueue(utils.TestCase):
def setUp(self):
self.storage = MemoryQueuesStorage()
self.queues_manager = QueuesManager(self.storage)
def tearDown(self):
self.queues_manager.close()
##################################################################
def queue_manager_restart(self):
self.queues_manager.close()
self.queues_manager = QueuesManager(self.storage)
##################################################################
def test_simple_put_get(self):
"""
Few puts, few gets, no TTL or persistence
"""
queue = self.queues_manager.get_queue("testqueue")
queue.connect()
queue.push(Message(b"data a", uuid=b"a"))
queue.push(Message(b"data b", uuid=b"b"))
self.assertEqual(len(queue), 2)
self.assertEqual(queue.get().uuid, b"a")
self.assertEqual(queue.get().uuid, b"a") # must be the same
queue.pop()
self.assertEqual(len(queue), 1)
self.assertEqual(queue.get().uuid, b"b")
queue.pop()
self.assertEqual(len(queue), 0)
self.assertEqual(queue.get(), None)
##################################################################
def test_ttl(self):
"""
Push 2 items, one will expire on connect.
"""
queue = self.queues_manager.get_queue("testqueue")
with mock.patch("time.time") as time_mock:
time_results = iter([0, 3])
time_mock.side_effect = lambda: next(time_results)
queue.disconnect()
queue.push(Message(b"data a", uuid=b"a", ttl=1))
queue.push(Message(b"data b", uuid=b"b", ttl=5))
queue.connect()
self.assertEqual(len(queue), 1)
msg = queue.get()
self.assertEqual(msg.uuid, b"b")
self.assertEqual(msg.ttl, 2) # 5 - 3
##################################################################
def test_ttl_none(self):
queue = self.queues_manager.get_queue("testqueue")
queue.disconnect()
queue.push(Message(b"data a", uuid=b"a", ttl=None))
queue.connect()
self.assertEqual(len(queue), 1)
msg = queue.get()
self.assertEqual(msg.uuid, b"a")
self.assertEqual(msg.ttl, None)
##################################################################
def test_zero_ttl(self):
"""
Push item with ttl=0 into a connected or disconnected queue.
"""
queue = self.queues_manager.get_queue("testqueue")
# disconnected
queue.push(Message(b"data a", uuid=b"a", ttl=0))
self.assertEqual(len(queue), 0)
queue.connect()
queue.push(Message(b"data a", uuid=b"a", ttl=0))
self.assertEqual(len(queue), 1)
##################################################################
def test_persistence(self):
"""
Without TTL.
"""
queue = self.queues_manager.get_queue("testqueue")
queue.connect()
queue.push(Message(b"data a", uuid=b"a", ttl=1, flags=FLAG_PERSISTENT))
queue.push(Message(b"data b", uuid=b"b"))
queue.push(Message(b"data c", uuid=b"c", ttl=1, flags=FLAG_PERSISTENT))
self.assertEqual(len(queue), 3)
stored_items = self.queues_manager.storage.get_items("testqueue")
self.assertEqual(len(stored_items), 2)
self.assertEqual(stored_items[0].uuid, b"a")
self.assertEqual(stored_items[1].uuid, b"c")
# remove "a"
queue.pop()
stored_items = self.queues_manager.storage.get_items("testqueue")
self.assertEqual(len(stored_items), 1)
self.assertEqual(stored_items[0].uuid, b"c")
# remove "b", "c" remains
queue.pop()
stored_items = self.queues_manager.storage.get_items("testqueue")
self.assertEqual(len(stored_items), 1)
##################################################################
def test_persistence_restart(self):
"""
Test of persistent items load.
"""
queue1 = self.queues_manager.get_queue("testqueue1")
queue1.connect()
queue1.push(Message(b"data a", uuid=b"a", ttl=1,
flags=FLAG_PERSISTENT))
queue1.push(Message(b"data b", uuid=b"b", ttl=1,
flags=FLAG_PERSISTENT))
queue1.push(Message(b"data c", uuid=b"c", ttl=1,
flags=FLAG_PERSISTENT))
queue2 = self.queues_manager.get_queue("testqueue2")
queue2.connect()
queue2.push(Message(b"data d", uuid=b"d", ttl=1,
flags=FLAG_PERSISTENT))
queue2.push(Message(b"data e", uuid=b"e", ttl=1,
flags=FLAG_PERSISTENT))
self.queue_manager_restart()
self.assertEqual(len(self.queues_manager), 2)
queue = self.queues_manager.get_queue("testqueue1")
self.assertEqual(len(queue), 3)
self.assertEqual(queue.get().uuid, b"a")
queue = self.queues_manager.get_queue("testqueue2")
self.assertEqual(len(queue), 2)
self.assertEqual(queue.get().uuid, b"d")
##################################################################
def test_persistence_ttl(self):
queue = self.queues_manager.get_queue("testqueue")
queue.connect()
queue.push(Message(b"data a", uuid=b"a", ttl=1, flags=FLAG_PERSISTENT))
queue.push(Message(b"data b", uuid=b"b"))
queue.push(Message(b"data c", uuid=b"c", ttl=5, flags=FLAG_PERSISTENT))
self.assertEqual(len(queue), 3)
self.queue_manager_restart()
queue = self.queues_manager.get_queue("testqueue")
with mock.patch("time.time") as time_mock:
time_results = iter([0, 3])
time_mock.side_effect = lambda: next(time_results)
queue.disconnect()
self.assertEqual(len(queue), 2)
queue.connect()
self.assertEqual(len(queue), 1)
