def test_delete_accounts(self):
"""Test deleting an account from disk."""
with custom_qiskitrc(), mock_ibmq_provider():
IBMQ.save_account('QISKITRC_TOKEN')
self.assertEqual(len(read_credentials_from_qiskitrc()), 1)
IBMQ._accounts.clear()
IBMQ.delete_accounts(token='QISKITRC_TOKEN')
self.assertEqual(len(read_credentials_from_qiskitrc()), 0)
def test_delete_all_accounts(self):
"""Test deleting all accounts from disk."""
with custom_qiskitrc(), mock_ibmq_provider():
IBMQ.save_account('QISKITRC_TOKEN')
IBMQ.save_account('QISKITRC_TOKEN',
url=IBMQ_TEMPLATE.format('a', 'b', 'c'))
self.assertEqual(len(read_credentials_from_qiskitrc()), 2)
IBMQ.delete_accounts()
self.assertEqual(len(IBMQ._accounts), 0)
self.assertEqual(len(read_credentials_from_qiskitrc()), 0)
def test_save_preferences(self):
"""Test saving preferences."""
preferences = self._get_pref_dict()
with custom_qiskitrc():
store_preferences(preferences)
_, stored_pref = read_credentials_from_qiskitrc()
self.assertEqual(preferences, stored_pref)
def test_save_account(self):
"""Test saving one account."""
with custom_qiskitrc(), mock_ibmq_provider():
IBMQ.save_account('QISKITRC_TOKEN', url=QE_URL, proxies=PROXIES)
# Compare the session accounts with the ones stored in file.
stored_accounts = read_credentials_from_qiskitrc()
self.assertEqual(len(stored_accounts.keys()), 1)
def test_save_same_value_twice(self):
"""Test saving same value twice."""
pref = self._get_pref_dict(pref_val=True)
with custom_qiskitrc():
store_preferences(pref)
store_preferences(pref)
_, stored_pref = read_credentials_from_qiskitrc()
self.assertEqual(pref, stored_pref)
def test_new_provider_pref(self):
"""Test adding preference for another provider."""
pref1 = self._get_pref_dict()
with custom_qiskitrc():
store_preferences(pref1)
pref2 = self._get_pref_dict('hub2/group2/project2', pref_val=False)
store_preferences(pref2)
_, stored_pref = read_credentials_from_qiskitrc()
self.assertEqual({**pref1, **pref2}, stored_pref)
def test_update_preferences(self):
"""Test updating preferences."""
pref1 = self._get_pref_dict()
with custom_qiskitrc():
store_preferences(pref1)
pref2 = self._get_pref_dict(pref_val=False)
store_preferences(pref2)
_, stored_pref = read_credentials_from_qiskitrc()
self.assertEqual(pref2, stored_pref)
def test_api2_non_auth_credentials(self):
"""Test converting api 2 non auth credentials."""
with custom_qiskitrc():
store_credentials(Credentials('A', url=QE2_URL))
_ = update_credentials(force=True)
# Assert over the stored (updated) credentials.
loaded_accounts, _ = read_credentials_from_qiskitrc()
self.assertCorrectApi2Credentials('A', loaded_accounts)
def test_qe_credentials(self):
"""Test converting QE credentials."""
with custom_qiskitrc():
self.ibmq.save_account('A', url=QE_URL)
_ = update_credentials(force=True)
# Assert over the stored (updated) credentials.
loaded_accounts = read_credentials_from_qiskitrc()
self.assertCorrectApi2Credentials('A', loaded_accounts)
def test_save_duplicate_accounts(self):
"""Test saving the same credentials twice."""
with custom_qiskitrc(), mock_ibmq_provider():
IBMQ.save_account('QISKITRC_TOKEN')
IBMQ.save_account('QISKITRC_TOKEN')
# Compare the session accounts with the ones stored in file.
stored_accounts = read_credentials_from_qiskitrc()
self.assertEqual(len(stored_accounts), 1)
def test_set_preferences(self):
"""Test setting preferences."""
with custom_qiskitrc(), no_envs(CREDENTIAL_ENV_VARS):
self.service.save_preferences(auto_save=True)
self.assertTrue(self.service.preferences['auto_save'])
# Read back from qiskitrc.
_, stored_pref = read_credentials_from_qiskitrc()
self.assertTrue(
stored_pref[self.provider.credentials.unique_id()]['experiment']['auto_save'])
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 test_qconsole_credentials(self):
"""Test converting Qconsole credentials."""
with custom_qiskitrc():
store_credentials(
Credentials('A', url=IBMQ_TEMPLATE.format('a', 'b', 'c')))
_ = update_credentials(force=True)
# Assert over the stored (updated) credentials.
loaded_accounts, _ = read_credentials_from_qiskitrc()
self.assertCorrectApi2Credentials('A', loaded_accounts)
def test_update_preferences_with_credentials(self):
"""Test updating preferences with credentials."""
preferences = self._get_pref_dict()
pref2 = self._get_pref_dict(pref_val=False)
credentials = Credentials('QISKITRC_TOKEN', url=QE2_AUTH_URL)
credentials2 = Credentials('QISKITRC_TOKEN_2', url=QE2_AUTH_URL)
with custom_qiskitrc():
store_preferences(preferences)
store_credentials(credentials)
# Update preferences.
store_preferences(pref2)
stored_cred, stored_pref = read_credentials_from_qiskitrc()
self.assertEqual(pref2, stored_pref)
self.assertEqual(credentials, stored_cred[credentials.unique_id()])
# Update credentials.
store_credentials(credentials2, overwrite=True)
stored_cred, stored_pref = read_credentials_from_qiskitrc()
self.assertEqual(pref2, stored_pref)
self.assertEqual(credentials2,
stored_cred[credentials2.unique_id()])
def test_unknown_credentials(self):
"""Test converting credentials with an unknown URL."""
with custom_qiskitrc():
store_credentials(Credentials('A', url='UNKNOWN_URL'))
credentials = update_credentials(force=True)
# No credentials should be returned nor updated.
self.assertIsNone(credentials)
loaded_accounts, _ = read_credentials_from_qiskitrc()
self.assertEqual(
list(loaded_accounts.values())[0].url, 'UNKNOWN_URL')
def test_remove_credentials(self):
"""Test removing credentials when preferences are set."""
preferences = self._get_pref_dict()
credentials = Credentials('QISKITRC_TOKEN', url=QE2_AUTH_URL)
with custom_qiskitrc():
store_credentials(credentials)
store_preferences(preferences)
configrc.remove_credentials(credentials)
stored_cred, stored_pref = read_credentials_from_qiskitrc()
self.assertEqual(preferences, stored_pref)
self.assertFalse(stored_cred)
def test_save_duplicate_accounts(self):
"""Test saving the same credentials twice."""
with custom_qiskitrc(), mock_ibmq_provider():
IBMQ.save_account('QISKITRC_TOKEN')
with self.assertWarns(UserWarning) as context_manager:
IBMQ.save_account('QISKITRC_TOKEN')
self.assertIn('Set overwrite', str(context_manager.warning))
# Compare the session accounts with the ones stored in file.
stored_accounts = read_credentials_from_qiskitrc()
self.assertEqual(len(stored_accounts), 1)
def test_update_one_of_many_providers(self):
"""Test updating one of many provider preferences."""
pref1 = self._get_pref_dict(pref_val=False)
pref2 = self._get_pref_dict('hub2/group2/project2', pref_val=False)
with custom_qiskitrc():
store_preferences(pref1)
store_preferences(pref2)
pref1 = self._get_pref_dict(pref_val=True)
store_preferences(pref1)
_, stored_pref = read_credentials_from_qiskitrc()
self.assertEqual({**pref1, **pref2}, stored_pref)
def test_enable_multiple_accounts(self):
"""Test enabling multiple accounts, combining QX and IBMQ."""
with custom_qiskitrc(), mock_ibmq_provider():
IBMQ.enable_account('QISKITRC_TOKEN')
IBMQ.enable_account('QISKITRC_TOKEN',
url=IBMQ_TEMPLATE.format('a', 'b', 'c'))
IBMQ.enable_account('QISKITRC_TOKEN',
url=IBMQ_TEMPLATE.format('a', 'b', 'X'))
# Compare the session accounts with the ones stored in file.
loaded_accounts = read_credentials_from_qiskitrc()
self.assertEqual(loaded_accounts, {})
self.assertEqual(len(IBMQ._accounts), 3)
def test_enable_account(self):
"""Test enabling one account."""
with custom_qiskitrc(), mock_ibmq_provider():
IBMQ.enable_account('QISKITRC_TOKEN', url='someurl',
proxies=PROXIES)
# Compare the session accounts with the ones stored in file.
loaded_accounts = read_credentials_from_qiskitrc()
_, provider = list(IBMQ._accounts.items())[0]
self.assertEqual(loaded_accounts, {})
self.assertEqual('QISKITRC_TOKEN', provider.credentials.token)
self.assertEqual('someurl', provider.credentials.url)
self.assertEqual(PROXIES, provider.credentials.proxies)
def save(self):
if self._credentials_changed:
try:
dict = read_credentials_from_qiskitrc()
if dict is not None:
for credentials in dict.values():
remove_credentials(credentials)
except:
self._credentials = OrderedDict()
for credentials in self._credentials.values():
store_credentials(credentials, overwrite=True)
self._credentials_changed = False
def __init__(self):
"""Create CredentialsPreferences object."""
self._credentials_changed = False
self._selected_credentials = None
try:
self._credentials = read_credentials_from_qiskitrc()
if self._credentials is None:
self._credentials = OrderedDict()
except:
self._credentials = OrderedDict()
credentials = list(self._credentials.values())
if len(credentials) > 0:
self._selected_credentials = credentials[0]
def test_proxy_credentials(self):
"""Test converting credentials with proxy values."""
with custom_qiskitrc():
store_credentials(Credentials('A',
url=IBMQ_TEMPLATE.format('a', 'b', 'c'),
proxies=PROXIES))
_ = update_credentials(force=True)
# Assert over the stored (updated) credentials.
loaded_accounts = read_credentials_from_qiskitrc()
self.assertCorrectApi2Credentials('A', loaded_accounts)
# Extra assert on preserving proxies.
credentials = list(loaded_accounts.values())[0]
self.assertEqual(credentials.proxies, PROXIES)
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 test_save_multiple_accounts(self):
"""Test saving several accounts, combining QX and IBMQ"""
with custom_qiskitrc(), mock_ibmq_provider():
IBMQ.save_account('QISKITRC_TOKEN')
IBMQ.save_account('QISKITRC_TOKEN',
url=IBMQ_TEMPLATE.format('a', 'b', 'c'))
IBMQ.save_account('QISKITRC_TOKEN',
IBMQ_TEMPLATE.format('a', 'b', 'X'))
# Compare the session accounts with the ones stored in file.
stored_accounts = read_credentials_from_qiskitrc()
self.assertEqual(len(stored_accounts), 3)
for account_name, provider in IBMQ._accounts.items():
self.assertEqual(provider.credentials,
stored_accounts[account_name])
def test_overwrite_category_keys(self):
"""Test overwriting preference keys in a category."""
pref1 = self._get_pref_dict()
orig_active_pref = copy.deepcopy(configrc._ACTIVE_PREFERENCES)
try:
configrc._ACTIVE_PREFERENCES['experiment'].update({'foo': str})
with custom_qiskitrc():
store_preferences(pref1)
new_cat = self._get_pref_dict(pref_key="foo", pref_val='bar')
store_preferences(new_cat)
_, stored_pref = read_credentials_from_qiskitrc()
key = list(pref1.keys())[0]
pref1[key]['experiment'] = {'foo': 'bar'}
self.assertEqual(pref1, stored_pref)
finally:
configrc._ACTIVE_PREFERENCES = orig_active_pref
def test_new_pref_cat(self):
"""Test adding a new preference category."""
pref1 = self._get_pref_dict()
orig_active_pref = copy.deepcopy(configrc._ACTIVE_PREFERENCES)
try:
configrc._ACTIVE_PREFERENCES.update({'foo': {'bar': str}})
with custom_qiskitrc():
store_preferences(pref1)
new_cat = self._get_pref_dict(cat="foo",
pref_key="bar",
pref_val='foobar')
store_preferences(new_cat)
_, stored_pref = read_credentials_from_qiskitrc()
key = list(pref1.keys())[0]
pref1[key].update(new_cat[key])
self.assertEqual(pref1, stored_pref)
finally:
configrc._ACTIVE_PREFERENCES = orig_active_pref
