Use importorskip

Author: aliu39

tests/integrations/featureflags/test_featureflags.py

@@ -1,4 +1,3 @@
-# import asyncio
 import concurrent.futures as cf
 
 import sentry_sdk
@@ -7,8 +6,7 @@
     add_feature_flag,
 )
 
-# import pytest
-# import sys
+import pytest
 
 
 def test_featureflags_integration(sentry_init, capture_events, uninstall_integration):
@@ -81,56 +79,53 @@ def task(flag_key):
     }
 
 
-#
-#
-# @pytest.mark.skipif(
-#     sys.version_info < (3, 7), reason="Test requires Python 3.7 or higher"
-# )
-# def test_featureflags_integration_asyncio(
-#     sentry_init, capture_events, uninstall_integration
-# ):
-#     uninstall_integration(FeatureFlagsIntegration.identifier)
-#     sentry_init(integrations=[FeatureFlagsIntegration()])
-#     events = capture_events()
-#
-#     # Capture an eval before we split isolation scopes.
-#     add_feature_flag("hello", False)
-#
-#     async def task(flag_key):
-#         # Creates a new isolation scope for the thread.
-#         # This means the evaluations in each task are captured separately.
-#         with sentry_sdk.isolation_scope():
-#             add_feature_flag(flag_key, False)
-#             # use a tag to identify to identify events later on
-#             sentry_sdk.set_tag("task_id", flag_key)
-#             sentry_sdk.capture_exception(Exception("something wrong!"))
-#
-#     async def runner():
-#         return asyncio.gather(task("world"), task("other"))
-#
-#     asyncio.run(runner())
-#
-#     # Capture error in original scope
-#     sentry_sdk.set_tag("task_id", "0")
-#     sentry_sdk.capture_exception(Exception("something wrong!"))
-#
-#     assert len(events) == 3
-#     events.sort(key=lambda e: e["tags"]["task_id"])
-#
-#     assert events[0]["contexts"]["flags"] == {
-#         "values": [
-#             {"flag": "hello", "result": False},
-#         ]
-#     }
-#     assert events[1]["contexts"]["flags"] == {
-#         "values": [
-#             {"flag": "hello", "result": False},
-#             {"flag": "other", "result": False},
-#         ]
-#     }
-#     assert events[2]["contexts"]["flags"] == {
-#         "values": [
-#             {"flag": "hello", "result": False},
-#             {"flag": "world", "result": False},
-#         ]
-#     }
+def test_featureflags_integration_asyncio(
+    sentry_init, capture_events, uninstall_integration
+):
+    asyncio = pytest.importorskip("asyncio")  # Only available in Python 3.7+.
+
+    uninstall_integration(FeatureFlagsIntegration.identifier)
+    sentry_init(integrations=[FeatureFlagsIntegration()])
+    events = capture_events()
+
+    # Capture an eval before we split isolation scopes.
+    add_feature_flag("hello", False)
+
+    async def task(flag_key):
+        # Creates a new isolation scope for the thread.
+        # This means the evaluations in each task are captured separately.
+        with sentry_sdk.isolation_scope():
+            add_feature_flag(flag_key, False)
+            # use a tag to identify to identify events later on
+            sentry_sdk.set_tag("task_id", flag_key)
+            sentry_sdk.capture_exception(Exception("something wrong!"))
+
+    async def runner():
+        return asyncio.gather(task("world"), task("other"))
+
+    asyncio.run(runner())
+
+    # Capture error in original scope
+    sentry_sdk.set_tag("task_id", "0")
+    sentry_sdk.capture_exception(Exception("something wrong!"))
+
+    assert len(events) == 3
+    events.sort(key=lambda e: e["tags"]["task_id"])
+
+    assert events[0]["contexts"]["flags"] == {
+        "values": [
+            {"flag": "hello", "result": False},
+        ]
+    }
+    assert events[1]["contexts"]["flags"] == {
+        "values": [
+            {"flag": "hello", "result": False},
+            {"flag": "other", "result": False},
+        ]
+    }
+    assert events[2]["contexts"]["flags"] == {
+        "values": [
+            {"flag": "hello", "result": False},
+            {"flag": "world", "result": False},
+        ]
+    }

tests/integrations/launchdarkly/test_launchdarkly.py

@@ -1,4 +1,3 @@
-import asyncio
 import concurrent.futures as cf
 
 import ldclient
@@ -114,6 +113,9 @@ def test_launchdarkly_integration_asyncio(
     sentry_init, capture_events, uninstall_integration
 ):
     """Assert concurrently evaluated flags do not pollute one another."""
+
+    asyncio = pytest.importorskip("asyncio")  # Only available in Python 3.7+.
+
     td = TestData.data_source()
     client = LDClient(config=Config("sdk-key", update_processor_class=td))
     context = Context.create("user1")

tests/integrations/openfeature/test_openfeature.py

@@ -1,10 +1,10 @@
-import asyncio
 import concurrent.futures as cf
 import sentry_sdk
 
 from openfeature import api
 from openfeature.provider.in_memory_provider import InMemoryFlag, InMemoryProvider
 from sentry_sdk.integrations.openfeature import OpenFeatureIntegration
+import pytest
 
 
 def test_openfeature_integration(sentry_init, capture_events, uninstall_integration):
@@ -95,6 +95,8 @@ def test_openfeature_integration_asyncio(
 ):
     """Assert concurrently evaluated flags do not pollute one another."""
 
+    asyncio = pytest.importorskip("asyncio")  # Only available in Python 3.7+.
+
     uninstall_integration(OpenFeatureIntegration.identifier)
     sentry_init(integrations=[OpenFeatureIntegration()])
     events = capture_events()