issue #125: add test cases

noxdafox · noxdafox · commit 7d03e00bc14c · 2024-03-20T23:56:39.000+02:00
Signed-off-by: Matteo Cafasso &lt;noxdafox@gmail.com&gt;
diff --git a/test/test_asynchronous_process_fork.py b/test/test_asynchronous_process_fork.py
@@ -5,6 +5,7 @@
 import asyncio
 import unittest
 import threading
+import dataclasses
 import multiprocessing
 from concurrent.futures import CancelledError, TimeoutError
 
@@ -55,6 +56,16 @@ def pickling_error_decorated():
     return event
 
 
+@dataclasses.dataclass(frozen=True)
+class FrozenError(Exception):
+    pass
+
+
+@asynchronous.process(context=mp_context)
+def frozen_error_decorated():
+    raise FrozenError()
+
+
 @asynchronous.process(context=mp_context)
 def critical_decorated():
     os._exit(123)
@@ -303,6 +314,14 @@ async def test():
         with self.assertRaises((pickle.PicklingError, TypeError)):
             asyncio.run(test())
 
+    def test_frozen_error_decorated(self):
+        """Process Fork frozen errors are raised by future.result."""
+        async def test():
+            return await frozen_error_decorated()
+
+        with self.assertRaises(FrozenError):
+            asyncio.run(test())
+
     def test_timeout_decorated(self):
         """Process Fork raises TimeoutError if so."""
         async def test():
diff --git a/test/test_asynchronous_process_forkserver.py b/test/test_asynchronous_process_forkserver.py
@@ -5,6 +5,7 @@
 import asyncio
 import unittest
 import threading
+import dataclasses
 import multiprocessing
 from concurrent.futures import CancelledError, TimeoutError
 
@@ -55,6 +56,16 @@ def pickling_error_decorated():
     return event
 
 
+@dataclasses.dataclass(frozen=True)
+class FrozenError(Exception):
+    pass
+
+
+@asynchronous.process(context=mp_context)
+def frozen_error_decorated():
+    raise FrozenError()
+
+
 @asynchronous.process(context=mp_context)
 def critical_decorated():
     os._exit(123)
@@ -286,6 +297,14 @@ async def test():
         with self.assertRaises((pickle.PicklingError, TypeError)):
             asyncio.run(test())
 
+    def test_frozen_error_decorated(self):
+        """Process Fork frozen errors are raised by future.result."""
+        async def test():
+            return await frozen_error_decorated()
+
+        with self.assertRaises(FrozenError):
+            asyncio.run(test())
+
     def test_timeout_decorated(self):
         """Process Forkserver raises TimeoutError if so."""
         async def test():
diff --git a/test/test_asynchronous_process_spawn.py b/test/test_asynchronous_process_spawn.py
@@ -5,6 +5,7 @@
 import asyncio
 import unittest
 import threading
+import dataclasses
 import multiprocessing
 from concurrent.futures import CancelledError, TimeoutError
 
@@ -55,6 +56,16 @@ def pickling_error_decorated():
     return event
 
 
+@dataclasses.dataclass(frozen=True)
+class FrozenError(Exception):
+    pass
+
+
+@asynchronous.process(context=mp_context)
+def frozen_error_decorated():
+    raise FrozenError()
+
+
 @asynchronous.process(context=mp_context)
 def critical_decorated():
     os._exit(123)
@@ -286,6 +297,14 @@ async def test():
         with self.assertRaises((pickle.PicklingError, TypeError)):
             asyncio.run(test())
 
+    def test_frozen_error_decorated(self):
+        """Process Spawn frozen errors are raised by future.result."""
+        async def test():
+            return await frozen_error_decorated()
+
+        with self.assertRaises(FrozenError):
+            asyncio.run(test())
+
     def test_timeout_decorated(self):
         """Process Spawn raises TimeoutError if so."""
         async def test():
diff --git a/test/test_asynchronous_thread.py b/test/test_asynchronous_thread.py
@@ -1,6 +1,7 @@
 import asyncio
 import unittest
 import threading
+import dataclasses
 
 from pebble import asynchronous
 
@@ -25,6 +26,16 @@ def error_returned():
     return RuntimeError("BOOM!")
 
 
