fix checking for running sync version in coroutine in case when event loop is not set

Author: rutsky

backoff/_decorator.py

@@ -62,13 +62,19 @@ def decorate(target):
             else:
                 # Verify that sync version is not being run from coroutine
                 # (that would lead to event loop hiccups).
-                if asyncio.Task.current_task() is not None:
-                    raise TypeError(
-                        "backoff.on_predicate applied to a regular function "
-                        "inside coroutine, this will lead to event loop "
-                        "hiccups. "
-                        "Use backoff.on_predicate on coroutines in "
-                        "asynchronous code.")
+                try:
+                    asyncio.get_event_loop()
+                except RuntimeError:
+                    # Event loop not set for this thread.
+                    pass
+                else:
+                    if asyncio.Task.current_task() is not None:
+                        raise TypeError(
+                            "backoff.on_predicate applied to a regular "
+                            "function inside coroutine, this will lead "
+                            "to event loop hiccups. "
+                            "Use backoff.on_predicate on coroutines in "
+                            "asynchronous code.")
 
         if retry is None:
             retry = _sync.retry_predicate
@@ -138,13 +144,19 @@ def decorate(target):
             else:
                 # Verify that sync version is not being run from coroutine
                 # (that would lead to event loop hiccups).
-                if asyncio.Task.current_task() is not None:
-                    raise TypeError(
-                        "backoff.on_exception applied to a regular function "
-                        "inside coroutine, this will lead to event loop "
-                        "hiccups. "
-                        "Use backoff.on_exception on coroutines in "
-                        "asynchronous code.")
+                try:
+                    asyncio.get_event_loop()
+                except RuntimeError:
+                    # Event loop not set for this thread.
+                    pass
+                else:
+                    if asyncio.Task.current_task() is not None:
+                        raise TypeError(
+                            "backoff.on_exception applied to a regular "
+                            "function inside coroutine, this will lead "
+                            "to event loop hiccups. "
+                            "Use backoff.on_exception on coroutines in "
+                            "asynchronous code.")
 
         if retry is None:
             retry = _sync.retry_exception

tests/python34/test_backoff_async.py

@@ -573,3 +573,52 @@ def regular_func():
             pass
 
     assert "applied to a regular function" in str(excinfo.value)
+
+
+def test_on_predicate_on_regular_function_without_event_loop(monkeypatch):
+    monkeypatch.setattr('time.sleep', lambda x: None)
+
+    # Set default event loop to None.
+    loop = asyncio.get_event_loop()
+    asyncio.set_event_loop(None)
+
+    try:
+        @backoff.on_predicate(backoff.expo)
+        def return_true(log, n):
+            val = (len(log) == n - 1)
+            log.append(val)
+            return val
+
+        log = []
+        ret = return_true(log, 3)
+        assert ret is True
+        assert 3 == len(log)
+
+    finally:
+        # Restore event loop.
+        asyncio.set_event_loop(loop)
+
+
+def test_on_exception_on_regular_function_without_event_loop(monkeypatch):
+    monkeypatch.setattr('time.sleep', lambda x: None)
+
+    # Set default event loop to None.
+    loop = asyncio.get_event_loop()
+    asyncio.set_event_loop(None)
+
+    try:
+        @backoff.on_exception(backoff.expo, KeyError)
+        def keyerror_then_true(log, n):
+            if len(log) == n:
+                return True
+            e = KeyError()
+            log.append(e)
+            raise e
+
+        log = []
+        assert keyerror_then_true(log, 3) is True
+        assert 3 == len(log)
+
+    finally:
+        # Restore event loop.
+        asyncio.set_event_loop(loop)

tests/test_backoff.py

@@ -3,6 +3,7 @@
 import backoff
 import pytest
 import random
+import threading
 
 from tests.common import _log_hdlrs, _save_target
 
@@ -465,3 +466,66 @@ def exceptor():
 
     with pytest.raises(ValueError):
         exceptor()
+
+
+def test_on_predicate_in_thread(monkeypatch):
+    monkeypatch.setattr('time.sleep', lambda x: None)
+
+    result = []
+
+    def check():
+        try:
+            @backoff.on_predicate(backoff.expo)
+            def return_true(log, n):
+                val = (len(log) == n - 1)
+                log.append(val)
+                return val
+
+            log = []
+            ret = return_true(log, 3)
+            assert ret is True
+            assert 3 == len(log)
+
+        except Exception as ex:
+            result.append(ex)
+        else:
+            result.append('success')
+
+    t = threading.Thread(target=check)
+    t.start()
+    t.join()
+
+    assert len(result) == 1
+    assert result[0] == 'success'
+
+
+def test_on_exception_in_thread(monkeypatch):
+    monkeypatch.setattr('time.sleep', lambda x: None)
+
+    result = []
+
+    def check():
+        try:
+            @backoff.on_exception(backoff.expo, KeyError)
+            def keyerror_then_true(log, n):
+                if len(log) == n:
+                    return True
+                e = KeyError()
+                log.append(e)
+                raise e
+
+            log = []
+            assert keyerror_then_true(log, 3) is True
+            assert 3 == len(log)
+
+        except Exception as ex:
+            result.append(ex)
+        else:
+            result.append('success')
+
+    t = threading.Thread(target=check)
+    t.start()
+    t.join()
+
+    assert len(result) == 1
+    assert result[0] == 'success'