implemented working pool size limit; adjusted tests and examples; small renaming

tests/test_pool.py

@@ -1,6 +1,6 @@
 import asyncio
 from unittest import TestCase
-from unittest.mock import MagicMock, PropertyMock, patch, call
+from unittest.mock import MagicMock, PropertyMock, patch
 
 from asyncio_taskpool import pool
 
@@ -14,10 +14,10 @@ class BaseTaskPoolTestCase(TestCase):
 
         # These three methods are called during initialization, so we mock them by default during setup
         self._add_pool_patcher = patch.object(pool.BaseTaskPool, '_add_pool')
-        self._check_more_allowed_patcher = patch.object(pool.BaseTaskPool, '_check_more_allowed')
+        self.pool_size_patcher = patch.object(pool.BaseTaskPool, 'pool_size', new_callable=PropertyMock)
         self.__str___patcher = patch.object(pool.BaseTaskPool, '__str__')
         self.mock__add_pool = self._add_pool_patcher.start()
-        self.mock__check_more_allowed = self._check_more_allowed_patcher.start()
+        self.mock_pool_size = self.pool_size_patcher.start()
         self.mock___str__ = self.__str___patcher.start()
         self.mock__add_pool.return_value = self.mock_idx = 123
         self.mock___str__.return_value = self.mock_str = 'foobar'
@@ -29,7 +29,7 @@ class BaseTaskPoolTestCase(TestCase):
     def tearDown(self) -> None:
         setattr(pool.TaskPool, '_pools', self._pools)
         self._add_pool_patcher.stop()
-        self._check_more_allowed_patcher.stop()
+        self.pool_size_patcher.stop()
         self.__str___patcher.stop()
 
     def test__add_pool(self):
@@ -40,7 +40,7 @@ class BaseTaskPoolTestCase(TestCase):
         self.assertListEqual([self.task_pool], getattr(pool.TaskPool, '_pools'))
 
     def test_init(self):
-        self.assertEqual(self.test_pool_size, self.task_pool.pool_size)
+        self.assertIsInstance(self.task_pool._enough_room, asyncio.locks.Semaphore)
         self.assertTrue(self.task_pool._open)
         self.assertEqual(0, self.task_pool._counter)
         self.assertDictEqual(EMPTY_DICT, self.task_pool._running)
@@ -51,9 +51,8 @@ class BaseTaskPoolTestCase(TestCase):
         self.assertEqual(self.test_pool_name, self.task_pool._name)
         self.assertIsInstance(self.task_pool._all_tasks_known_flag, asyncio.locks.Event)
         self.assertTrue(self.task_pool._all_tasks_known_flag.is_set())
-        self.assertIsInstance(self.task_pool._more_allowed_flag, asyncio.locks.Event)
         self.mock__add_pool.assert_called_once_with(self.task_pool)
-        self.mock__check_more_allowed.assert_called_once_with()
+        self.mock_pool_size.assert_called_once_with(self.test_pool_size)
         self.mock___str__.assert_called_once_with()
 
     def test___str__(self):
@@ -64,6 +63,17 @@ class BaseTaskPoolTestCase(TestCase):
         expected_str = f'{pool.BaseTaskPool.__name__}-{self.task_pool._idx}'
         self.assertEqual(expected_str, str(self.task_pool))
 
+    def test_pool_size(self):
+        self.pool_size_patcher.stop()
+        self.task_pool._pool_size = self.test_pool_size
+        self.assertEqual(self.test_pool_size, self.task_pool.pool_size)
+
+        with self.assertRaises(ValueError):
+            self.task_pool.pool_size = -1
+
+        self.task_pool.pool_size = new_size = 69
+        self.assertEqual(new_size, self.task_pool._pool_size)
+
     def test_is_open(self):
         self.task_pool._open = foo = 'foo'
         self.assertEqual(foo, self.task_pool.is_open)
@@ -91,48 +101,7 @@ class BaseTaskPoolTestCase(TestCase):
         mock_num_ended.assert_called_once_with()
 
     def test_is_full(self):
-        self.assertEqual(not self.task_pool._more_allowed_flag.is_set(), self.task_pool.is_full)
-
-    @patch.object(pool.BaseTaskPool, 'num_running', new_callable=PropertyMock)
-    @patch.object(pool.BaseTaskPool, 'is_full', new_callable=PropertyMock)
-    def test__check_more_allowed(self, mock_is_full: MagicMock, mock_num_running: MagicMock):
-        def reset_mocks():
-            mock_is_full.reset_mock()
-            mock_num_running.reset_mock()
-        self._check_more_allowed_patcher.stop()
-
-        # Just reaching limit, we expect flag to become unset:
-        mock_is_full.return_value = False
-        mock_num_running.return_value = 420
-        self.task_pool._more_allowed_flag.clear()
-        self.task_pool._check_more_allowed()
-        self.assertFalse(self.task_pool._more_allowed_flag.is_set())
-        mock_is_full.assert_has_calls([call(), call()])
-        mock_num_running.assert_called_once_with()
-        reset_mocks()
-
-        # Already at limit, we expect nothing to change:
-        mock_is_full.return_value = True
-        self.task_pool._check_more_allowed()
-        self.assertFalse(self.task_pool._more_allowed_flag.is_set())
-        mock_is_full.assert_has_calls([call(), call()])
-        mock_num_running.assert_called_once_with()
-        reset_mocks()
-
-        # Just finished a task, we expect flag to become set:
-        mock_num_running.return_value = 419
-        self.task_pool._check_more_allowed()
-        self.assertTrue(self.task_pool._more_allowed_flag.is_set())
-        mock_is_full.assert_called_once_with()
-        mock_num_running.assert_called_once_with()
-        reset_mocks()
-
-        # In this state we expect the flag to remain unchanged change:
-        mock_is_full.return_value = False
-        self.task_pool._check_more_allowed()
-        self.assertTrue(self.task_pool._more_allowed_flag.is_set())
-        mock_is_full.assert_has_calls([call(), call()])
-        mock_num_running.assert_called_once_with()
+        self.assertEqual(self.task_pool._enough_room.locked(), self.task_pool.is_full)
 
     def test__task_name(self):
         i = 123