def test_retrieve_jobs_between_datetimes_not_overriden(
self, qe_token, qe_url):
"""Test retrieving jobs created between two specified datetimes
and ensure `db_filter` does not override datetime arguments."""
ibmq_factory = IBMQFactory()
provider = ibmq_factory.enable_account(qe_token, qe_url)
backend = provider.get_backend('ibmq_qasm_simulator')
date_today = datetime.now()
past_two_month = date_today - timedelta(30)
past_two_month_str = past_two_month.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
past_three_month = date_today - timedelta(60)
past_three_month_str = past_three_month.strftime(
'%Y-%m-%dT%H:%M:%S.%fZ')
# Used for `db_filter`, should not override `start_datetime` and `end_datetime` arguments.
past_ten_days = date_today - timedelta(10)
job_list = provider.backends.jobs(
backend_name=backend.name(),
limit=5,
skip=0,
start_datetime=past_three_month,
end_datetime=past_two_month,
db_filter={'creationDate': {
'gt': past_ten_days
}})
self.assertTrue(job_list)
for i, job in enumerate(job_list):
self.assertTrue(
(past_three_month_str <= job.creation_date() <=
past_two_month_str), '{}) job creation date {} is not '
'between past three month {} and past two month {}'.format(
i, past_three_month_str, job.creation_date(),
past_two_month_str))
def test_api1_url(self, qe_token, qe_url):
"""Test login into an API 1 auth account."""
with self.assertRaises(IBMQApiUrlError) as context_manager:
ibmq = IBMQFactory()
ibmq.enable_account(qe_token, qe_url)
self.assertIn('authentication URL', str(context_manager.exception))
def _wrapper(obj, *args, **kwargs):
if get_test_options()['skip_online']:
raise SkipTest('Skipping online tests')
if os.getenv('USE_STAGING_CREDENTIALS', ''):
credentials = Credentials(os.getenv('QE_STAGING_TOKEN'),
os.getenv('QE_STAGING_URL'))
backend_name = os.getenv('QE_STAGING_DEVICE', None)
else:
if not get_test_options()['run_slow']:
raise SkipTest('Skipping slow tests')
credentials = _get_credentials()
backend_name = os.getenv('QE_DEVICE', None)
obj.using_ibmq_credentials = credentials.is_ibmq()
ibmq_factory = IBMQFactory()
provider = ibmq_factory.enable_account(credentials.token,
credentials.url)
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)
def setUp(self):
"""Initial test setup."""
super().setUp()
self.factory = IBMQFactory()
self.provider = self._get_provider()
self.credentials = self.provider.credentials
def test_pulse_job(self, qe_token, qe_url):
"""Test running a pulse job."""
factory = IBMQFactory()
factory.enable_account(qe_token, qe_url)
backend = None
for provider in factory.providers():
backends = provider.backends(open_pulse=True)
if backends:
backend = least_busy(backends)
break
self.assertIsNotNone(backend)
config = backend.configuration()
defaults = backend.defaults()
cmd_def = defaults.build_cmd_def()
# Run 2 experiments - 1 with x pulse and 1 without
x = cmd_def.get('x', 0)
measure = cmd_def.get('measure', range(config.n_qubits)) << x.duration
ground_sched = measure
excited_sched = x | measure
schedules = [ground_sched, excited_sched]
qobj = assemble(schedules, backend, meas_level=1, shots=256)
job = backend.run(qobj)
_ = job.result()
class TestIBMQFactoryProvider(IBMQTestCase):
"""Tests for IBMQFactory provider related methods."""
@requires_qe_access
def _get_provider(self, qe_token=None, qe_url=None):
"""Return default provider."""
return self.factory.enable_account(qe_token, qe_url)
def setUp(self):
"""Initial test setup."""
super().setUp()
self.factory = IBMQFactory()
self.provider = self._get_provider()
self.credentials = self.provider.credentials
def test_get_provider(self):
"""Test get single provider."""
provider = self.factory.get_provider(hub=self.credentials.hub,
group=self.credentials.group,
project=self.credentials.project)
self.assertEqual(self.provider, provider)
def test_providers_with_filter(self):
"""Test providers() with a filter."""
provider = self.factory.providers(hub=self.credentials.hub,
group=self.credentials.group,
project=self.credentials.project)[0]
self.assertEqual(self.provider, provider)
def test_providers_no_filter(self):
"""Test providers() without a filter."""
providers = self.factory.providers()
self.assertIn(self.provider, providers)
def test_circuit_random_uniform(self, qe_token, qe_url):
"""Test random_uniform circuit."""
ibmq_factory = IBMQFactory()
provider = ibmq_factory.enable_account(qe_token, qe_url)
results = provider.circuits.random_uniform(number_of_qubits=4)
self.assertIsInstance(results, Result)
def get_provider(ibmq_factory: IBMQFactory,
qe_token: str,
qe_url: str,
default: bool = True) -> AccountProvider:
"""Return a provider for the account.
Args:
ibmq_factory: An `IBMQFactory` instance.
qe_token: IBM Quantum Experience token.
qe_url: IBM Quantum Experience auth URL.
default: If `True`, the default open access project provider is returned.
Otherwise, a non open access project provider is returned.
Returns:
A provider, as specified by `default`.
"""
provider_to_return = ibmq_factory.enable_account(
qe_token, url=qe_url) # Default provider.
if not default:
# Get a non default provider (i.e.not the default open access project).
providers = ibmq_factory.providers()
for provider in providers:
if provider != provider_to_return:
provider_to_return = provider
break
ibmq_factory.disable_account()
return provider_to_return
def _wrapper(obj, *args, **kwargs):
ibmq_factory = IBMQFactory()
qe_token = kwargs.pop('qe_token')
qe_url = kwargs.pop('qe_url')
provider = ibmq_factory.enable_account(qe_token, qe_url)
backend_name = os.getenv('QE_STAGING_DEVICE', None) if \
os.getenv('USE_STAGING_CREDENTIALS', '') else os.getenv('QE_DEVICE', None)
_backend = None
provider = _get_custom_provider(ibmq_factory) or provider
if backend_name:
# Put desired provider as the first in the list.
providers = [provider] + ibmq_factory.providers()
for provider in providers:
backends = provider.backends(name=backend_name)
if backends:
_backend = backends[0]
break
else:
_backend = least_busy(provider.backends(
simulator=False, filters=lambda b: b.configuration().n_qubits >= 5))
if not _backend:
raise Exception("Unable to find suitable backend.")
kwargs.update({'backend': _backend})
return func(obj, *args, **kwargs)
def test_retrieve_jobs_between_datetimes(self, qe_token, qe_url):
"""Test retrieving jobs created between two specified datetimes."""
ibmq_factory = IBMQFactory()
provider = ibmq_factory.enable_account(qe_token, qe_url)
backend = provider.get_backend('ibmq_qasm_simulator')
date_today = datetime.now()
past_month = date_today - timedelta(30)
past_month_str = past_month.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
past_two_month = date_today - timedelta(60)
past_two_month_str = past_two_month.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
job_list = provider.backends.jobs(backend_name=backend.name(),
limit=5,
skip=0,
start_datetime=past_two_month,
end_datetime=past_month)
self.assertTrue(job_list)
for i, job in enumerate(job_list):
self.assertTrue(
(past_two_month_str <= job.creation_date() <= past_month_str),
'{}) job creation date {} is not '
'between past two month {} and past month {}'.format(
i, past_two_month_str, job.creation_date(),
past_month_str))
def _wrapper(*args, **kwargs):
ibmq_factory = IBMQFactory()
qe_token = kwargs.pop('qe_token')
qe_url = kwargs.pop('qe_url')
provider = ibmq_factory.enable_account(qe_token, qe_url)
kwargs.update({'provider': provider})
return func(*args, **kwargs)
def test_non_auth_url(self):
"""Test login into a non-auth account."""
qe_token = 'invalid'
qe_url = API_URL
with self.assertRaises(IBMQAccountCredentialsInvalidUrl) as context_manager:
ibmq = IBMQFactory()
ibmq.enable_account(qe_token, qe_url)
self.assertIn('authentication URL', str(context_manager.exception))
def test_non_auth_url_with_hub(self):
"""Test login into a non-auth account with h/g/p."""
qe_token = 'invalid'
qe_url = API_URL + '/Hubs/X/Groups/Y/Projects/Z'
with self.assertRaises(IBMQAccountCredentialsInvalidUrl) as context_manager:
ibmq = IBMQFactory()
ibmq.enable_account(qe_token, qe_url)
self.assertIn('authentication URL', str(context_manager.exception))
def _wrapper(*args, **kwargs):
ibmq_factory = IBMQFactory()
qe_token = kwargs.pop('qe_token')
qe_url = kwargs.pop('qe_url')
provider = ibmq_factory.enable_account(qe_token, qe_url)
if os.getenv('QE_HGP', None):
hgp = os.getenv('QE_HGP').split('/')
provider = ibmq_factory.get_provider(hub=hgp[0], group=hgp[1], project=hgp[2])
kwargs.update({'provider': provider})
return func(*args, **kwargs)
def test_pass_unreachable_proxy(self, qe_token, qe_url):
"""Test using an unreachable proxy while enabling an account."""
proxies = {
'urls': {
'http': 'http://*****:*****@127.0.0.1:5678',
'https': 'https://*****:*****@127.0.0.1:5678'
}
}
ibmq = IBMQFactory()
with self.assertRaises(RequestsApiError) as context_manager:
ibmq.enable_account(qe_token, qe_url, proxies=proxies)
self.assertIn('ProxyError', str(context_manager.exception))
def test_api1_get_backend(self, qe_token, qe_url):
"""Test backward compatibility for API 1 get_backend()."""
ibmq = IBMQFactory()
ibmq.enable_account(qe_token, qe_url)
ibmq_provider = IBMQProvider()
ibmq_provider.enable_account(qe_token, qe_url)
backend = ibmq_provider.backends()[0]
with self.assertWarns(DeprecationWarning):
ibmq_backend = ibmq.get_backend(backend.name())
self.assertEqual(backend.name(), ibmq_backend.name())
def test_api1_delete_accounts(self):
"""Test backward compatibility for API 1 delete_accounts()."""
ibmq_provider = IBMQProvider()
ibmq_factory = IBMQFactory()
with custom_qiskitrc():
ibmq_provider.save_account('QISKITRC_TOKEN', url=API1_URL)
with self.assertWarns(DeprecationWarning):
ibmq_factory.delete_accounts()
with self.assertWarns(DeprecationWarning):
stored_accounts = ibmq_factory.stored_accounts()
self.assertEqual(len(stored_accounts), 0)
def test_enable_specified_provider(self, qe_token, qe_url):
"""Test enabling an account with a specified provider."""
ibmq = IBMQFactory()
non_default_provider = get_provider(ibmq,
qe_token,
qe_url,
default=False)
enabled_provider = ibmq.enable_account(
token=qe_token,
url=qe_url,
hub=non_default_provider.credentials.hub,
group=non_default_provider.credentials.group,
project=non_default_provider.credentials.project)
self.assertEqual(non_default_provider, enabled_provider)
def test_custom_job_name(self, qe_token, qe_url):
"""Test assigning a custom job name."""
factory = IBMQFactory()
provider = factory.enable_account(qe_token, qe_url)
backend = provider.get_backend('ibmq_qasm_simulator')
qobj = assemble(transpile(self._qc, backend=backend), backend=backend)
# Use a unique job name
job_name = str(time.time()).replace('.', '')
job_id = backend.run(qobj, job_name=job_name).job_id()
job_list = backend.jobs(limit=1, job_name=job_name)
self.assertEqual(len(job_list), 1)
self.assertEqual(job_id, job_list[0].job_id())
def test_api1_backends(self, qe_token, qe_url):
"""Test backward compatibility for API 1 backends()."""
ibmq = IBMQFactory()
ibmq.enable_account(qe_token, qe_url)
ibmq_provider = IBMQProvider()
ibmq_provider.enable_account(qe_token, qe_url)
ibmq_provider_backend_names = [
b.name() for b in ibmq_provider.backends()
]
with self.assertWarns(DeprecationWarning):
ibmq_backend_names = [b.name() for b in ibmq.backends()]
self.assertEqual(set(ibmq_backend_names),
set(ibmq_provider_backend_names))
def test_retrieve_jobs_end_datetime(self, qe_token, qe_url):
"""Test retrieving jobs created before a specified datetime."""
ibmq_factory = IBMQFactory()
provider = ibmq_factory.enable_account(qe_token, qe_url)
backend = provider.get_backend('ibmq_qasm_simulator')
past_month = datetime.now() - timedelta(days=30)
past_month_str = past_month.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
job_list = provider.backends.jobs(backend_name=backend.name(),
limit=5, skip=0, end_datetime=past_month)
self.assertTrue(job_list)
for i, job in enumerate(job_list):
self.assertTrue(job.creation_date() <= past_month_str,
'{}) job creation_date {} is not '
'less than or equal to past month: {}'
.format(i, job.creation_date(), past_month_str))
def test_duplicate_job_name(self, qe_token, qe_url):
"""Test multiple jobs with the same custom job name."""
factory = IBMQFactory()
provider = factory.enable_account(qe_token, qe_url)
backend = provider.get_backend('ibmq_qasm_simulator')
qobj = assemble(transpile(self._qc, backend=backend), backend=backend)
# Use a unique job name
job_name = str(time.time()).replace('.', '')
job_ids = set()
for _ in range(2):
job_ids.add(backend.run(qobj, job_name=job_name).job_id())
retrieved_jobs = backend.jobs(job_name=job_name)
self.assertEqual(len(retrieved_jobs), 2)
retrieved_job_ids = {job.job_id() for job in retrieved_jobs}
self.assertEqual(job_ids, retrieved_job_ids)
def _wrapper(*args, **kwargs):
ibmq_factory = IBMQFactory()
qe_token = kwargs.pop('qe_token')
qe_url = kwargs.pop('qe_url')
# Get the open access project public provider.
public_provider = ibmq_factory.enable_account(qe_token, qe_url)
# Get a premium provider.
premium_provider = _get_custom_provider(ibmq_factory)
if premium_provider is None:
raise SkipTest('Requires both the public provider and a premium provider.')
kwargs.update({
'providers': {'public_provider': public_provider,
'premium_provider': premium_provider}
})
return func(*args, **kwargs)
def _wrapper(*args, **kwargs):
ibmq_factory = IBMQFactory()
qe_token = kwargs.pop("qe_token")
qe_url = kwargs.pop("qe_url")
# Get the open access project public provider.
public_provider = ibmq_factory.enable_account(qe_token, qe_url)
# Get a premium provider.
premium_provider = _get_custom_provider(ibmq_factory)
if premium_provider is None:
raise SkipTest(
"Requires both the public provider and a premium provider.")
kwargs.update({
"providers": {
"public_provider": public_provider,
"premium_provider": premium_provider,
}
})
return func(*args, **kwargs)
def test_api1_disable_accounts(self, qe_token, qe_url):
"""Test backward compatibility for API 1 disable_accounts()."""
ibmq = IBMQFactory()
ibmq.enable_account(qe_token, qe_url)
with warnings.catch_warnings(record=True) as warnings_list:
accounts = ibmq.active_accounts()[0]
self.assertEqual(accounts['token'], qe_token)
self.assertEqual(accounts['url'], qe_url)
ibmq.disable_accounts()
number_of_accounts = len(ibmq.active_accounts())
self.assertEqual(number_of_accounts, 0)
self.assertEqual(len(warnings_list), 3)
for warn in warnings_list:
self.assertTrue(issubclass(warn.category, DeprecationWarning))
def test_enable_twice(self, qe_token, qe_url):
"""Test login into an already logged-in account."""
ibmq = IBMQFactory()
ibmq.enable_account(qe_token, qe_url)
with self.assertRaises(IBMQAccountError) as context_manager:
ibmq.enable_account(qe_token, qe_url)
self.assertIn('already', str(context_manager.exception))
def _get_custom_provider(ibmq_factory: IBMQFactory) -> Optional[AccountProvider]:
"""Find the provider for the specific hub/group/project, if any.
Args:
ibmq_factory: IBMQFactory instance with account already loaded.
Returns:
Custom provider or ``None`` if default is to be used.
"""
hgp = os.getenv('QE_STAGING_HGP', None) if os.getenv('USE_STAGING_CREDENTIALS', '') else \
os.getenv('QE_HGP', None)
if hgp:
hgp = hgp.split('/')
return ibmq_factory.get_provider(hub=hgp[0], group=hgp[1], project=hgp[2])
return None # No custom provider.
def _wrapper(obj, *args, **kwargs):
if get_test_options()['skip_online']:
raise SkipTest('Skipping online tests')
if os.getenv('USE_STAGING_CREDENTIALS', ''):
credentials = Credentials(os.getenv('QE_STAGING_TOKEN'), os.getenv('QE_STAGING_URL'))
backend_name = os.getenv('QE_STAGING_DEVICE', None)
else:
if not get_test_options()['run_slow']:
raise SkipTest('Skipping slow tests')
credentials = _get_credentials()
backend_name = os.getenv('QE_DEVICE', None)
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, filters=lambda b: b.configuration().n_qubits >= 5))
if not _backend:
raise Exception("Unable to find suitable backend.")
kwargs.update({'provider': provider})
kwargs.update({'backend': _backend})
return func(obj, *args, **kwargs)
def test_api2_after_api1(self, qe_token, qe_url):
"""Test login into API 2 during an already logged-in API 1 account."""
ibmq = IBMQFactory()
ibmq.enable_account(qe_token, qe_url)
with self.assertRaises(IBMQAccountError) as context_manager:
qe_token_api2 = 'invalid'
qe_url_api2 = AUTH_URL
ibmq.enable_account(qe_token_api2, qe_url_api2)
self.assertIn('already', str(context_manager.exception))
def test_enable_twice_invalid(self, qe_token, qe_url):
"""Test login into an invalid account during an already logged-in account."""
ibmq = IBMQFactory()
ibmq.enable_account(qe_token, qe_url)
with self.assertRaises(IBMQAccountError) as context_manager:
qe_token_api1 = 'invalid'
qe_url_api1 = API1_URL
ibmq.enable_account(qe_token_api1, qe_url_api1)
self.assertIn('already', str(context_manager.exception))