+@dataclasses.dataclass(frozen=True)
+class FrozenError(Exception):
+    pass
+
+
+@asynchronous.thread()
+def frozen_error_decorated():
+    raise FrozenError()
+
+
 @asynchronous.thread()
 def name_keyword_argument(name='function_kwarg'):
     return name
@@ -168,6 +179,14 @@ async def test():
         self.assertTrue(isinstance(self.exception, RuntimeError),
                         msg=str(self.exception))
 
+    def test_frozen_error_decorated(self):
+        """Thread frozen errors are raised by future.result."""
+        async def test():
+            return await frozen_error_decorated()
+
+        with self.assertRaises(FrozenError):
+            asyncio.run(test())
+
     def test_name_keyword_argument(self):
         """name keyword can be passed to a decorated function process without name """
         async def test():
diff --git a/test/test_concurrent_process_fork.py b/test/test_concurrent_process_fork.py
@@ -4,6 +4,7 @@
 import signal
 import unittest
 import threading
+import dataclasses
 import multiprocessing
 from concurrent.futures import CancelledError, TimeoutError
 
@@ -54,6 +55,16 @@ def pickling_error_decorated():
     return event
 
 
+@dataclasses.dataclass(frozen=True)
+class FrozenError(Exception):
+    pass
+
+
+@concurrent.process(context=mp_context)
+def frozen_error_decorated():
+    raise FrozenError()
+
+
 @concurrent.process(context=mp_context)
 def critical_decorated():
     os._exit(123)
@@ -253,6 +264,12 @@ def test_pickling_error_decorated(self):
         with self.assertRaises((pickle.PicklingError, TypeError)):
             future.result()
 
+    def test_frozen_error_decorated(self):
+        """Process Fork frozen errors are raised by future.result."""
+        future = frozen_error_decorated()
+        with self.assertRaises(FrozenError):
+            future.result()
+
     def test_timeout_decorated(self):
         """Process Fork raises TimeoutError if so."""
         future = long_decorated()
diff --git a/test/test_concurrent_process_forkserver.py b/test/test_concurrent_process_forkserver.py
@@ -4,6 +4,7 @@
 import signal
 import unittest
 import threading
+import dataclasses
 import multiprocessing
 from concurrent.futures import CancelledError, TimeoutError
 
@@ -54,6 +55,16 @@ def pickling_error_decorated():
     return event
 
 
+@dataclasses.dataclass(frozen=True)
+class FrozenError(Exception):
+    pass
+
+
+@concurrent.process(context=mp_context)
+def frozen_error_decorated():
+    raise FrozenError()
+
+
 @concurrent.process(context=mp_context)
 def critical_decorated():
     os._exit(123)
@@ -214,6 +225,12 @@ def test_pickling_error_decorated(self):
         with self.assertRaises((pickle.PicklingError, TypeError)):
             future.result()
 
+    def test_frozen_error_decorated(self):
+        """Process Fork frozen errors are raised by future.result."""
+        future = frozen_error_decorated()
+        with self.assertRaises(FrozenError):
+            future.result()
+
     def test_timeout_decorated(self):
         """Process Forkserver raises TimeoutError if so."""
         future = long_decorated()
diff --git a/test/test_concurrent_process_spawn.py b/test/test_concurrent_process_spawn.py
@@ -4,6 +4,7 @@
 import signal
 import unittest
 import threading
+import dataclasses
 import multiprocessing
 from concurrent.futures import CancelledError, TimeoutError
 
@@ -54,6 +55,16 @@ def pickling_error_decorated():
     return event
 
 
+@dataclasses.dataclass(frozen=True)
+class FrozenError(Exception):
+    pass
+
+
+@concurrent.process(context=mp_context)
+def frozen_error_decorated():
+    raise FrozenError()
+
+
 @concurrent.process(context=mp_context)
 def critical_decorated():
     os._exit(123)
@@ -214,6 +225,12 @@ def test_pickling_error_decorated(self):
         with self.assertRaises((pickle.PicklingError, TypeError)):
             future.result()
 
