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