Remove IQP classic integration tests

Author: kt474

.github/workflows/ci.yml

@@ -122,7 +122,7 @@ jobs:
       matrix:
         python-version: [ 3.9 ]
         os: [ "ubuntu-latest" ]
-        environment: [ "ibm-quantum-production", "ibm-cloud-production" ]
+        environment: ["ibm-cloud-production" ]
     environment: ${{ matrix.environment }}
     env:
       QISKIT_IBM_TOKEN: ${{ secrets.QISKIT_IBM_TOKEN }}

.github/workflows/integration-tests-qiskit-main.yml

@@ -27,7 +27,7 @@ jobs:
       matrix:
         python-version: [ 3.9 ]
         os: [ "ubuntu-latest" ]
-        environment: [ "ibm-quantum-production", "ibm-quantum-staging", "ibm-cloud-production", "ibm-cloud-staging" ]
+        environment: ["ibm-cloud-production", "ibm-cloud-staging" ]
     environment: ${{ matrix.environment }}
     env:
       QISKIT_IBM_TOKEN: ${{ secrets.QISKIT_IBM_TOKEN }}

.github/workflows/integration-tests.yml

@@ -27,7 +27,7 @@ jobs:
       matrix:
         python-version: [ 3.9 ]
         os: [ "ubuntu-latest" ]
-        environment: [ "ibm-quantum-production", "ibm-quantum-staging", "ibm-cloud-production", "ibm-cloud-staging" ]
+        environment: ["ibm-cloud-production", "ibm-cloud-staging" ]
     environment: ${{ matrix.environment }}
     env:
       QISKIT_IBM_TOKEN: ${{ secrets.QISKIT_IBM_TOKEN }}

.github/workflows/smoke-tests.yml

@@ -24,7 +24,7 @@ jobs:
       matrix:
         python-version: [ 3.9 ]
         os: [ "ubuntu-latest" ]
-        environment: [ "ibm-quantum-production", "ibm-quantum-staging", "ibm-cloud-production", "ibm-cloud-staging" ]
+        environment: [ "ibm-cloud-production", "ibm-cloud-staging" ]
     environment: ${{ matrix.environment }}
     env:
       QISKIT_IBM_TOKEN: ${{ secrets.QISKIT_IBM_TOKEN }}

CONTRIBUTING.md

@@ -237,7 +237,7 @@ To enable test cases against external system in your private fork, make sure to
 The names of the environments must match the ones that the [CI workflow](.github/workflows/ci.yml) relies
 upon. 
 
-For example, in your github fork settings, add the environment you want to run tests on (ibm-quantum-production, ibm-quantum-staging, ibm-cloud-production, ibm-cloud-staging). Then add the appropriate environment secrets (QISKIT_IBM_INSTANCE, QISKIT_IBM_TOKEN, QISKIT_IBM_URL, QISKIT_IBM_DEVICE).
+For example, in your github fork settings, add the environment you want to run tests on (ibm-cloud-production, ibm-cloud-staging). Then add the appropriate environment secrets (QISKIT_IBM_INSTANCE, QISKIT_IBM_TOKEN, QISKIT_IBM_URL, QISKIT_IBM_DEVICE).
 
 ### Style guide
 

test/decorators.py

@@ -35,20 +35,6 @@ def _wrapper(self, *args, **kwargs):
     return _wrapper
 
 
-def quantum_only(func):
-    """Decorator that runs a test using only ibm_quantum services."""
-
-    @wraps(func)
-    def _wrapper(self, service):
-        if service._channel != "ibm_quantum":
-            raise SkipTest(
-                f"Skipping integration test. {self} does not support channel type {service._channel}"
-            )
-        func(self, service)
-
-    return _wrapper
-
-
 def run_quantum_and_cloud_fake(func):
     """Decorator that runs a test using both quantum and cloud fake services."""
 

test/integration/test_account.py