+    def test_error_decorated(self):
+        """Process Fork errors are raised by future.result."""
+        future = error_decorated()
+        with self.assertRaises(RuntimeError):
+            future.result()
+
     def test_timeout_decorated(self):
         """Process Spawn raises TimeoutError if so."""
         future = long_decorated()
diff --git a/test/test_process_pool_fork.py b/test/test_process_pool_fork.py
@@ -6,6 +6,7 @@
 import asyncio
 import unittest
 import threading
+import dataclasses
 import multiprocessing
 
 from concurrent.futures import CancelledError, TimeoutError
@@ -64,6 +65,15 @@ def return_error_function():
     return BaseException("BOOM!")
 
 
+@dataclasses.dataclass(frozen=True)
+class FrozenError(Exception):
+    pass
+
+
+def frozen_error_function():
+    raise FrozenError()
+
+
 def pickle_error_function():
     return threading.Lock()
 
@@ -187,6 +197,12 @@ def test_process_pool_pickling_error_result(self):
             future = pool.schedule(pickle_error_function)
             self.assertRaises((pickle.PicklingError, TypeError), future.result)
 
+    def test_process_pool_frozen_error(self):
+        """Process Pool Fork frozen errors are raised by future get."""
+        with ProcessPool(max_workers=1, context=mp_context) as pool:
+            future = pool.schedule(frozen_error_function)
+        self.assertRaises(FrozenError, future.result)
+
     def test_process_pool_timeout(self):
         """Process Pool Fork future raises TimeoutError if so."""
         with ProcessPool(max_workers=1, context=mp_context) as pool:
diff --git a/test/test_process_pool_forkserver.py b/test/test_process_pool_forkserver.py
@@ -6,6 +6,7 @@
 import asyncio
 import unittest
 import threading
+import dataclasses
 import multiprocessing
 
 from concurrent.futures import CancelledError, TimeoutError
@@ -70,6 +71,15 @@ def pickle_error_function():
     return threading.Lock()
 
 
+@dataclasses.dataclass(frozen=True)
+class FrozenError(Exception):
+    pass
+
+
+def frozen_error_function():
+    raise FrozenError()
+
+
 def long_function(value=1):
     time.sleep(value)
     return value
@@ -189,6 +199,12 @@ def test_process_pool_pickling_error_result(self):
             future = pool.schedule(pickle_error_function)
             self.assertRaises((pickle.PicklingError, TypeError), future.result)
 
+    def test_process_pool_frozen_error(self):
+        """Process Pool Forkserver frozen errors are raised by future get."""
+        with ProcessPool(max_workers=1, context=mp_context) as pool:
+            future = pool.schedule(frozen_error_function)
+        self.assertRaises(FrozenError, future.result)
+
     def test_process_pool_timeout(self):
         """Process Pool Forkserver future raises TimeoutError if so."""
         with ProcessPool(max_workers=1, context=mp_context) as pool:
diff --git a/test/test_process_pool_spawn.py b/test/test_process_pool_spawn.py
@@ -6,6 +6,7 @@
 import asyncio
 import unittest
 import threading
+import dataclasses
 import multiprocessing
 
 from concurrent.futures import CancelledError, TimeoutError
@@ -68,6 +69,15 @@ def pickle_error_function():
     return threading.Lock()
 
 
+@dataclasses.dataclass(frozen=True)
+class FrozenError(Exception):
+    pass
+
+
+def frozen_error_function():
+    raise FrozenError()
+
+
 def long_function(value=1):
     time.sleep(value)
     return value
@@ -187,6 +197,12 @@ def test_process_pool_pickling_error_result(self):
             future = pool.schedule(pickle_error_function)
             self.assertRaises((pickle.PicklingError, TypeError), future.result)
 
+    def test_process_pool_frozen_error(self):
+        """Process Pool Spawn frozen errors are raised by future get."""
+        with ProcessPool(max_workers=1, context=mp_context) as pool:
+            future = pool.schedule(frozen_error_function)
+        self.assertRaises(FrozenError, future.result)
+
     def test_process_pool_timeout(self):
         """Process Pool Spawn future raises TimeoutError if so."""
         with ProcessPool(max_workers=1, context=mp_context) as pool:
diff --git a/test/test_thread_pool.py b/test/test_thread_pool.py
