Allow non default provider in test (#461)

* allow use of non default provider in test

* remove unused import

* rename decorator

* slow_test to slow_test_on_device

* test need not be slow

* bump version

* separate try blocks

Author: jyu00

qiskit/providers/ibmq/VERSION.txt

@@ -1 +1 @@
-0.4.3
+0.4.4rc1

test/decorators.py

@@ -124,7 +124,7 @@ def _wrapper(*args, **kwargs):
     return _wrapper
 
 
-def run_on_device(func):
+def slow_test_on_device(func):
     """Decorator that signals that the test should run on a real or semi-real device.
 
     It involves:
@@ -164,9 +164,21 @@ def _wrapper(obj, *args, **kwargs):
         obj.using_ibmq_credentials = credentials.is_ibmq()
         ibmq_factory = IBMQFactory()
         provider = ibmq_factory.enable_account(credentials.token, credentials.url)
+
+        _backend = None
+        if backend_name:
+            for provider in ibmq_factory.providers():
+                backends = provider.backends(name=backend_name)
+                if backends:
+                    _backend = backends[0]
+                    break
+        else:
+            _backend = least_busy(provider.backends(simulator=False))
+
+        if not _backend:
+            raise Exception("Unable to find suitable backend.")
+
         kwargs.update({'provider': provider})
-        _backend = provider.get_backend(backend_name) if backend_name else \
-            least_busy(provider.backends(simulator=False))
         kwargs.update({'backend': _backend})
 
         return func(obj, *args, **kwargs)

test/ibmq/test_ibmq_job.py

@@ -17,6 +17,7 @@
 import time
 from concurrent import futures
 from datetime import datetime, timedelta
+from unittest import SkipTest
 
 import numpy
 from scipy.stats import chi2_contingency
@@ -28,14 +29,14 @@
 from qiskit.providers.ibmq.exceptions import IBMQBackendError
 from qiskit.providers.ibmq.ibmqfactory import IBMQFactory
 from qiskit.providers.ibmq.job.ibmqjob import IBMQJob
-from qiskit.providers.ibmq.job.exceptions import IBMQJobInvalidStateError
+from qiskit.providers.ibmq.job.exceptions import IBMQJobInvalidStateError, JobError
 from qiskit.test import slow_test
 from qiskit.compiler import assemble, transpile
 from qiskit.result import Result
 
 from ..jobtestcase import JobTestCase
 from ..decorators import (requires_provider, requires_qe_access,
-                          run_on_device, requires_device)
+                          slow_test_on_device, requires_device)
 
 
 class TestIBMQJob(JobTestCase):
@@ -81,9 +82,8 @@ def test_run_simulator(self, provider):
         self.assertGreater(contingency1[1], 0.01)
         self.assertGreater(contingency2[1], 0.01)
 
-    @slow_test
-    @requires_device
-    def test_run_device(self, backend):
+    @slow_test_on_device
+    def test_run_device(self, provider, backend):   # pylint: disable=unused-argument
         """Test running in a real device."""
         qobj = assemble(transpile(self._qc, backend=backend), backend=backend)
         shots = qobj.config.shots
@@ -152,7 +152,7 @@ def test_run_async_simulator(self, provider):
         job_ids = [job.job_id() for job in job_array]
         self.assertEqual(sorted(job_ids), sorted(list(set(job_ids))))
 
-    @run_on_device
+    @slow_test_on_device
     def test_run_async_device(self, provider, backend):  # pylint: disable=unused-argument
         """Test running in a real device asynchronously."""
         self.log.info('submitting to backend %s', backend.name())
@@ -208,7 +208,6 @@ def test_cancel(self, provider):
 
         qobj = assemble(transpile(self._qc, backend=backend), backend=backend)
         job = backend.run(qobj)
-        self.wait_for_initialization(job, timeout=5)
         can_cancel = job.cancel()
         self.assertTrue(can_cancel)
         self.assertTrue(job.status() is JobStatus.CANCELLED)
@@ -234,38 +233,50 @@ def test_retrieve_job(self, provider):
         self.assertEqual(job.result().get_counts(), retrieved_job.result().get_counts())
         self.assertEqual(job.qobj().to_dict(), qobj.to_dict())
 
-    @slow_test
     @requires_device
     @requires_provider
     def test_retrieve_job_uses_appropriate_backend(self, backend, provider):
         """Test that retrieved jobs come from their appropriate backend."""
-        simulator_backend = provider.get_backend('ibmq_qasm_simulator')
-        real_backend = backend
+        backend_1 = backend
+        # Get a second backend.
+        backend_2 = None
+        for backend_2 in provider.backends():
+            if backend_2.status().operational and backend_2.name() != backend_1.name():
+                break
+        if not backend_2:
+            raise SkipTest('Skipping test that requires multiple backends')
 
-        qobj_sim = assemble(
-            transpile(self._qc, backend=simulator_backend), backend=simulator_backend)
-        job_sim = simulator_backend.run(qobj_sim)
+        qobj_1 = assemble(
+            transpile(self._qc, backend=backend_1), backend=backend_1)
+        job_1 = backend_1.run(qobj_1)
 
-        qobj_real = assemble(
-            transpile(self._qc, backend=real_backend), backend=real_backend)
-        job_real = real_backend.run(qobj_real)
+        qobj_2 = assemble(
+            transpile(self._qc, backend=backend_2), backend=backend_2)
+        job_2 = backend_2.run(qobj_2)
 
         # test a retrieved job's backend is the same as the queried backend
-        self.assertEqual(simulator_backend.retrieve_job(job_sim.job_id()).backend().name(),
-                         simulator_backend.name())
-        self.assertEqual(real_backend.retrieve_job(job_real.job_id()).backend().name(),
-                         real_backend.name())
+        self.assertEqual(backend_1.retrieve_job(job_1.job_id()).backend().name(),
+                         backend_1.name())
+        self.assertEqual(backend_2.retrieve_job(job_2.job_id()).backend().name(),
+                         backend_2.name())
 
         # test retrieve requests for jobs that exist on other backends throw errors
         with self.assertWarns(Warning) as context_manager:
             self.assertRaises(IBMQBackendError,
-                              simulator_backend.retrieve_job, job_real.job_id())
+                              backend_1.retrieve_job, job_2.job_id())
         self.assertIn('belongs to', str(context_manager.warning))
         with self.assertWarns(Warning) as context_manager:
             self.assertRaises(IBMQBackendError,
-                              real_backend.retrieve_job, job_sim.job_id())
+                              backend_2.retrieve_job, job_1.job_id())
         self.assertIn('belongs to', str(context_manager.warning))
 
+        # Cleanup
+        for job in [job_1, job_2]:
+            try:
+                job.cancel()
+            except JobError:
+                pass
+
     @requires_provider
     def test_retrieve_job_error(self, provider):
         """Test retrieving an invalid job."""

test/ibmq/test_ibmq_job_attributes.py

@@ -26,7 +26,7 @@
 from qiskit.compiler import assemble, transpile
 
 from ..jobtestcase import JobTestCase
-from ..decorators import requires_provider, run_on_device
+from ..decorators import requires_provider, slow_test_on_device
 
 
 class TestIBMQJobAttributes(JobTestCase):
@@ -55,7 +55,7 @@ def test_get_backend_name(self, provider):
         job = backend.run(qobj)
         self.assertTrue(job.backend().name() == backend.name())
 
-    @run_on_device
+    @slow_test_on_device
     def test_running_job_properties(self, provider, backend):  # pylint: disable=unused-argument
         """Test fetching properties of a running job."""
         qobj = assemble(transpile(self._qc, backend=backend), backend=backend)
@@ -110,7 +110,7 @@ def test_duplicate_job_name(self, provider):
         for job in retrieved_jobs:
             self.assertEqual(job.name(), job_name)
 
-    @run_on_device
+    @slow_test_on_device
     def test_error_message_device(self, provider, backend):  # pylint: disable=unused-argument
         """Test retrieving job error messages from a device backend."""
         qc_new = transpile(self._qc, backend)

test/ibmq/test_ibmq_provider.py

@@ -23,11 +23,11 @@
 from qiskit.providers.ibmq.ibmqfactory import IBMQFactory
 from qiskit.providers.ibmq.ibmqbackend import IBMQSimulator, IBMQBackend
 from qiskit.qobj import QobjHeader
-from qiskit.test import slow_test, providers
+from qiskit.test import providers
 from qiskit.compiler import assemble, transpile
 from qiskit.providers.models.backendproperties import BackendProperties
 
-from ..decorators import requires_qe_access
+from ..decorators import requires_qe_access, slow_test_on_device
 from ..ibmqtestcase import IBMQTestCase
 
 
@@ -119,24 +119,25 @@ def test_qobj_headers_in_result_sims(self):
                 self.assertEqual(result.results[0].header.some_field,
                                  'extra info')
 
-    @slow_test
-    def test_qobj_headers_in_result_devices(self):
+    @slow_test_on_device
+    def test_qobj_headers_in_result_devices(self, provider, backend):
         """Test that the qobj headers are passed onto the results for devices."""
-        backends = self.provider.backends(simulator=False)
+        # pylint: disable=unused-argument
+        backends = provider.backends(simulator=False, filters=lambda b: b.status().operational)
 
         custom_qobj_header = {'x': 1, 'y': [1, 2, 3], 'z': {'a': 4}}
 
-        for backend in backends:
-            with self.subTest(backend=backend):
-                circuits = transpile(self.qc1, backend=backend)
+        for backend_ in backends:
+            with self.subTest(backend=backend_):
+                circuits = transpile(self.qc1, backend=backend_)
 
-                qobj = assemble(circuits, backend=backend)
+                qobj = assemble(circuits, backend=backend_)
                 # Update the Qobj header.
                 qobj.header = QobjHeader.from_dict(custom_qobj_header)
                 # Update the Qobj.experiment header.
                 qobj.experiments[0].header.some_field = 'extra info'
 
-                result = backend.run(qobj).result()
+                result = backend_.run(qobj).result()
                 self.assertEqual(result.header.to_dict(), custom_qobj_header)
                 self.assertEqual(result.results[0].header.some_field,
                                  'extra info')

test/ibmq/websocket/test_websocket_integration.py

@@ -28,7 +28,7 @@
 from qiskit.providers.jobstatus import JobStatus
 
 from ...ibmqtestcase import IBMQTestCase
-from ...decorators import requires_qe_access, run_on_device
+from ...decorators import requires_qe_access, slow_test_on_device
 
 
 class TestWebsocketIntegration(IBMQTestCase):
@@ -66,7 +66,7 @@ def test_websockets_simulator(self):
 
         self.assertEqual(result.status, 'COMPLETED')
 
-    @run_on_device
+    @slow_test_on_device
     def test_websockets_device(self, provider, backend):  # pylint: disable=unused-argument
         """Test checking status of a job via websockets for a device."""
         qc = transpile(self.qc1, backend=backend)