@@ -48,10 +48,6 @@ def _get_service_instance_name_for_crn(
 class TestIntegrationAccount(IBMIntegrationTestCase):
     """Integration tests for account management."""
 
-    def _skip_on_ibm_quantum(self):
-        if self.dependencies.channel == "ibm_quantum":
-            self.skipTest("Not supported on ibm_quantum")
-
     def test_local_channel(self):
         """Test local channel mode"""
         local_service = QiskitRuntimeService(
@@ -68,7 +64,6 @@ def test_local_channel(self):
 
     def test_resolve_crn_for_valid_service_instance_name(self):
         """Verify if CRN is transparently resolved based for an existing service instance name."""
-        self._skip_on_ibm_quantum()
 
         service_instance_name = _get_service_instance_name_for_crn(self.dependencies)
         with self.subTest(instance=service_instance_name):
@@ -83,7 +78,6 @@ def test_resolve_crn_for_valid_service_instance_name(self):
 
     def test_resolve_crn_for_invalid_service_instance_name(self):
         """Verify if CRN resolution fails for non-existing service instance name."""
-        self._skip_on_ibm_quantum()
 
         service_instance_name = "-non-existing-service-name-"
         with (
@@ -96,16 +90,3 @@ def test_resolve_crn_for_invalid_service_instance_name(self):
                 token=self.dependencies.token,
                 instance=service_instance_name,
             )
-
-    def test_logging_instance_at_init(self):
-        """Test instance is logged at initialization if instance not passed in."""
-        if self.dependencies.channel == "ibm_cloud":
-            self.skipTest("Not supported on ibm_cloud")
-
-        with self.assertLogs("qiskit_ibm_runtime", "INFO") as logs:
-            QiskitRuntimeService(
-                channel="ibm_quantum",
-                url=self.dependencies.url,
-                token=self.dependencies.token,
-            )
-        self.assertIn("instance", logs.output[0])

test/integration/test_auth_client.py

@@ -12,25 +12,16 @@
 
 """Tests for the AccountClient class."""
 
-import re
 
-from qiskit_ibm_runtime.api.exceptions import RequestsApiError
-from qiskit_ibm_runtime.exceptions import IBMNotAuthorizedError
 from qiskit_ibm_runtime.api.client_parameters import ClientParameters
-from qiskit_ibm_runtime.api.clients import AuthClient
+
 from ..ibm_test_case import IBMTestCase
 from ..decorators import integration_test_setup, IntegrationTestDependencies
 
 
 class TestAuthClient(IBMTestCase):
     """Tests for the AuthClient."""
 
-    @integration_test_setup(supported_channel=["ibm_quantum"], init_service=False)
-    def test_valid_login(self, dependencies: IntegrationTestDependencies) -> None:
-        """Test valid authentication."""
-        client = self._init_auth_client(dependencies.token, dependencies.url)
-        self.assertTrue(client.access_token)
-
     @integration_test_setup(supported_channel=["ibm_cloud"], init_service=False)
     def test_cloud_access_token(self, dependencies: IntegrationTestDependencies) -> None:
         """Test valid cloud authentication."""
@@ -43,54 +34,3 @@ def test_cloud_access_token(self, dependencies: IntegrationTestDependencies) ->
         cloud_auth = params.get_auth_handler()
         self.assertTrue(cloud_auth.tm)
         self.assertTrue(cloud_auth.tm.get_token())
-
-    @integration_test_setup(supported_channel=["ibm_quantum"], init_service=False)
-    def test_url_404(self, dependencies: IntegrationTestDependencies) -> None:
-        """Test login against a 404 URL"""
-        url_404 = re.sub(r"/api.*$", "/api/TEST_404", dependencies.url)
-        with self.assertRaises(RequestsApiError):
-            _ = self._init_auth_client(dependencies.token, url_404)
-
-    @integration_test_setup(supported_channel=["ibm_quantum"], init_service=False)
-    def test_invalid_token(self, dependencies: IntegrationTestDependencies) -> None:
-        """Test login using invalid token."""
-        qe_token = "INVALID_TOKEN"
-        with self.assertRaises(IBMNotAuthorizedError):
-            _ = self._init_auth_client(qe_token, dependencies.url)
-
-    @integration_test_setup(supported_channel=["ibm_quantum"], init_service=False)
-    def test_url_unreachable(self, dependencies: IntegrationTestDependencies) -> None:
-        """Test login against an invalid (malformed) URL."""
-        qe_url = "INVALID_URL"
-        with self.assertRaises(RequestsApiError):
-            _ = self._init_auth_client(dependencies.token, qe_url)
-
-    @integration_test_setup(supported_channel=["ibm_quantum"], init_service=False)
-    def test_api_version(self, dependencies: IntegrationTestDependencies) -> None:
-        """Check the version of the QX API."""
-        client = self._init_auth_client(dependencies.token, dependencies.url)
-        version = client.api_version()
-        self.assertIsNotNone(version)
-
-    @integration_test_setup(supported_channel=["ibm_quantum"], init_service=False)
-    def test_user_urls(self, dependencies: IntegrationTestDependencies) -> None:
-        """Check the user urls of the QX API."""
-        client = self._init_auth_client(dependencies.token, dependencies.url)
-        user_urls = client.user_urls()
-        self.assertIsNotNone(user_urls)
-        self.assertTrue("http" in user_urls and "ws" in user_urls)
-
-    @integration_test_setup(supported_channel=["ibm_quantum"], init_service=False)
-    def test_user_hubs(self, dependencies: IntegrationTestDependencies) -> None:
-        """Check the user hubs of the QX API."""
-        client = self._init_auth_client(dependencies.token, dependencies.url)
-        user_hubs = client.user_hubs()
-        self.assertIsNotNone(user_hubs)
-        for user_hub in user_hubs:
-            with self.subTest(user_hub=user_hub):
-                self.assertTrue("hub" in user_hub and "group" in user_hub and "project" in user_hub)
-
-    def _init_auth_client(self, token, url):
-        """Return an AuthClient."""
-        params = ClientParameters(channel="ibm_quantum", token=token, url=url)
-        return AuthClient(params)

test/integration/test_backend.py

@@ -25,7 +25,7 @@
 from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
 
 from ..ibm_test_case import IBMIntegrationTestCase
-from ..decorators import run_integration_test, production_only, quantum_only
+from ..decorators import run_integration_test, production_only
 from ..utils import bell
 
 
@@ -44,26 +44,6 @@ def test_backends(self, service):
             f"backend_names={backend_names}",
         )
 
-    @run_integration_test
-    @quantum_only
-    def test_backend_wrong_instance(self, service):
-        """Test getting a backend with wrong instance."""
-        hgps = list(service._hgps.keys())
-        if len(hgps) < 2:
-            raise SkipTest("Skipping test, not enough instances")
-
-        hgp_1 = hgps[0]
-        hgp_2 = hgps[1]
-        hgp_1_backends = [backend.name for backend in service.backends(instance=hgp_1)]
-        hgp_2_backends = [backend.name for backend in service.backends(instance=hgp_2)]
-        unique_backends_list = list(
-            set(hgp_2_backends) - set(hgp_1_backends)
-        )  # get differences between the two lists
-        if unique_backends_list:
-            unique_backend = unique_backends_list[0]
-            with self.assertRaises(QiskitBackendNotFoundError):
-                service.backend(unique_backend, instance=hgp_1)
-
     @run_integration_test
     def test_get_backend(self, service):
         """Test getting a backend."""

test/integration/test_backend_serialization.py

@@ -49,21 +49,6 @@ def test_backend_configuration(self, service):
             with self.subTest(backend=backend):
                 self._verify_data(backend.configuration().to_dict(), good_keys, good_keys_prefixes)
 
-    @run_integration_test
-    def test_pulse_defaults(self, service):
-        """Test deserializing backend configuration."""
-        instance = self.dependencies.instance if service.channel == "ibm_quantum" else None
-        backends = service.backends(operational=True, open_pulse=True, instance=instance)
-        if not backends:
-            self.skipTest("Need pulse backends.")
-
-        # Known keys that look like a serialized complex number.
-        good_keys = ("cmd_def.qubits", "cmd_def.sequence.ch")
-
-        for backend in backends:
-            with self.subTest(backend=backend):
-                self._verify_data(backend.defaults().to_dict(), good_keys)
-
     @run_integration_test
     def test_backend_properties(self, service):
         """Test deserializing backend properties."""

test/integration/test_basic_server_paths.py

@@ -23,7 +23,7 @@
 )
 
 from ..ibm_test_case import IBMIntegrationJobTestCase
-from ..decorators import run_integration_test, production_only, quantum_only
+from ..decorators import run_integration_test, production_only
 from ..serialization import (
     SerializableClass,
 )
@@ -52,18 +52,6 @@ def test_run_with_simplejson(self, service):
         except ImportError:
             self.assertRaises(ImportError)
 
-    @run_integration_test
-    @quantum_only
-    def test_run_program_log_level(self, service):
-        """Test running with a custom log level."""
-        levels = ["INFO", "ERROR"]
-        for level in levels:
-            with self.subTest(level=level):
-                job = self._run_program(service, log_level=level)
-                job.wait_for_final_state()
-                if job.logs():
-                    self.assertIn("Completed", job.logs())
-
     @run_integration_test
     @production_only
     def test_cancel_job_queued(self, service):
@@ -156,8 +144,6 @@ def test_wait_for_final_state(self, service):
     @production_only
     def test_run_program_missing_backend_ibm_cloud(self, service):
         """Test running an ibm_cloud program with no backend."""
-        if self.dependencies.channel == "ibm_quantum":
-            self.skipTest("Not supported on ibm_quantum")
         with self.subTest():
             job = self._run_program(service=service, backend="")
             _ = job.status()