hfsadjkfhskdjhfsad

Author: rjduffner

opentelemetry-instrumentation/tests/auto_instrumentation/test_load.py

@@ -23,6 +23,10 @@
     OTEL_PYTHON_DISTRO,
 )
 from opentelemetry.instrumentation.version import __version__
+from opentelemetry.instrumentation.dependencies import (
+    DependencyConflictError,
+    DependencyConflict,
+)
 
 
 class TestLoad(TestCase):
@@ -199,17 +203,18 @@ def test_load_distro_error(self, iter_mock, isinstance_mock):
         # Confirm method raises exception if it fails to load a distro.
         self.assertRaises(Exception, _load._load_distro)
 
+    @staticmethod
+    def _instrumentation_failed_to_load_call(entry_point, dependency_conflict):
+        return call("Skipping instrumentation %s: %s", entry_point, dependency_conflict)
+
     @patch.dict(
         "os.environ",
         {OTEL_PYTHON_DISABLED_INSTRUMENTATIONS: " instr1 , instr3 "},
     )
-    @patch(
-        "opentelemetry.instrumentation.auto_instrumentation._load.get_dist_dependency_conflicts"
-    )
     @patch(
         "opentelemetry.instrumentation.auto_instrumentation._load.entry_points"
     )
-    def test_load_instrumentors(self, iter_mock, dep_mock):
+    def test_load_instrumentors(self, iter_mock):
         # Mock opentelemetry_pre_instrument entry points
         # pylint: disable=too-many-locals
         pre_ep_mock1 = Mock()
@@ -254,8 +259,6 @@ def test_load_instrumentors(self, iter_mock, dep_mock):
             (ep_mock1, ep_mock2, ep_mock3, ep_mock4),
             (post_ep_mock1, post_ep_mock2),
         ]
-        # No dependency conflict
-        dep_mock.return_value = None
         _load._load_instrumentors(distro_mock)
         # All opentelemetry_pre_instrument entry points should be loaded
         pre_mock1.assert_called_once()
@@ -264,8 +267,8 @@ def test_load_instrumentors(self, iter_mock, dep_mock):
         # Only non-disabled instrumentations should be loaded
         distro_mock.load_instrumentor.assert_has_calls(
             [
-                call(ep_mock2, skip_dep_check=True),
-                call(ep_mock4, skip_dep_check=True),
+                call(ep_mock2, raise_exception_on_conflict=True),
+                call(ep_mock4, raise_exception_on_conflict=True),
             ]
         )
         self.assertEqual(distro_mock.load_instrumentor.call_count, 2)
@@ -277,13 +280,11 @@ def test_load_instrumentors(self, iter_mock, dep_mock):
         "os.environ",
         {OTEL_PYTHON_DISABLED_INSTRUMENTATIONS: " instr1 , instr3 "},
     )
-    @patch(
-        "opentelemetry.instrumentation.auto_instrumentation._load.get_dist_dependency_conflicts"
-    )
+    @patch('opentelemetry.instrumentation.auto_instrumentation._load._logger')
     @patch(
         "opentelemetry.instrumentation.auto_instrumentation._load.entry_points"
     )
-    def test_load_instrumentors_dep_conflict(self, iter_mock, dep_mock):  # pylint: disable=no-self-use
+    def test_load_instrumentors_dep_conflict(self, iter_mock, mock_logger):  # pylint: disable=no-self-use
         ep_mock1 = Mock()
         ep_mock1.name = "instr1"
 
@@ -296,27 +297,27 @@ def test_load_instrumentors_dep_conflict(self, iter_mock, dep_mock):  # pylint:
         ep_mock4 = Mock()
         ep_mock4.name = "instr4"
 
+        dependency_conflict = DependencyConflict("1.2.3", None)
+
         distro_mock = Mock()
+        distro_mock.load_instrumentor.side_effect = [None, DependencyConflictError(dependency_conflict)]
 
         iter_mock.return_value = (ep_mock1, ep_mock2, ep_mock3, ep_mock4)
-        # If a dependency conflict is raised, that instrumentation should not be loaded, but others still should.
-        dep_mock.side_effect = [None, "DependencyConflict"]
         _load._load_instrumentors(distro_mock)
         distro_mock.load_instrumentor.assert_has_calls(
             [
-                call(ep_mock2, skip_dep_check=True),
+                call(ep_mock2, raise_exception_on_conflict=True),
+                call(ep_mock4, raise_exception_on_conflict=True),
             ]
         )
-        distro_mock.load_instrumentor.assert_called_once()
+        assert distro_mock.load_instrumentor.call_count == 2
+        mock_logger.debug.assert_has_calls([self._instrumentation_failed_to_load_call(ep_mock4.name, dependency_conflict)])
 
-    @patch(
-        "opentelemetry.instrumentation.auto_instrumentation._load.get_dist_dependency_conflicts"
-    )
     @patch(
         "opentelemetry.instrumentation.auto_instrumentation._load.entry_points"
     )
     def test_load_instrumentors_import_error_does_not_stop_everything(
-        self, iter_mock, dep_mock
+        self, iter_mock
     ):
         ep_mock1 = Mock(name="instr1")
         ep_mock2 = Mock(name="instr2")
@@ -330,25 +331,21 @@ def test_load_instrumentors_import_error_does_not_stop_everything(
             (ep_mock1, ep_mock2),
             (),
         ]
-        dep_mock.return_value = None
 
         _load._load_instrumentors(distro_mock)
 
         distro_mock.load_instrumentor.assert_has_calls(
             [
-                call(ep_mock1, skip_dep_check=True),
-                call(ep_mock2, skip_dep_check=True),
+                call(ep_mock1, raise_exception_on_conflict=True),
+                call(ep_mock2, raise_exception_on_conflict=True),
             ]
         )
         self.assertEqual(distro_mock.load_instrumentor.call_count, 2)
 
-    @patch(
-        "opentelemetry.instrumentation.auto_instrumentation._load.get_dist_dependency_conflicts"
-    )
     @patch(
         "opentelemetry.instrumentation.auto_instrumentation._load.entry_points"
     )
-    def test_load_instrumentors_raises_exception(self, iter_mock, dep_mock):
+    def test_load_instrumentors_raises_exception(self, iter_mock):
         ep_mock1 = Mock(name="instr1")
         ep_mock2 = Mock(name="instr2")
 
@@ -361,14 +358,13 @@ def test_load_instrumentors_raises_exception(self, iter_mock, dep_mock):
             (ep_mock1, ep_mock2),
             (),
         ]
-        dep_mock.return_value = None
 
         with self.assertRaises(ValueError):
             _load._load_instrumentors(distro_mock)
 
         distro_mock.load_instrumentor.assert_has_calls(
             [
-                call(ep_mock1, skip_dep_check=True),
+                call(ep_mock1, raise_exception_on_conflict=True),
             ]
         )
         self.assertEqual(distro_mock.load_instrumentor.call_count, 1)