def test_global_resolve(self): """Testing if instantiating with default handle server'works and if a handle is correctly retrieved. """ # Create instance with default server url: inst = RESTHandleClient(HTTPS_verify=self.https_verify) rec = inst.retrieve_handle_record_json(self.handle_global) self.assertIn('handle', rec, 'Response lacks "handle".') self.assertIn('responseCode', rec, 'Response lacks "responseCode".')
def test_modify_handle_value_without_authentication(self): """Test if exception when not authenticated.""" log_new_case("test_modify_handle_value_without_authentication") # Test variables testhandle = self.handle inst_readonly = RESTHandleClient(self.url, HTTPS_verify=self.https_verify) # Run code to be tested + check exception: log_start_test_code() with self.assertRaises(HandleAuthenticationError): inst_readonly.modify_handle_value(testhandle, foo='bar') log_end_test_code()
def test_instantiate_with_credentials_config(self): """Test instantiation of client: No exception if password wrong.""" # Test variables credentials = mock.MagicMock() config_from_cred = {} valuefoo = 'foo/foo/foo/' config_from_cred['REST_API_url_extension'] = valuefoo credentials = pyhandle.clientcredentials.PIDClientCredentials( handle_server_url=self.url, username=self.user, password=self.randompassword, handleowner=self.user, REST_API_url_extension=valuefoo ) self.assertEqual(credentials.get_config()['REST_API_url_extension'],valuefoo, 'Config: '+str(credentials.get_config())) # foo/foo/ from the credentials should override default api/handles/ # Run code to be tested - we expect an exception, as it will try to do a GET on the bogus rest api: with self.assertRaises(GenericHandleError): inst = RESTHandleClient.instantiate_with_credentials( credentials, HTTPS_verify=self.https_verify) # So this code can only be reached if something went wrong: self.assertIsInstance(inst, RESTHandleClient) # Check if foo/foo instead of api/handles was stored as path! serverconn = inst._EUDATHandleClient__handlesystemconnector self.assertIn('/foo/', serverconn._HandleSystemConnector__REST_API_url_extension) self.assertEquals(serverconn._HandleSystemConnector__REST_API_url_extension, valuefoo)
def test_instantiate_with_username_and_password_noindex(self): # Try to ceate client instance with username and password with self.assertRaises(HandleSyntaxError): inst = RESTHandleClient.instantiate_with_username_and_password( 'someurl', 'johndoe', 'passywordy')
def test_instantiate_for_read_an_search(self): """Testing if instantiating with default handle server works. """ # Try to create client instance for search without a search URL: with self.assertRaises(TypeError): inst = RESTHandleClient.instantiate_for_read_and_search( None, 'johndoe', 'passywordy')
def setUp(self): """ For most test, provide a client instance with the user-specified handle server url.""" self.inst = RESTHandleClient( HTTPS_verify=self.https_verify, handle_server_url=self.url, url_extension_REST_API=self.path_to_api) # Before being able to run these tests without write access, # the handle that we use for testing must exist. With this code, # you can create it. You only need to create it once and leave it # on the server, it will not be modified and can be used eternally. if False: # This should always be false!!! Except for creating the # required handle once! self.create_required_test_handles()
def create_required_test_handles(self): # Creating an instance that knows how to write: pw = self.testvalues['password'] inst = RESTHandleClient.instantiate_with_username_and_password( self.testvalues['handle_server_url_write'], self.user, pw, HTTPS_verify=self.https_verify) authstring = pyhandle.utilhandle.create_authentication_string(self.user, pw) headers = { 'Content-Type': 'application/json', 'Authorization': 'Basic '+authstring } list_of_all_entries = [ { "index":100, "type":"HS_ADMIN", "data":{ "format":"admin", "value":{ "handle":"21.T14999/B2HANDLE_INTEGRATION_TESTS", "index":300, "permissions":"011111110011" } } }, { "index":111, "type":"TEST1", "data":"val1" }, { "index":2222, "type":"TEST2", "data":"val2" }, { "index":333, "type":"TEST3", "data":"val3" }, { "index":4, "type":"TEST4", "data":"val4" } ] testhandle = self.handle url = self.testvalues['handle_server_url_write']+self.testvalues['url_extension_REST_API']+testhandle veri = self.https_verify head = headers data = json.dumps({'values':list_of_all_entries}) resp = requests.put(url, data=data, headers=head, verify=veri)
def test_instantiate_wrong_search_url(self): inst = RESTHandleClient.instantiate_for_read_and_search( 'someurl', 'someuser', 'somepassword', reverselookup_baseuri='http://something_random_foo_bar') self.assertIsInstance(inst, RESTHandleClient)
def test_instantiate_with_username_and_password_inexistentuser(self, getpatch): # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response with self.assertRaises(HandleNotFoundException): inst = RESTHandleClient.instantiate_with_username_and_password( 'http://someurl', '100:john/doe', 'passywordy')
def test_instantiate_with_username_and_wrong_password(self): """Test instantiation of client: No exception if password wrong.""" # Create client instance with username and password inst = RESTHandleClient.instantiate_with_username_and_password( self.url, self.user, self.randompassword, HTTPS_verify=self.https_verify) self.assertIsInstance(inst, RESTHandleClient)
def test_instantiate_with_username_and_password_wrongpw(self, getpatch): # Define the replacement for the patched method: mock_response = MockResponse(success=True) getpatch.return_value = mock_response inst = RESTHandleClient.instantiate_with_username_and_password( 'http://someurl', '100:my/testhandle', 'passywordy') self.assertIsInstance(inst, RESTHandleClient)
def test_instantiate_for_read_access(self): """Testing if instantiating with default handle server works and if a handle is correctly retrieved. """ # Create client instance with username and password inst = RESTHandleClient.instantiate_for_read_access(HTTPS_verify=self.https_verify) rec = self.inst.retrieve_handle_record_json(self.handle) self.assertIsInstance(inst, RESTHandleClient) self.assertIn('handle', rec, 'Response lacks "handle".') self.assertIn('responseCode', rec, 'Response lacks "responseCode".')
def test_instantiate_with_username_without_index_and_password(self): """Test instantiation of client: Exception if username has no index.""" testusername_without_index = self.user.split(':')[1] # Run code to be tested + check exception: with self.assertRaises(HandleSyntaxError): # Create client instance with username and password inst = RESTHandleClient.instantiate_with_username_and_password( self.url, testusername_without_index, self.randompassword, HTTPS_verify=self.https_verify)
def test_instantiate_with_nonexistent_username_and_password(self): """Test instantiation of client: Exception if username does not exist.""" testusername_inexistent = '100:'+self.inexistent_handle # Run code to be tested + check exception: with self.assertRaises(HandleNotFoundException): # Create client instance with username and password inst = RESTHandleClient.instantiate_with_username_and_password( self.url, testusername_inexistent, self.randompassword, HTTPS_verify=self.https_verify)
def test_instantiate_with_credentials_inexistentuser(self): """Test instantiation of client: Exception if username does not exist.""" # Test variables testusername_inexistent = '100:'+self.inexistent_handle credentials = pyhandle.clientcredentials.PIDClientCredentials( handle_server_url=self.url, username=testusername_inexistent, password=self.randompassword) # Run code to be tested + check exception: # Create instance with credentials with self.assertRaises(HandleNotFoundException): inst = RESTHandleClient.instantiate_with_credentials(credentials, HTTPS_verify=self.https_verify)
def test_instantiate_with_credentials(self): """Test instantiation of client: No exception if password wrong.""" # Test variables credentials = pyhandle.clientcredentials.PIDClientCredentials( handle_server_url=self.url, username=self.user, password=self.randompassword) # Run code to be tested # Create instance with credentials inst = RESTHandleClient.instantiate_with_credentials( credentials, HTTPS_verify=self.https_verify) # Check desired outcomes self.assertIsInstance(inst, RESTHandleClient)
def test_instantiate_with_credentials_config(self, checkpatch): """Test instantiation of client: No exception if password wrong.""" # Define the replacement for the patched method: mock_response = MockResponse(success=True) checkpatch.return_value = mock_response # Test variables credentials = MockCredentials(restapi='foobar') self.assertEqual(credentials.get_config()['REST_API_url_extension'],'foobar', 'Config: '+str(credentials.get_config())) # Run code to be tested # Create instance with credentials inst = RESTHandleClient.instantiate_with_credentials(credentials) self.assertIsInstance(inst, RESTHandleClient)
def test_instantiate_with_credentials_inexistentuser(self, getpatch): """Test instantiation of client: Exception if username does not exist.""" # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Test variables testusername_inexistent = '100:john/doe' credentials = pyhandle.clientcredentials.PIDClientCredentials( handle_server_url='some/url', username=testusername_inexistent, password='******') # Run code to be tested + check exception: # Create instance with credentials with self.assertRaises(HandleNotFoundException): inst = RESTHandleClient.instantiate_with_credentials(credentials)
def test_instantiate_with_credentials(self, getpatch): """Test instantiation of client: No exception if password wrong.""" # Define the replacement for the patched method: mock_response = MockResponse(success=True) getpatch.return_value = mock_response # Test variables credentials = pyhandle.clientcredentials.PIDClientCredentials( handle_server_url='some/url', username='******', password='******') # Run code to be tested # Create instance with credentials inst = RESTHandleClient.instantiate_with_credentials(credentials) # Check desired outcomes self.assertIsInstance(inst, RESTHandleClient)
def test_instantiate_with_credentials_config_override(self, getpatch, checkpatch): """Test instantiation of client: We pass a config value in the credentials and also as an arg in the instantiation. We want the latter to override the first one. """ # Define the replacement for the patched method: # We pretend the username exists! mock_response = MockResponse(success=True) checkpatch.return_value = mock_response # Define the replacement for the patched GET: cont = {"responseCode":1,"handle":"my/testhandle","values":[{"index":111,"type":"TEST1","data":{"format":"string","value":"val1"},"ttl":86400,"timestamp":"2015-09-30T15:08:49Z"},{"index":2222,"type":"TEST2","data":{"format":"string","value":"val2"},"ttl":86400,"timestamp":"2015-09-30T15:08:49Z"},{"index":333,"type":"TEST3","data":{"format":"string","value":"val3"},"ttl":86400,"timestamp":"2015-09-30T15:08:49Z"},{"index":4,"type":"TEST4","data":{"format":"string","value":"val4"},"ttl":86400,"timestamp":"2015-09-30T15:08:49Z"}]} mock_response = MockResponse(success=True, content=json.dumps(cont)) getpatch.return_value = mock_response # Test variables # Passing mock credentials, give them the value "foobar", which # should be overridden! credentials = MockCredentials(restapi='foobar') self.assertEqual(credentials.get_config()['REST_API_url_extension'],'foobar', 'Config: '+str(credentials.get_config())) # Run code to be tested # Create instance with credentials. It gets the "REST_API_url_extention" # from both the credentials and as a param. inst = RESTHandleClient.instantiate_with_credentials( credentials, REST_API_url_extension='bar/bar/bar') self.assertIsInstance(inst, RESTHandleClient) # How to know now which one was used? # Call a read and check its url! Did it get foobar or barbarbar appended? inst.get_value_from_handle('my/testhandle', 'key') positional_args_passed = getpatch.call_args_list[len(getpatch.call_args_list)-1][0] passed_url = positional_args_passed[0] # Compare with expected URL: self.assertIn('bar/bar/bar',passed_url, 'bar/bar/bar is not specified in the URL '+passed_url)
def test_constructor_with_url(self): """Test constructor with one arg (ill-formatted server URL): No exception raised.""" inst = RESTHandleClient('foo') self.assertIsInstance(inst, RESTHandleClient, 'Not a client instance!')
class RESTHandleClientReadaccessFakedTestCase(unittest.TestCase): '''Testing methods for retrieving values and indices.''' def setUp(self): self.inst = RESTHandleClient() def tearDown(self): pass # get_value_from_handle def test_get_value_from_handle_normal(self): """Test retrieving a specific value from a handle record.""" handlerecord = RECORD handle = RECORD['handle'] val = self.inst.get_value_from_handle(handle, 'TEST1', handlerecord) self.assertEquals(val, 'val1', 'The value of "TEST1" should be "val1".') def test_get_value_from_handle_inexistentvalue(self): """Test retrieving an inexistent value from a handle record.""" handlerecord = RECORD handle = handlerecord['handle'] val = self.inst.get_value_from_handle(handle, 'TEST100', handlerecord) self.assertIsNone(val, 'The value of "TEST100" should be None.') def test_get_value_from_handle_HS_ADMIN(self): """Test retrieving an HS_ADMIN value from a handle record.""" handlerecord = RECORD handle = handlerecord['handle'] val = self.inst.get_value_from_handle(handle, 'HS_ADMIN', handlerecord) self.assertIn('handle', val, 'The HS_ADMIN has no entry "handle".') self.assertIn('index', val, 'The HS_ADMIN has no entry "index".') self.assertIn('permissions', val, 'The HS_ADMIN has no entry "permissions".') syntax_ok = check_handle_syntax(val['handle']) self.assertTrue(syntax_ok, 'The handle in HS_ADMIN is not well-formatted.') self.assertIsInstance(val['index'], (int, long), 'The index of the HS_ADMIN is not an integer.') self.assertEqual( str(val['permissions']).replace('0', '').replace('1', ''), '', 'The permission value in the HS_ADMIN contains not just 0 and 1.') def test_get_value_from_handle_duplicatekey(self): """Test retrieving a value of a duplicate key.""" handlerecord = RECORD handle = handlerecord['handle'] val = self.inst.get_value_from_handle(handle, 'TESTDUP', handlerecord) self.assertIn( val, ("dup1", "dup2"), 'The value of the duplicate key "TESTDUP" should be "dup1" or "dup2".' ) # retrieve_handle_record def test_retrieve_handle_record_normal(self): handlerecord = RECORD handle = handlerecord['handle'] dict_record = self.inst.retrieve_handle_record(handle, handlerecord) self.assertIn('TEST1', dict_record, 'Key "test1" not in handlerecord dictionary!') self.assertIn('TEST2', dict_record, 'Key "test2" not in handlerecord dictionary!') self.assertIn('TESTDUP', dict_record, 'Key "testdup" not in handlerecord dictionary!') self.assertIn('HS_ADMIN', dict_record, 'Key "HS_ADMIN" not in handlerecord dictionary!') self.assertEqual(dict_record['TEST1'], 'val1', 'The value of "TEST1" is not "val1.') self.assertEqual(dict_record['TEST2'], 'val2', 'The value of "TEST2" is not "val2.') self.assertIn( dict_record['TESTDUP'], ("dup1", "dup2"), 'The value of the duplicate key "TESTDUP" should be "dup1" or "dup2".' ) self.assertIn( 'permissions', dict_record['HS_ADMIN'], 'The HS_ADMIN has no permissions: ' + dict_record['HS_ADMIN']) self.assertEqual( len(dict_record), 4, 'The record should have a length of 5 (as the duplicate is ignored.' ) # get_handlerecord_indices_for_key def test_get_indices_for_key_normal(self): """Test getting the indices for a specific key.""" handlerecord = RECORD handle = handlerecord['handle'] indices = self.inst.get_handlerecord_indices_for_key( 'TEST1', handlerecord['values']) self.assertEqual(len(indices), 1, 'There is more or less than 1 index!') self.assertEqual(indices[0], 3, 'The index of "test1" is not 3.') def test_get_indices_for_key_duplicatekey(self): """Test getting the indices for a duplicate key.""" handlerecord = RECORD handle = handlerecord['handle'] indices = self.inst.get_handlerecord_indices_for_key( 'TESTDUP', handlerecord['values']) self.assertEqual(len(indices), 2, 'There is more or less than 2 indices!') self.assertIn(5, indices, '5 is not in indices for key "testdup".') self.assertIn(6, indices, '6 is not in indices for key "testdup".') def test_get_indices_for_key_inexistentkey(self): """Test getting the indices for an inexistent key.""" handlerecord = RECORD handle = handlerecord['handle'] indices = self.inst.get_handlerecord_indices_for_key( 'test100', handlerecord['values']) self.assertEqual(len(indices), 0, 'There is more than 0 index!') self.assertEqual(indices, [], 'Indices should be an empty list!')
class RESTHandleClientSearchNoAccessTestCase(unittest.TestCase): def __init__(self, *args, **kwargs): unittest.TestCase.__init__(self, *args, **kwargs) def setUp(self): self.inst = RESTHandleClient() self.inst._RESTHandleClient__searcher._Searcher__has_search_access = True # fake search access self.searcher = Searcher() self.searcher._Searcher__has_search_access = True # Fake search access def tearDown(self): pass def test_search_handle_for_forbiddenkeys(self): with self.assertRaisesRegexp(ReverseLookupException, 'Cannot search for key[.]*'): self.inst.search_handle(url='*dkrz*', checksum='*123*', anotherfield='xyz') def test_search_handle_for_fulltext(self): with self.assertRaisesRegexp( ReverseLookupException, 'Full-text search is not implemented yet[.]*'): self.inst.search_handle(url='*dkrz*', checksum='*123*', searchterms=['searchterm1', 'searchterm2']) def test_search_handle_noterms(self): with self.assertRaisesRegexp( ReverseLookupException, 'No search terms have been specified[.]*'): self.inst.search_handle() def test_create_revlookup_query_fulltext(self): with self.assertRaisesRegexp( ReverseLookupException, 'Full-text search is not implemented yet[.]*'): self.searcher.create_revlookup_query('foo', 'bar') def test_create_revlookup_query_forbiddenkeys(self): with self.assertRaisesRegexp(ReverseLookupException, 'Cannot search for key[.]*'): self.searcher.create_revlookup_query(foo='foo', bar='bar') def test_create_revlookup_query_noterms(self): with self.assertRaisesRegexp( ReverseLookupException, 'No search terms have been specified[.]*'): self.searcher.create_revlookup_query() def test_create_revlookup_query_norestriction(self): searcher = Searcher(allowed_search_keys=[]) query = searcher.create_revlookup_query(baz='baz') self.assertEqual(query, '?baz=baz', 'The query is: ' + query) def test_create_revlookup_query_normal(self): query = self.searcher.create_revlookup_query(URL='foo') self.assertEqual(query, '?URL=foo', 'The query is: ' + query) def test_create_revlookup_query_normal_checksum(self): query = self.searcher.create_revlookup_query(CHECKSUM='foo') self.assertEqual(query, '?CHECKSUM=foo', 'The query is: ' + query) #def test_create_revlookup_query_normal_checksum_and_url(self): # query = self.searcher.create_revlookup_query(CHECKSUM='foo', URL='bar') # self.assertEqual(query, '?URL=bar&CHECKSUM=foo', # 'The query is: '+query) def test_create_revlookup_query_checksum_and_none_url(self): query = self.searcher.create_revlookup_query(CHECKSUM='foo', URL=None) self.assertEqual(query, '?URL=bar&CHECKSUM=foo', 'The query is: ' + query) def test_create_revlookup_query_checksum_and_none_url(self): query = self.searcher.create_revlookup_query(CHECKSUM='foo', URL=None, something=None) self.assertEqual(query, '?CHECKSUM=foo', 'The query is: ' + query) def test_instantiate_wrong_search_url(self): inst = RESTHandleClient.instantiate_for_read_and_search( 'someurl', 'someuser', 'somepassword', reverselookup_baseuri='http://something_random_foo_bar') self.assertIsInstance(inst, RESTHandleClient)
def setUp(self): self.inst = RESTHandleClient() self.inst._RESTHandleClient__searcher._Searcher__has_search_access = True # fake search access self.searcher = Searcher() self.searcher._Searcher__has_search_access = True # Fake search access
def setUp(self): REQUESTLOGGER.info("\n" + 60 * "*" + "\nsetUp of RESTHandleClientWriteaccessTestCase") self.inst = RESTHandleClient.instantiate_with_username_and_password( self.url, self.user, self.password, HTTPS_verify=self.https_verify, handleowner=self.user) authstring = pyhandle.utilhandle.create_authentication_string( self.user, self.password) self.headers = { 'Content-Type': 'application/json', 'Authorization': 'Basic ' + authstring } list_of_all_entries = [ { "index": 100, "type": "HS_ADMIN", "data": { "format": "admin", "value": { "handle": "21.T14999/B2HANDLE_INTEGRATION_TESTS", "index": 300, "permissions": "011111110011" } } }, { "index": 111, "type": "TEST1", "data": { "format": "string", "value": "val1" } }, { "index": 2222, "type": "TEST2", "data": { "format": "string", "value": "val2" } }, { "index": 333, "type": "TEST3", "data": { "format": "string", "value": "val3" } }, { "index": 4, "type": "TEST4", "data": { "format": "string", "value": "val4" } }, ] testhandle = self.handle url = self.connector.make_handle_URL(testhandle) veri = self.https_verify head = self.headers data = json.dumps({'values': list_of_all_entries}) resp = requests.put(url, data=data, headers=head, verify=veri) log_request_response_to_file('PUT', self.handle, url, head, veri, resp)
class RESTHandleClientReadaccessTestCase(unittest.TestCase): def __init__(self, *args, **kwargs): unittest.TestCase.__init__(self, *args, **kwargs) # Read resources from file: self.testvalues = RESOURCES_FILE # Test values that need to be given by user: self.handle = self.testvalues['handle_for_read_tests'] self.handle_global = self.testvalues['handle_globally_resolvable'] self.user = self.testvalues['user'] # Optional: self.https_verify = True if 'HTTPS_verify' in self.testvalues: self.https_verify = self.testvalues['HTTPS_verify'] self.url = 'http://hdl.handle.net' if 'handle_server_url_read' in self.testvalues.keys(): self.url = self.testvalues['handle_server_url_read'] self.path_to_api = None if 'url_extension_REST_API' in self.testvalues.keys(): self.path_to_api = self.testvalues['url_extension_REST_API'] # Others prefix = self.handle.split('/')[0] self.inexistent_handle = prefix+'/07e1fbf3-2b72-430a-a035-8584d4eada41' self.randompassword = '******' def setUp(self): """ For most test, provide a client instance with the user-specified handle server url.""" self.inst = RESTHandleClient( HTTPS_verify=self.https_verify, handle_server_url=self.url, url_extension_REST_API=self.path_to_api) # Before being able to run these tests without write access, # the handle that we use for testing must exist. With this code, # you can create it. You only need to create it once and leave it # on the server, it will not be modified and can be used eternally. if False: # This should always be false!!! Except for creating the # required handle once! self.create_required_test_handles() def tearDown(self): pass pass def create_required_test_handles(self): # Creating an instance that knows how to write: pw = self.testvalues['password'] inst = RESTHandleClient.instantiate_with_username_and_password( self.testvalues['handle_server_url_write'], self.user, pw, HTTPS_verify=self.https_verify) authstring = pyhandle.utilhandle.create_authentication_string(self.user, pw) headers = { 'Content-Type': 'application/json', 'Authorization': 'Basic '+authstring } list_of_all_entries = [ { "index":100, "type":"HS_ADMIN", "data":{ "format":"admin", "value":{ "handle":"21.T14999/B2HANDLE_INTEGRATION_TESTS", "index":300, "permissions":"011111110011" } } }, { "index":111, "type":"TEST1", "data":"val1" }, { "index":2222, "type":"TEST2", "data":"val2" }, { "index":333, "type":"TEST3", "data":"val3" }, { "index":4, "type":"TEST4", "data":"val4" } ] testhandle = self.handle url = self.testvalues['handle_server_url_write']+self.testvalues['url_extension_REST_API']+testhandle veri = self.https_verify head = headers data = json.dumps({'values':list_of_all_entries}) resp = requests.put(url, data=data, headers=head, verify=veri) # retrieve_handle_record_json def test_retrieve_handle_record_json(self): """Test reading handle record from server.""" rec = self.inst.retrieve_handle_record_json(self.handle) received_type = rec['values'][2]['type'] received_value = rec['values'][2]['data']['value'] self.assertEqual(received_type, 'TEST1', 'The type should be "TEST3" but was "%s" (%s).'% (received_type, self.handle)) self.assertEqual(received_value, 'val1', 'The value should be "val3" but is "%s" (%s).' % (received_value, self.handle)) # get_value_from_handle def test_get_value_from_handle_normal(self): """Test reading existent and inexistent handle value from server.""" val = self.inst.get_value_from_handle(self.handle, 'TEST1') self.assertEqual(val, 'val1', 'Retrieving "TEST1" from %s should lead to "val1", but it lead to "%s"' % (self.handle,val)) def test_get_value_from_handle_inexistent_key(self): val = self.inst.get_value_from_handle(self.handle, 'TEST100') self.assertIsNone(val, 'Retrieving "TEST100" from %s should lead to "None", but it lead to "%s"' % (self.handle,val)) def test_get_value_from_handle_inexistent_record(self): """Test reading handle value from inexistent handle.""" with self.assertRaises(HandleNotFoundException): val = self.inst.get_value_from_handle(self.inexistent_handle, 'anykey') # instantiate def test_instantiate_with_username_and_wrong_password(self): """Test instantiation of client: No exception if password wrong.""" # Create client instance with username and password inst = RESTHandleClient.instantiate_with_username_and_password( self.url, self.user, self.randompassword, HTTPS_verify=self.https_verify) self.assertIsInstance(inst, RESTHandleClient) def test_instantiate_with_username_without_index_and_password(self): """Test instantiation of client: Exception if username has no index.""" testusername_without_index = self.user.split(':')[1] # Run code to be tested + check exception: with self.assertRaises(HandleSyntaxError): # Create client instance with username and password inst = RESTHandleClient.instantiate_with_username_and_password( self.url, testusername_without_index, self.randompassword, HTTPS_verify=self.https_verify) def test_instantiate_with_nonexistent_username_and_password(self): """Test instantiation of client: Exception if username does not exist.""" testusername_inexistent = '100:'+self.inexistent_handle # Run code to be tested + check exception: with self.assertRaises(HandleNotFoundException): # Create client instance with username and password inst = RESTHandleClient.instantiate_with_username_and_password( self.url, testusername_inexistent, self.randompassword, HTTPS_verify=self.https_verify) def test_instantiate_with_credentials(self): """Test instantiation of client: No exception if password wrong.""" # Test variables credentials = pyhandle.clientcredentials.PIDClientCredentials( handle_server_url=self.url, username=self.user, password=self.randompassword) # Run code to be tested # Create instance with credentials inst = RESTHandleClient.instantiate_with_credentials( credentials, HTTPS_verify=self.https_verify) # Check desired outcomes self.assertIsInstance(inst, RESTHandleClient) def test_instantiate_with_credentials_inexistentuser(self): """Test instantiation of client: Exception if username does not exist.""" # Test variables testusername_inexistent = '100:'+self.inexistent_handle credentials = pyhandle.clientcredentials.PIDClientCredentials( handle_server_url=self.url, username=testusername_inexistent, password=self.randompassword) # Run code to be tested + check exception: # Create instance with credentials with self.assertRaises(HandleNotFoundException): inst = RESTHandleClient.instantiate_with_credentials(credentials, HTTPS_verify=self.https_verify) # If the user name has no index, exception is already thrown in credentials creation! #self.assertRaises(HandleSyntaxError, pyhandle.PIDClientCredentials, 'url', 'prefix/suffix', randompassword) def test_instantiate_with_credentials_config_override(self): """Test instantiation of client: No exception if password wrong.""" # Test variables credentials = mock.MagicMock() config_from_cred = {} valuefoo = 'foo/foo/foo/' # passed via credentials valuebar = 'bar/bar/bar' # passed directly to constructor config_from_cred['REST_API_url_extension'] = valuefoo credentials = pyhandle.clientcredentials.PIDClientCredentials( handle_server_url=self.url, username=self.user, password=self.randompassword, handleowner=self.user, REST_API_url_extension=valuefoo ) self.assertEqual(credentials.get_config()['REST_API_url_extension'],valuefoo, 'Config: '+str(credentials.get_config())) # foo/foo/ from the credentials should be overridden by bar/bar/ which is directly passed # Run code to be tested - we expect an exception, as it will try to do a GET on the bogus rest api: with self.assertRaises(GenericHandleError): inst = RESTHandleClient.instantiate_with_credentials( credentials, HTTPS_verify=self.https_verify, REST_API_url_extension=valuebar) # So this code can only be reached if something went wrong: self.assertIsInstance(inst, RESTHandleClient) # Check if bar/bar instead of foo/foo was stored as path! serverconn = inst._EUDATHandleClient__handlesystemconnector self.assertIn('/bar/', serverconn._HandleSystemConnector__REST_API_url_extension) self.assertNotIn('/foo/', serverconn._HandleSystemConnector__REST_API_url_extension) self.assertEquals(serverconn._HandleSystemConnector__REST_API_url_extension, valuebar) def test_instantiate_with_credentials_config(self): """Test instantiation of client: No exception if password wrong.""" # Test variables credentials = mock.MagicMock() config_from_cred = {} valuefoo = 'foo/foo/foo/' config_from_cred['REST_API_url_extension'] = valuefoo credentials = pyhandle.clientcredentials.PIDClientCredentials( handle_server_url=self.url, username=self.user, password=self.randompassword, handleowner=self.user, REST_API_url_extension=valuefoo ) self.assertEqual(credentials.get_config()['REST_API_url_extension'],valuefoo, 'Config: '+str(credentials.get_config())) # foo/foo/ from the credentials should override default api/handles/ # Run code to be tested - we expect an exception, as it will try to do a GET on the bogus rest api: with self.assertRaises(GenericHandleError): inst = RESTHandleClient.instantiate_with_credentials( credentials, HTTPS_verify=self.https_verify) # So this code can only be reached if something went wrong: self.assertIsInstance(inst, RESTHandleClient) # Check if foo/foo instead of api/handles was stored as path! serverconn = inst._EUDATHandleClient__handlesystemconnector self.assertIn('/foo/', serverconn._HandleSystemConnector__REST_API_url_extension) self.assertEquals(serverconn._HandleSystemConnector__REST_API_url_extension, valuefoo) def test_global_resolve(self): """Testing if instantiating with default handle server'works and if a handle is correctly retrieved. """ # Create instance with default server url: inst = RESTHandleClient(HTTPS_verify=self.https_verify) rec = inst.retrieve_handle_record_json(self.handle_global) self.assertIn('handle', rec, 'Response lacks "handle".') self.assertIn('responseCode', rec, 'Response lacks "responseCode".') def test_instantiate_for_read_access(self): """Testing if instantiating with default handle server works and if a handle is correctly retrieved. """ # Create client instance with username and password inst = RESTHandleClient.instantiate_for_read_access(HTTPS_verify=self.https_verify) rec = self.inst.retrieve_handle_record_json(self.handle) self.assertIsInstance(inst, RESTHandleClient) self.assertIn('handle', rec, 'Response lacks "handle".') self.assertIn('responseCode', rec, 'Response lacks "responseCode".')
class RESTHandleClientNoaccessTestCase(unittest.TestCase): def setUp(self): self.inst = RESTHandleClient() def tearDown(self): pass # Init def test_constructor_no_args(self): """Test constructor without args: No exception raised.""" inst = RESTHandleClient() self.assertIsInstance(inst, RESTHandleClient, 'Not a client instance!') def test_constructor_with_url(self): """Test constructor with one arg (well-formatted server URL): No exception raised.""" inst = RESTHandleClient('http://foo.bar') self.assertIsInstance(inst, RESTHandleClient, 'Not a client instance!') def test_constructor_with_url(self): """Test constructor with one arg (ill-formatted server URL): No exception raised.""" inst = RESTHandleClient('foo') self.assertIsInstance(inst, RESTHandleClient, 'Not a client instance!') def test_instantiate_for_read_access(self): """Testing if instantiating with default handle server works. """ # Create client instance with username and password inst = RESTHandleClient.instantiate_for_read_access() self.assertIsInstance(inst, RESTHandleClient) def test_instantiate_for_read_an_search(self): """Testing if instantiating with default handle server works. """ # Try to create client instance for search without a search URL: with self.assertRaises(TypeError): inst = RESTHandleClient.instantiate_for_read_and_search( None, 'johndoe', 'passywordy') def test_instantiate_with_username_and_password_noindex(self): # Try to ceate client instance with username and password with self.assertRaises(HandleSyntaxError): inst = RESTHandleClient.instantiate_with_username_and_password( 'someurl', 'johndoe', 'passywordy') # PID generation def test_generate_PID_name_without_prefix(self): """Test PID generation without prefix.""" uuid = self.inst.generate_PID_name() self.assertFalse('/' in uuid, 'There is a slash in the generated PID, even though no prefix was specified.') def test_generate_PID_name_with_prefix(self): """Test PID generation with prefix.""" prefix = 'aprefix' uuid = self.inst.generate_PID_name(prefix) self.assertTrue(prefix+'/' in uuid, 'The specified prefix is not present in the generated PID.') # Handle syntax def test_check_handle_syntax_normal(self): """Test check handle syntax""" syntax_checked = check_handle_syntax("foo/bar") self.assertTrue(syntax_checked) def test_check_handle_syntax_two_slashes(self): """Handle Syntax: No exception if too many slashes in handle.""" check_handle_syntax("foo/bar/foo") def test_check_handle_syntax_no_slashes(self): """Handle Syntax: Exception if too many slashes in handle.""" with self.assertRaises(HandleSyntaxError): check_handle_syntax("foobar") def test_check_handle_syntax_no_prefix(self): """Handle Syntax: Exception if no prefix.""" with self.assertRaises(HandleSyntaxError): check_handle_syntax("/bar") def test_check_handle_syntax_no_suffix(self): """Handle Syntax: Exception if no suffix.""" with self.assertRaises(HandleSyntaxError): check_handle_syntax("foo/") def test_check_handle_syntax_with_index(self): """Test check handle syntax with index.""" syntax_checked = check_handle_syntax("300:foo/bar") self.assertTrue(syntax_checked, 'The syntax of the handle is not index:prefix/suffix.') def test_check_handle_syntax_none(self): """Test check handle syntax where handle is None""" with self.assertRaises(HandleSyntaxError): syntax_checked = check_handle_syntax(None) def test_check_handle_syntax_with_index_nan(self): """Handle Syntax: Exception if index not a number.""" with self.assertRaises(HandleSyntaxError): check_handle_syntax_with_index("nonumber:foo/bar") def test_check_handle_syntax_with_index_noindex(self): """Handle Syntax: Exception if index not existent.""" with self.assertRaises(HandleSyntaxError): check_handle_syntax_with_index("index/missing") def test_check_handle_syntax_with_index_twocolons(self): """Handle Syntax: Exception if two colons.""" with self.assertRaises(HandleSyntaxError): check_handle_syntax_with_index("too:many:colons") def test_check_handle_syntax_with_index_onlyindex(self): """Handle Syntax: Exception if no prefix and suffix.""" with self.assertRaises(HandleSyntaxError): check_handle_syntax_with_index("onlyindex:") def test_remove_index_from_handle(self): handle_with_index = "300:foo/bar" syntax_checked = check_handle_syntax(handle_with_index) self.assertTrue(syntax_checked, 'Test precondition failed!') index, handle = remove_index_from_handle(handle_with_index) syntax_checked = check_handle_syntax(handle) self.assertTrue(syntax_checked, 'After removing the index, the syntax of the handle should '+\ 'be prefix/suffix.') def test_remove_index_noindex(self): handle_with_index = "foo/bar" syntax_checked = check_handle_syntax(handle_with_index) self.assertTrue(syntax_checked, 'Test precondition failed!') index, handle = remove_index_from_handle(handle_with_index) syntax_checked = check_handle_syntax(handle) self.assertTrue(syntax_checked, 'After removing the index, the syntax of the handle should '+\ 'be prefix/suffix.') def test_remove_index_toomany(self): handle_with_index = "100:100:foo/bar" with self.assertRaises(HandleSyntaxError): index, handle = remove_index_from_handle(handle_with_index) # retrieve handle record (failing before any server access) def test_retrieve_handle_record_json_handlesyntax_wrong(self): """Test exception if handle syntax is wrong (retrieve_handle_record_json).""" with self.assertRaises(HandleSyntaxError): json_record = self.inst.retrieve_handle_record_json('testhandle') def test_retrieve_handle_record_when_handle_is_None(self): """Test error when retrieving a handle record with a None input.""" # Call method and check result: with self.assertRaises(HandleSyntaxError): self.inst.retrieve_handle_record(None) # make_authentication_string def test_create_authentication_string(self): auth = create_authentication_string('100:user/name', 'password123') expected = 'MTAwJTNBdXNlci9uYW1lOnBhc3N3b3JkMTIz' self.assertEquals(expected, auth, 'Authentication string is: '+auth+', but should be: '+expected)
def setUp(self): self.inst = RESTHandleClient()
def test_constructor_no_args(self): """Test constructor without args: No exception raised.""" inst = RESTHandleClient() self.assertIsInstance(inst, RESTHandleClient, 'Not a client instance!')
def test_instantiate_for_read_access(self): """Testing if instantiating with default handle server works. """ # Create client instance with username and password inst = RESTHandleClient.instantiate_for_read_access() self.assertIsInstance(inst, RESTHandleClient)