def test_store_credentials_overwrite(self):
"""Test overwriting qiskitrc credentials."""
credentials = Credentials('QISKITRC_TOKEN', url=QE_URL, hub='HUB')
credentials2 = Credentials('QISKITRC_TOKEN_2', url=QE_URL)
# Use an IBMQProvider instead of a Factory.
provider = IBMQProvider()
with custom_qiskitrc():
store_credentials(credentials)
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
# Attempt overwriting.
with warnings.catch_warnings(record=True) as w:
store_credentials(credentials)
self.assertIn('already present', str(w[0]))
with no_file('Qconfig.py'), no_envs(
CREDENTIAL_ENV_VARS), mock_ibmq_provider():
# Attempt overwriting.
store_credentials(credentials2, overwrite=True)
provider.load_accounts()
# Ensure that the credentials are the overwritten ones - note that the
# 'hub' parameter was removed.
self.assertEqual(len(provider._accounts), 1)
self.assertEqual(
list(provider._accounts.values())[0].credentials.token,
'QISKITRC_TOKEN_2')
def disable_ibmq_account(url, token, proxies):
"""Disable IBMQ account."""
if not has_ibmq():
return
try:
url = url or ''
token = token or ''
proxies = proxies or {}
if url != '' and token != '':
from qiskit import IBMQ
from qiskit.providers.ibmq.credentials import Credentials
credentials = Credentials(token, url, proxies=proxies)
unique_id = credentials.unique_id()
if unique_id in IBMQ._accounts:
del IBMQ._accounts[unique_id]
logger.info("Disabled IBMQ account. Url:'{}' "
"Token:'{}' Proxies:'{}'".format(
url, token, proxies))
else:
logger.info("IBMQ account is not active. Not disabled. "
"Url:'{}' Token:'{}' Proxies:'{}'".format(
url, token, proxies))
except Exception as e:
logger.warning("Failed to disable IBMQ account. Url:'{}' "
"Token:'{}' Proxies:'{}' :{}".format(
url, token, proxies, str(e)))
def test_proxies_param_with_ntlm(self):
"""Test proxies with NTLM credentials."""
urls = {'http': 'localhost:8080', 'https': 'localhost:8080'}
proxies_with_ntlm_dict = {
'urls': urls,
'username_ntlm': 'domain\\username',
'password_ntlm': 'password'
}
ntlm_expected_result = {
'verify': True,
'proxies': urls,
'auth': HttpNtlmAuth('domain\\username', 'password')
}
proxies_with_ntlm_credentials = Credentials(
'dummy_token', 'https://dummy_url', proxies=proxies_with_ntlm_dict)
result = proxies_with_ntlm_credentials.connection_parameters()
# Verify the NTLM credentials.
self.assertEqual(ntlm_expected_result['auth'].username,
result['auth'].username)
self.assertEqual(ntlm_expected_result['auth'].password,
result['auth'].password)
# Remove the HttpNtlmAuth objects for direct comparison of the dicts.
ntlm_expected_result.pop('auth')
result.pop('auth')
self.assertDictEqual(ntlm_expected_result, result)
def select_credentials(self, url):
if url is not None:
credentials = Credentials('', url)
if credentials.unique_id() in self._credentials:
self._selected_credentials = self._credentials[credentials.unique_id()]
return self._selected_credentials
def test_store_credentials_overwrite(self):
"""Test overwriting qiskitrc credentials."""
credentials = Credentials('QISKITRC_TOKEN', url=QE2_AUTH_URL)
credentials2 = Credentials('QISKITRC_TOKEN_2', url=QE2_AUTH_URL)
factory = IBMQFactory()
with custom_qiskitrc():
store_credentials(credentials)
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
# Get the logger for `store_credentials`.
config_rc_logger = logging.getLogger(store_credentials.__module__)
# Attempt overwriting.
with self.assertLogs(logger=config_rc_logger,
level='WARNING') as log_records:
store_credentials(credentials)
self.assertIn('already present', log_records.output[0])
with no_envs(CREDENTIAL_ENV_VARS), mock_ibmq_provider():
# Attempt overwriting.
store_credentials(credentials2, overwrite=True)
factory.load_account()
# Ensure that the credentials are the overwritten ones.
self.assertEqual(factory._credentials, credentials2)
def _read_credentials(self):
"""Read first credential from file and attempt to convert to v2"""
self._credentials = None
try:
credentials = read_credentials_from_qiskitrc()
if credentials:
credentials = list(credentials.values())[0]
if credentials:
if is_directly_updatable(credentials):
self._credentials = Credentials(credentials.token,
QE2_AUTH_URL,
proxies=credentials.proxies,
verify=credentials.verify)
elif credentials.url == QE2_AUTH_URL:
self._credentials = credentials
elif credentials.is_ibmq():
self._credentials = Credentials(credentials.token,
QE2_AUTH_URL,
proxies=credentials.proxies,
verify=credentials.verify)
self._ibmq_dict[IBMQCredentialsPreferences._HUB_KEY] = credentials.hub
self._ibmq_dict[IBMQCredentialsPreferences._GROUP_KEY] = credentials.group
self._ibmq_dict[IBMQCredentialsPreferences._PROJECT_KEY] = credentials.project
else:
# Unknown URL - do not act on it.
logger.debug('The stored account with url "{}" could not be '
'parsed.'.format(credentials.url))
except Exception as ex:
logger.debug("Failed to read IBM credentials: '{}'".format(str(ex)))
def _get_credentials(test_object, test_options):
"""Finds the credentials for a specific test and options.
Args:
test_object (QiskitTestCase): The test object asking for credentials
test_options (dict): Options after QISKIT_TESTS was parsed by
get_test_options.
Returns:
Credentials: set of credentials
Raises:
ImportError: if the
Exception: when the credential could not be set and they are needed
for that set of options
"""
try:
from qiskit.providers.ibmq.credentials import (Credentials,
discover_credentials)
except ImportError:
raise ImportError('qiskit-ibmq-provider could not be found, and is '
'required for mocking or executing online tests.')
dummy_credentials = Credentials(
'dummyapiusersloginWithTokenid01',
'https://quantumexperience.ng.bluemix.net/api')
if test_options['mock_online']:
return dummy_credentials
if os.getenv('USE_ALTERNATE_ENV_CREDENTIALS', ''):
# Special case: instead of using the standard credentials mechanism,
# load them from different environment variables. This assumes they
# will always be in place, as is used by the Travis setup.
return Credentials(os.getenv('IBMQ_TOKEN'), os.getenv('IBMQ_URL'))
else:
# Attempt to read the standard credentials.
discovered_credentials = discover_credentials()
if discovered_credentials:
# Decide which credentials to use for testing.
if len(discovered_credentials) > 1:
try:
# Attempt to use QE credentials.
return discovered_credentials[dummy_credentials.unique_id()]
except KeyError:
pass
# Use the first available credentials.
return list(discovered_credentials.values())[0]
# No user credentials were found.
if test_options['rec']:
raise Exception('Could not locate valid credentials. You need them for '
'recording tests against the remote API.')
test_object.log.warning('No user credentials were detected. '
'Running with mocked data.')
test_options['mock_online'] = True
return dummy_credentials
def enable_ibmq_account(url, token, proxies):
"""
Enable IBMQ account, if not alreay enabled.
"""
if not has_ibmq():
return
try:
url = url or ''
token = token or ''
proxies = proxies or {}
if url != '' and token != '':
from qiskit import IBMQ
from qiskit.providers.ibmq.credentials import Credentials
credentials = Credentials(token, url, proxies=proxies)
unique_id = credentials.unique_id()
if unique_id in IBMQ._accounts:
# disable first any existent previous account with same unique_id and different properties
enabled_credentials = IBMQ._accounts[unique_id].credentials
if enabled_credentials.url != url or enabled_credentials.token != token or enabled_credentials.proxies != proxies:
del IBMQ._accounts[unique_id]
if unique_id not in IBMQ._accounts:
IBMQ.enable_account(token, url=url, proxies=proxies)
logger.info("Enabled IBMQ account. Url:'{}' Token:'{}' "
"Proxies:'{}'".format(url, token, proxies))
except Exception as e:
logger.warning("Failed to enable IBMQ account. Url:'{}' Token:'{}' "
"Proxies:'{}' :{}".format(url, token, proxies, str(e)))
def test_verify_param(self):
"""Test 'verify' arg is acknowledged."""
false_verify_expected_result = {'verify': False}
false_verify_credentials = Credentials('dummy_token',
'https://dummy_url',
verify=False)
result = false_verify_credentials.connection_parameters()
self.assertDictEqual(false_verify_expected_result, result)
def test_proxy_param(self):
"""Test using only proxy urls (no NTLM credentials)."""
urls = {'http': 'localhost:8080', 'https': 'localhost:8080'}
proxies_only_expected_result = {'verify': True, 'proxies': urls}
proxies_only_credentials = Credentials(
'dummy_token', 'https://dummy_url', proxies={'urls': urls})
result = proxies_only_credentials.connection_parameters()
self.assertDictEqual(proxies_only_expected_result, result)
def _mocked_initialize_provider(
self,
credentials: Credentials,
preferences: Optional[Dict] = None
) -> None:
"""Mock ``_initialize_provider()``, just storing the credentials."""
self._credentials = credentials
if preferences:
credentials.preferences = preferences.get(credentials.unique_id(), {})
def set_credentials(self, token, url, proxy_urls=None):
if url is not None and token is not None:
proxies = {} if proxy_urls is None else {'urls': proxy_urls}
credentials = Credentials(token, url, proxies=proxies)
self._credentials[credentials.unique_id()] = credentials
self._credentials_changed = True
return credentials
return None
def test_save_preferences_credentials(self):
"""Test saving both preferences and credentials."""
preferences = self._get_pref_dict()
credentials = Credentials('QISKITRC_TOKEN', url=QE2_AUTH_URL)
with custom_qiskitrc():
store_preferences(preferences)
store_credentials(credentials)
stored_cred, stored_pref = read_credentials_from_qiskitrc()
self.assertEqual(preferences, stored_pref)
self.assertEqual(credentials, stored_cred[credentials.unique_id()])
def remove_credentials(self, url):
if url is not None:
credentials = Credentials('', url)
if credentials.unique_id() in self._credentials:
del self._credentials[credentials.unique_id()]
self._credentials_changed = True
if self._selected_credentials is not None and self._selected_credentials.unique_id() == credentials.unique_id():
self._selected_credentials = None
credentials = list(self._credentials.values())
if len(credentials) > 0:
self._selected_credentials = credentials[0]
def test_proxy_urls_2(self, qe_token, qe_url):
"""Test proxy urls only supported by requests <= 2.26"""
test_urls = [
'http:{}:{}'.format(ADDRESS, PORT)
]
for proxy_url in test_urls:
with self.subTest(proxy_url=proxy_url):
credentials = Credentials(
qe_token, qe_url, proxies={'urls': {'https': proxy_url}})
version_finder = VersionClient(credentials.base_url,
**credentials.connection_parameters())
version_finder.version()
def test_malformed_proxy_param(self):
"""Test input with malformed nesting of the proxies dictionary."""
urls = {'http': 'localhost:8080', 'https': 'localhost:8080'}
malformed_nested_proxies_dict = {'proxies': urls}
malformed_nested_credentials = Credentials(
'dummy_token', 'https://dummy_url',
proxies=malformed_nested_proxies_dict)
# Malformed proxy entries should be ignored.
expected_result = {'verify': True}
result = malformed_nested_credentials.connection_parameters()
self.assertDictEqual(expected_result, result)
def test_qconfig_over_all(self):
"""Test order, with qconfig"""
credentials = Credentials('QISKITRC_TOKEN', url=QE2_AUTH_URL)
with custom_qiskitrc():
# Prepare the credentials: qconfig, env and qiskitrc present
store_credentials(credentials)
with custom_qconfig(b"APItoken='QCONFIG_TOKEN'"),\
custom_envs({'QE_TOKEN': 'ENVIRON_TOKEN'}):
credentials, _ = discover_credentials()
self.assertEqual(len(credentials), 1)
self.assertEqual(list(credentials.values())[0].token, 'QCONFIG_TOKEN')
def test_environ_over_qiskitrc(self):
"""Test order, without qconfig"""
credentials = Credentials('QISKITRC_TOKEN', url=QE_URL)
with custom_qiskitrc():
# Prepare the credentials: both env and qiskitrc present
store_credentials(credentials)
with no_file('Qconfig.py'), custom_envs({'QE_TOKEN': 'ENVIRON_TOKEN',
'QE_URL': 'ENVIRON_URL'}):
credentials = discover_credentials()
self.assertEqual(len(credentials), 1)
self.assertEqual(list(credentials.values())[0].token, 'ENVIRON_TOKEN')
def test_proxy_urls(self, qe_token, qe_url):
"""Test different forms of the proxy urls."""
test_urls = [
'http://{}:{}'.format(ADDRESS, PORT),
'//{}:{}'.format(ADDRESS, PORT),
'http://*****:*****@{}:{}'.format(ADDRESS, PORT)
]
for proxy_url in test_urls:
with self.subTest(proxy_url=proxy_url):
credentials = Credentials(
qe_token, qe_url, proxies={'urls': {'https': proxy_url}})
version_finder = VersionClient(credentials.base_url,
**credentials.connection_parameters())
version_finder.version()
def test_malformed_ntlm_params(self):
"""Test input with malformed NTLM credentials."""
urls = {'http': 'localhost:8080', 'https': 'localhost:8080'}
malformed_ntlm_credentials_dict = {
'urls': urls,
'username_ntlm': 1234,
'password_ntlm': 5678
}
malformed_ntlm_credentials = Credentials(
'dummy_token', 'https://dummy_url',
proxies=malformed_ntlm_credentials_dict)
# Should raise when trying to do username.split('\\', <int>)
# in NTLM credentials due to int not facilitating 'split'.
with self.assertRaises(AttributeError):
_ = malformed_ntlm_credentials.connection_parameters()
def test_environ_over_qiskitrc(self) -> None:
"""Test credential discovery order."""
credentials = Credentials('QISKITRC_TOKEN', url=QE2_AUTH_URL)
with custom_qiskitrc():
# Prepare the credentials: both env and qiskitrc present
store_credentials(credentials)
with custom_envs({
'QE_TOKEN': 'ENVIRON_TOKEN',
'QE_URL': 'ENVIRON_URL'
}):
credentials, _ = discover_credentials()
self.assertEqual(len(credentials), 1)
self.assertEqual(list(credentials.values())[0].token, 'ENVIRON_TOKEN')
def test_multiple_credentials(self):
"""Test converting multiple credentials."""
with custom_qiskitrc():
store_credentials(Credentials('A', url=QE2_AUTH_URL))
store_credentials(
Credentials('B', url=IBMQ_TEMPLATE.format('a', 'b', 'c')))
store_credentials(
Credentials('C', url=IBMQ_TEMPLATE.format('d', 'e', 'f')))
_ = update_credentials(force=True)
# Assert over the stored (updated) credentials.
loaded_accounts, _ = read_credentials_from_qiskitrc()
# We don't assert over the token, as it depends on the order of
# the qiskitrc, which is not guaranteed.
self.assertCorrectApi2Credentials(None, loaded_accounts)
def _get_credentials():
"""Finds the credentials for a specific test and options.
Returns:
Credentials: set of credentials
Raises:
SkipTest: when credentials can't be found
"""
try:
from qiskit.providers.ibmq.credentials import (Credentials,
discover_credentials)
except ImportError:
raise unittest.SkipTest('qiskit-ibmq-provider could not be found, '
'and is required for executing online tests.')
if os.getenv('IBMQ_TOKEN') and os.getenv('IBMQ_URL'):
return Credentials(os.getenv('IBMQ_TOKEN'), os.getenv('IBMQ_URL'))
elif os.getenv('QISKIT_TESTS_USE_CREDENTIALS_FILE'):
# Attempt to read the standard credentials.
discovered_credentials = discover_credentials()
if discovered_credentials:
# Decide which credentials to use for testing.
if len(discovered_credentials) > 1:
raise unittest.SkipTest(
"More than 1 credential set found, use: "
"IBMQ_TOKEN and IBMQ_URL env variables to "
"set credentials explicitly")
# Use the first available credentials.
return list(discovered_credentials.values())[0]
raise unittest.SkipTest(
'No IBMQ credentials found for running the test. This is required for '
'running online tests.')
def _get_credentials():
"""Finds the credentials for a specific test and options.
Returns:
Credentials: set of credentials
Raises:
Exception: when the credential could not be set and they are needed
for that set of options
"""
if os.getenv('USE_ALTERNATE_ENV_CREDENTIALS', ''):
# Special case: instead of using the standard credentials mechanism,
# load them from different environment variables. This assumes they
# will always be in place, as is used by the Travis setup.
return Credentials(os.getenv('IBMQ_TOKEN'), os.getenv('IBMQ_URL'))
# Attempt to read the standard credentials.
discovered_credentials = discover_credentials()
if discovered_credentials:
# Decide which credentials to use for testing.
if len(discovered_credentials) > 1:
try:
# Attempt to use QE credentials.
return discovered_credentials[(None, None, None)]
except KeyError:
pass
# Use the first available credentials.
return list(discovered_credentials.values())[0]
raise Exception('Could not locate valid credentials.') from None
def test_timeout(self):
"""Test timeout during retrieving a job status."""
cred = Credentials(token="", url="", websockets_url=MockWsServer.VALID_WS_URL,
access_token=TOKEN_TIMEOUT)
account_client = AccountClient(cred)
with self.assertRaises(WebsocketTimeoutError):
account_client._job_final_status_websocket("job_id", timeout=2)
def _get_credentials():
"""Finds the credentials for a specific test and options.
Returns:
Credentials: set of credentials
Raises:
Exception: When the credential could not be set and they are needed
for that set of options.
"""
if os.getenv("QISKIT_IBM_USE_STAGING_CREDENTIALS", ""):
# Special case: instead of using the standard credentials mechanism,
# load them from different environment variables. This assumes they
# will always be in place, as is used by the Travis setup.
return Credentials(os.getenv("QISKIT_IBM_STAGING_API_TOKEN"),
os.getenv("QISKIT_IBM_STAGING_API_URL"))
# Attempt to read the standard credentials.
discovered_credentials, _ = discover_credentials()
if discovered_credentials:
# Decide which credentials to use for testing.
if len(discovered_credentials) > 1:
try:
# Attempt to use QE credentials.
return discovered_credentials[(None, None, None)]
except KeyError:
pass
# Use the first available credentials.
return list(discovered_credentials.values())[0]
raise Exception("Unable to locate valid credentials.")
def test_auth2_credentials(self):
"""Test converting already API 2 auth credentials."""
with custom_qiskitrc():
store_credentials(Credentials('A', url=QE2_AUTH_URL))
credentials = update_credentials(force=True)
# No credentials should be returned.
self.assertIsNone(credentials)
def test_websocket_status_queue(self):
"""Test status queue used by websocket client."""
status_queue = RefreshQueue(maxsize=10)
cred = Credentials(token="", url="", websockets_url=MockWsServer.VALID_WS_URL,
access_token=TOKEN_JOB_TRANSITION)
client = WebsocketClient(MockWsServer.VALID_WS_URL, cred, "job_id", status_queue)
client.get_job_status()
self.assertEqual(status_queue.qsize(), 2)
def setUp(self):
"""Initial test setup."""
super().setUp()
provider = mock.MagicMock(spec=AccountProvider)
provider.credentials = Credentials(
token="", url="", services={"runtime": "https://quantum-computing.ibm.com"})
self.runtime = IBMRuntimeService(provider)
self.runtime._api_client = BaseFakeRuntimeClient()
def test_invalid_url(self):
"""Test connecting to an invalid URL."""
ws_url = f"wss://{MockWsServer.WS_IP_ADDRESS}:{MockWsServer.WS_INVALID_PORT}"
cred = Credentials(token="my_token", url="", websockets_url=ws_url)
client = WebsocketClient(ws_url, cred, "job_id")
with self.assertRaises(WebsocketError):
client.get_job_status()
