Increase code coverage

Author: igorcoding

asynctnt_queue/queue.py

@@ -84,6 +84,6 @@ async def statistics(self, tube_name=None):
             args = (tube_name,)
 
         res = await self._conn.call('{}.statistics'.format(self._namespace), args)
-        if self._conn.version < (1, 7):
+        if self._conn.version < (1, 7):  # pragma: nocover
             return res.body[0][0]
         return res.body[0]

asynctnt_queue/task.py

@@ -25,18 +25,18 @@ class Task:
 
     def __init__(self, tube, tnt_tuple):
         self._tube = tube
-        if tnt_tuple is None or len(tnt_tuple) == 0:
+        if tnt_tuple is None or len(tnt_tuple) == 0:  # pragma: nocover
             raise TaskEmptyError('Tarantool Queue task is empty')
 
         tnt_tuple = tnt_tuple[0]
-        if tnt_tuple is None or len(tnt_tuple) == 0:
+        if tnt_tuple is None or len(tnt_tuple) == 0:  # pragma: nocover
             raise TaskEmptyError('Tarantool Queue task is empty')
 
         self._task_id = tnt_tuple[0]
         status = tnt_tuple[1]
         try:
             self._status = Status(status)
-        except ValueError:
+        except ValueError:  # pragma: nocover
             asynctnt.log.logger.warning(
                 "unknown status '{}' in task_id = {}".format(
                     status, self._task_id))

setup.py

@@ -43,7 +43,7 @@ def find_version():
         "Topic :: Database :: Front-Ends"
     ],
     install_requires=[
-        'asynctnt>=0.1.9'
+        'asynctnt>=0.1.10'
     ],
     description=description,
     long_description=long_description,

tests/test_queue.py

@@ -15,6 +15,13 @@ def test__queue_get_tube(self):
         self.assertIsInstance(tube, Tube, 'tube valid type')
         self.assertEqual(tube.conn, self.conn, 'conn valid')
 
+    def test__queue_get_tube_multiple(self):
+        q = Queue(self.conn)
+        tube1 = q.tube('test_tube')
+        tube2 = q.tube('test_tube')
+
+        self.assertIs(tube1, tube2, 'the same object')
+
     async def test__queue_statistics(self):
         q = Queue(self.conn)
         res = await q.statistics()

tests/test_task.py

@@ -13,6 +13,16 @@ def _data_obj(self):
             'key': 'value'
         }
 
+    async def test__task_tube(self):
+        tube = self.create_tube()
+        t = await tube.put(self._data_obj())
+        self.assertIs(t.tube, tube, 'tube is the same object')
+
+    async def test__task_repr(self):
+        tube = self.create_tube()
+        t = await tube.put(self._data_obj())
+        self.assertEqual(repr(t), '<Task id=0 status=Status.READY>')
+
     async def test__task_ack(self):
         tube = self.create_tube()
         t = await tube.put(self._data_obj())

tests/test_tube.py

@@ -13,6 +13,11 @@ def _data_obj(self):
             'key': 'value'
         }
 
+    async def test__tube_queue(self):
+        q = Queue(self.conn)
+        tube = q.tube('test_tube')
+        self.assertIs(tube.queue, q, 'queue is the same object')
+
     async def test__tube_put(self):
         tube = self.create_tube()
         t = await tube.put(self._data_obj())
@@ -22,6 +27,15 @@ async def test__tube_put(self):
         self.assertEqual(t.task_id, 0)  # first task has id = 0
         self.assertEqual(t.data, self._data_obj())
 
+    async def test__tube_put_options(self):
+        tube = self.create_tube()
+        t = await tube.put(self._data_obj(), pri=4, ttl=10, ttr=1, delay=0.2)
+        self.assertIsNotNone(t)
+        self.assertIsInstance(t, Task)
+        self.assertEqual(t.status, Status.DELAYED)
+        self.assertEqual(t.task_id, 0)  # first task has id = 0
+        self.assertEqual(t.data, self._data_obj())
+
     async def test__tube_take(self):
         tube = self.create_tube()
         t = await tube.put(self._data_obj())
@@ -89,6 +103,21 @@ async def test__tube_touch(self):
         self.assertEqual(t2.status, Status.TAKEN)
         self.assertEqual(t2.data, t.data)
 
+    async def test__tube_kick(self):
+        tube = self.create_tube()
+        t = await tube.put(self._data_obj())
+        t2 = await tube.take()
+        t2 = await tube.bury(t2.task_id)
+        t3 = await tube.take(0.5)
+        self.assertIsNone(t3, 'no tasks left')
+
+        count = await tube.kick(1)
+        self.assertEqual(count, 1)
+        t3 = await tube.take(0.5)
+        self.assertEqual(t3.task_id, t2.task_id)
+        self.assertEqual(t3.status, Status.TAKEN)
+        self.assertEqual(t3.data, t2.data)
+
     async def test__tube_delete(self):
         tube = self.create_tube()
         t = await tube.put(self._data_obj())