[executor-preview] Test noise_learner_v3.py (#2498)

* Test noise_learner_v3.py

* reset mock

* init with session

* fix nlv3 constructor

* a bit more tests

* backticks

* test the run method

* black

* reverting a change by mistake

* lint

* lint

* wrote properties

* no need to check if simulator

* set session._run.return_value instead of session._run

* removed newly added properties

* convert _get_mode_service_backend into public

* fixed tests of the selected run method

* black

* lint

* typo

* 2026

* lint

Author: yaelbh

qiskit_ibm_runtime/base_primitive.py

@@ -46,7 +46,7 @@
 OptionsT = TypeVar("OptionsT", bound=BaseOptions)
 
 
-def _get_mode_service_backend(mode: BackendV2 | Session | Batch | None = None) -> tuple[
+def get_mode_service_backend(mode: BackendV2 | Session | Batch | None = None) -> tuple[
     Session | Batch | None,
     QiskitRuntimeService | QiskitRuntimeLocalService | None,
     BackendV2 | None,
@@ -120,7 +120,7 @@ def __init__(
         Raises:
             ValueError: Invalid arguments are given.
         """
-        self._mode, self._service, self._backend = _get_mode_service_backend(mode)
+        self._mode, self._service, self._backend = get_mode_service_backend(mode)
         self._set_options(options)
 
     def _run(self, pubs: list[EstimatorPub] | list[SamplerPub]) -> RuntimeJobV2:

qiskit_ibm_runtime/noise_learner/noise_learner.py

@@ -25,7 +25,7 @@
 from qiskit.primitives.containers import EstimatorPubLike
 from qiskit.primitives.containers.estimator_pub import EstimatorPub
 
-from ..base_primitive import _get_mode_service_backend
+from ..base_primitive import get_mode_service_backend
 from ..constants import DEFAULT_DECODERS
 from ..runtime_job_v2 import RuntimeJobV2
 from ..ibm_backend import IBMBackend
@@ -127,7 +127,7 @@ def __init__(
         mode: BackendV2 | Session | Batch | None = None,
         options: dict | NoiseLearnerOptions | EstimatorOptions | None = None,
     ):
-        self._mode, self._service, self._backend = _get_mode_service_backend(mode)
+        self._mode, self._service, self._backend = get_mode_service_backend(mode)
         if isinstance(self._service, QiskitRuntimeLocalService):
             raise ValueError("``NoiseLearner`` not currently supported in local mode.")
 

qiskit_ibm_runtime/noise_learner_v3/noise_learner_v3.py

@@ -22,17 +22,15 @@
 
 from qiskit_ibm_runtime.options.utils import UnsetType
 
-from ..base_primitive import _get_mode_service_backend
+from ..base_primitive import get_mode_service_backend
 from ..batch import Batch
 from ..fake_provider.local_service import QiskitRuntimeLocalService
 from ..options.noise_learner_v3_options import NoiseLearnerV3Options
-from ..qiskit_runtime_service import QiskitRuntimeService
 from ..runtime_job_v2 import RuntimeJobV2
 
 # pylint: disable=unused-import,cyclic-import
 from ..session import Session
 from ..utils.default_session import get_cm_session
-from ..utils.utils import is_simulator
 from .converters.version_0_1 import noise_learner_v3_inputs_to_0_1
 from .noise_learner_v3_decoders import NoiseLearnerV3ResultDecoder
 from .validation import validate_instruction, validate_options
@@ -77,50 +75,19 @@ def __init__(
         mode: BackendV2 | Session | Batch | None = None,
         options: NoiseLearnerV3Options | None = None,
     ):
-        self._session: BackendV2 | None = None
-        self._backend: BackendV2
-        self._service: QiskitRuntimeService
-
         self._options = options or NoiseLearnerV3Options()
         if (
             isinstance(self._options.experimental, UnsetType)
             or self._options.experimental.get("image") is None
         ):
             self._options.experimental = {}
 
-        if isinstance(mode, (Session, Batch)):
-            self._session = mode
-            self._backend = self._session._backend
-            self._service = self._session.service
-        elif open_session := get_cm_session():
-            if open_session != mode:
-                if open_session._backend != mode:
-                    raise ValueError(
-                        "The backend passed in to the primitive is different from the session "
-                        "backend. Please check which backend you intend to use or leave the mode "
-                        "parameter empty to use the session backend."
-                    )
-                logger.warning(
-                    "A backend was passed in as the mode but a session context manager "
-                    "is open so this job will run inside this session/batch "
-                    "instead of in job mode."
-                )
-            self._session = open_session
-            self._backend = self._session._backend
-            self._service = self._session.service
-        elif isinstance(mode, BackendV2):
-            self._backend = mode
-            self._service = self._backend.service
-        else:
-            raise ValueError(
-                "A backend or session/batch must be specified, or a session/batch must be open."
-            )
-        self._mode, self._service, self._backend = _get_mode_service_backend(  # type: ignore[assignment]
+        self._session, self._service, self._backend = get_mode_service_backend(
             mode
-        )
+        )  # type: ignore[assignment]
 
         if isinstance(self._service, QiskitRuntimeLocalService):  # type: ignore[unreachable]
-            raise ValueError("``NoiseLearner`` not currently supported in local mode.")
+            raise ValueError("``NoiseLearnerV3`` is currently not supported in local mode.")
 
     @property
     def options(self) -> NoiseLearnerV3Options:
@@ -146,15 +113,12 @@ def run(self, instructions: Iterable[CircuitInstruction]) -> RuntimeJobV2:
             IBMInputValueError: If an instruction cannot be learned by any of the supported learning
                 protocols.
         """
-        if self._backend:
-            target = getattr(self._backend, "target", None)
-            if target and not is_simulator(self._backend):
-                for instruction in instructions:
-                    validate_instruction(instruction, target)
-
-            configuration = getattr(self._backend, "configuration", None)
-            if configuration and not is_simulator(self._backend):
-                validate_options(self.options, configuration())
+        if target := getattr(self._backend, "target", None):
+            for instruction in instructions:
+                validate_instruction(instruction, target)
+
+        if configuration := getattr(self._backend, "configuration", None):
+            validate_options(self.options, configuration())
 
         inputs = noise_learner_v3_inputs_to_0_1(instructions, self.options).model_dump()
         inputs["version"] = 3  # TODO: this is a work-around for the dispatch

test/unit/noise_learner_v3/test_noise_learner_v3.py

@@ -0,0 +1,47 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2026.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Tests the `NoiseLearnerV3` class."""
+
+from unittest.mock import patch
+
+from test.utils import get_mocked_backend, get_mocked_session
+
+from qiskit_ibm_runtime.noise_learner_v3 import NoiseLearnerV3
+
+from ...ibm_test_case import IBMTestCase
+
+
+class TestNoiseLearnerV3(IBMTestCase):
+    """Tests the ``NoiseLearnerV3`` class."""
+
+    def test_run_of_session_is_selected(self):
+        """Test that ``NoiseLearnerV3.run`` selects the ``run`` method
+        of the session, if a session is specified."""
+        backend_name = "ibm_hello"
+        session = get_mocked_session(get_mocked_backend(backend_name))
+        with (
+            patch.object(session, "_run", return_value="session"),
+            patch.object(session.service, "_run", return_value="service"),
+        ):
+            noise_learner = NoiseLearnerV3(mode=session)
+            selected_run = noise_learner.run([])
+            self.assertEqual(selected_run, "session")
+
+    def test_run_of_service_is_selected(self):
+        """Test that ``NoiseLearnerV3.run`` selects the ``run`` method
+        of the service, if a session is not specified."""
+        backend = get_mocked_backend()
+        with patch.object(backend.service, "_run", return_value="service"):
+            noise_learner = NoiseLearnerV3(mode=backend)
+            selected_run = noise_learner.run([])
+            self.assertEqual(selected_run, "service")

test/unit/test_ibm_primitives_v2.py

@@ -26,6 +26,7 @@
 from qiskit_ibm_runtime import Session, Batch
 from qiskit_ibm_runtime.utils.default_session import _DEFAULT_SESSION
 from qiskit_ibm_runtime import EstimatorV2, SamplerV2
+from qiskit_ibm_runtime.base_primitive import get_mode_service_backend
 from qiskit_ibm_runtime.estimator import Estimator as IBMBaseEstimator
 from qiskit_ibm_runtime.fake_provider import FakeManilaV2
 from qiskit_ibm_runtime.exceptions import IBMInputValueError
@@ -650,3 +651,46 @@ def _assert_dict_partially_equal(self, dict1, dict2):
             dict_paritally_equal(dict1, dict2),
             f"{dict1} and {dict2} not partially equal.",
         )
+
+
+class TestGetModeServiceBackend(IBMTestCase):
+    """Test the function ``get_mode_service_backend``."""
+
+    def test_mode_is_backend(self):
+        """Test ``get_mode_service_backend`` when the input mode is an ``IBMBackend``."""
+        backend = get_mocked_backend()
+        service = backend.service
+        result = get_mode_service_backend(mode=backend)
+        self.assertEqual(result[0], None)
+        self.assertEqual(result[1], service)
+        self.assertEqual(result[2], backend)
+
+    def test_mode_is_session(self):
+        """Test ``get_mode_service_backend`` when the input mode is a session."""
+        backend_name = "ibm_hello"
+        session = get_mocked_session(get_mocked_backend(backend_name))
+        result = get_mode_service_backend(mode=session)
+        self.assertEqual(result[0], session)
+        self.assertEqual(result[1], session.service)
+        self.assertEqual(result[2].name, backend_name)
+
+    def test_session_context_manager(self):
+        """Test ``get_mode_service_backend`` inside a session context manager."""
+        backend = get_mocked_backend()
+        service = backend.service
+        with Session(backend=backend) as session:
+            result = get_mode_service_backend()
+            self.assertEqual(result[0], session)
+            self.assertEqual(result[1], service)
+            self.assertEqual(result[2], backend)
+
+    def test_mode_is_backend_inside_session_context_manager(self):
+        """Test ``get_mode_service_backend`` inside a session context manager,
+        when the input mode is an ``IBMBackend``."""
+        backend = get_mocked_backend()
+        service = backend.service
+        with Session(backend=backend) as session:
+            result = get_mode_service_backend(mode=backend)
+            self.assertEqual(result[0], session)
+            self.assertEqual(result[1], service)
+            self.assertEqual(result[2], backend)