class EUDATHandleClientReadaccessPatchedTestCase(unittest.TestCase): '''Testing methods that read the 10320/loc entry.''' def setUp(self): self.inst = EUDATHandleClient() def tearDown(self): pass # retrieve_handle_record_json: @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_json_normal(self, getpatch): """Test if retrieve_handle_record_json returns the correct things..""" # Test variables: handlerecord = RECORD expected = json.loads(handlerecord) # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord) getpatch.return_value = mock_response # Call method and check result: received = self.inst.retrieve_handle_record_json(expected['handle']) self.assertEqual(received, expected, 'Unexpected return from handle retrieval.') @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_json_handle_does_not_exist(self, getpatch): """Test return value (None) if handle does not exist (retrieve_handle_record_json).""" # Test variables: testhandle = 'dont/exist' # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: json_record = self.inst.retrieve_handle_record_json(testhandle) self.assertIsNone(json_record, 'The return value should be None if the handle does not exist, not: '+str(json_record)) @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_json_handle_empty(self, getpatch): """Test return value if handle is empty (retrieve_handle_record_json).""" # Test variables: testhandle = 'dont/exist' # Define the replacement for the patched method: mock_response = MockResponse(empty=True) getpatch.return_value = mock_response # Call method and check result: json_record = self.inst.retrieve_handle_record_json(testhandle) self.assertEquals(json_record['responseCode'],200, 'Unexpected return value: '+str(json_record)) @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_json_genericerror(self, getpatch): """Test exception if retrieve_handle_record_json returns a strange HTTP code.""" # Test variables: testhandle = 'dont/exist' # Define the replacement for the patched method: mock_response = MockResponse(status_code=99999) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(GenericHandleError): json_record = self.inst.retrieve_handle_record_json(testhandle) # retrieve_handle_record: #@mock.patch('b2handle.handleclient.EUDATHandleClient._EUDATHandleClient__send_handle_get_request') @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_when_json_not_given(self, getpatch): """Test retrieving a handle record""" # Test variables handlerecord_string = RECORD handlerecord_json = json.loads(handlerecord_string) testhandle = handlerecord_json['handle'] # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: dict_record = self.inst.retrieve_handle_record(testhandle) 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.') @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_when_handle_is_wrong(self, getpatch): """Test error when retrieving a handle record with contradicting inputs.""" # Test variable testhandle = 'something/else' handlerecord_string = RECORD handlerecord_json = json.loads(handlerecord_string) # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(GenericHandleError): self.inst.retrieve_handle_record(testhandle) @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_when_handle_is_None(self, getpatch): """Test error when retrieving a handle record with a None input.""" # Test variable testhandle = None # Call method and check result: with self.assertRaises(HandleSyntaxError): self.inst.retrieve_handle_record(testhandle) @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_when_handle_is_wrong(self, getpatch): """Test error when retrieving a nonexistent handle record.""" # Test variable testhandle = 'who/cares' # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: hrec = self.inst.retrieve_handle_record(testhandle) self.assertIsNone(hrec, 'The handle record for a nonexistent handle should be None!') @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_when_handlerecord_is_None(self, getpatch): """Test error when retrieving a handle record, giving a None type.""" # Test variable handlerecord_string = RECORD handlerecord_json = json.loads(handlerecord_string) testhandle = handlerecord_json['handle'] givenrecord = None # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: dict_record = self.inst.retrieve_handle_record(testhandle, givenrecord) 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_value_from_handle @mock.patch('b2handle.handleclient.requests.Session.get') def test_get_value_from_handle_when_handle_inexistent(self, getpatch): """Test error when retrieving a handle record, giving a None type.""" # Test variables testhandle = 'who/cares' key = 'foo' # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(HandleNotFoundException): self.inst.get_value_from_handle(testhandle, key=key) @mock.patch('b2handle.handleclient.requests.Session.get') def test_is_10320LOC_empty_handle_does_not_exist(self, getpatch): """Test exception""" # Test variables testhandle = 'who/cares' # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(HandleNotFoundException): self.inst.is_10320LOC_empty(testhandle) @mock.patch('b2handle.handleclient.requests.Session.get') def test_is_url_contained_in_10320LOC_handle_does_not_exist(self, getpatch): """Test exception""" # Test variables testhandle = 'who/cares' one_url = 'http://bla' list_of_urls = ['http://bla','http://foo.foo'] # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(HandleNotFoundException): self.inst.is_URL_contained_in_10320LOC(testhandle, url=one_url) with self.assertRaises(HandleNotFoundException): self.inst.is_URL_contained_in_10320LOC(testhandle, url=list_of_urls) # Instantiation @mock.patch('b2handle.handleclient.requests.Session.get') 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 = EUDATHandleClient.instantiate_with_username_and_password( 'http://someurl', '100:my/testhandle', 'passywordy') self.assertIsInstance(inst, EUDATHandleClient) @mock.patch('b2handle.handleclient.requests.Session.get') 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 = EUDATHandleClient.instantiate_with_username_and_password( 'http://someurl', '100:john/doe', 'passywordy') @mock.patch('b2handle.handleclient.requests.Session.get') 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 = b2handle.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 = EUDATHandleClient.instantiate_with_credentials(credentials) # If the user name has no index, exception is already thrown in credentials creation! #self.assertRaises(HandleSyntaxError, b2handle.PIDClientCredentials, 'url', 'prefix/suffix', randompassword) @mock.patch('b2handle.handleclient.requests.Session.get') 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 = b2handle.clientcredentials.PIDClientCredentials( handle_server_url='some/url', username='******', password='******') # Run code to be tested # Create instance with credentials inst = EUDATHandleClient.instantiate_with_credentials(credentials) # Check desired outcomes self.assertIsInstance(inst, EUDATHandleClient) @mock.patch('b2handle.handlesystemconnector.HandleSystemConnector.check_if_username_exists') 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 = EUDATHandleClient.instantiate_with_credentials(credentials) self.assertIsInstance(inst, EUDATHandleClient) @mock.patch('b2handle.handlesystemconnector.HandleSystemConnector.check_if_username_exists') @mock.patch('b2handle.handleclient.requests.Session.get') 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 = EUDATHandleClient.instantiate_with_credentials( credentials, REST_API_url_extension='bar/bar/bar') self.assertIsInstance(inst, EUDATHandleClient) # 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)
class EUDATHandleClientReadaccessPatchedTestCase(unittest.TestCase): '''Testing methods that read the 10320/loc entry.''' def setUp(self): self.inst = EUDATHandleClient() def tearDown(self): pass # retrieve_handle_record_json: @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_json_normal(self, getpatch): """Test if retrieve_handle_record_json returns the correct things..""" # Test variables: handlerecord = RECORD expected = json.loads(handlerecord) # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord) getpatch.return_value = mock_response # Call method and check result: received = self.inst.retrieve_handle_record_json(expected['handle']) self.assertEqual(received, expected, 'Unexpected return from handle retrieval.') @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_json_handle_does_not_exist(self, getpatch): """Test return value (None) if handle does not exist (retrieve_handle_record_json).""" # Test variables: testhandle = 'dont/exist' # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: json_record = self.inst.retrieve_handle_record_json(testhandle) self.assertIsNone( json_record, 'The return value should be None if the handle does not exist, not: ' + str(json_record)) @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_json_handle_empty(self, getpatch): """Test return value if handle is empty (retrieve_handle_record_json).""" # Test variables: testhandle = 'dont/exist' # Define the replacement for the patched method: mock_response = MockResponse(empty=True) getpatch.return_value = mock_response # Call method and check result: json_record = self.inst.retrieve_handle_record_json(testhandle) self.assertEquals(json_record['responseCode'], 200, 'Unexpected return value: ' + str(json_record)) @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_json_genericerror(self, getpatch): """Test exception if retrieve_handle_record_json returns a strange HTTP code.""" # Test variables: testhandle = 'dont/exist' # Define the replacement for the patched method: mock_response = MockResponse(status_code=99999) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(GenericHandleError): json_record = self.inst.retrieve_handle_record_json(testhandle) # retrieve_handle_record: #@mock.patch('b2handle.handleclient.EUDATHandleClient._EUDATHandleClient__send_handle_get_request') @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_when_json_not_given(self, getpatch): """Test retrieving a handle record""" # Test variables handlerecord_string = RECORD handlerecord_json = json.loads(handlerecord_string) testhandle = handlerecord_json['handle'] # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: dict_record = self.inst.retrieve_handle_record(testhandle) 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.' ) @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_when_handle_is_wrong(self, getpatch): """Test error when retrieving a handle record with contradicting inputs.""" # Test variable testhandle = 'something/else' handlerecord_string = RECORD handlerecord_json = json.loads(handlerecord_string) # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(GenericHandleError): self.inst.retrieve_handle_record(testhandle) @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_when_handle_is_None(self, getpatch): """Test error when retrieving a handle record with a None input.""" # Test variable testhandle = None # Call method and check result: with self.assertRaises(HandleSyntaxError): self.inst.retrieve_handle_record(testhandle) @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_when_handle_is_wrong(self, getpatch): """Test error when retrieving a nonexistent handle record.""" # Test variable testhandle = 'who/cares' # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: hrec = self.inst.retrieve_handle_record(testhandle) self.assertIsNone( hrec, 'The handle record for a nonexistent handle should be None!') @mock.patch('b2handle.handleclient.requests.Session.get') def test_retrieve_handle_record_when_handlerecord_is_None(self, getpatch): """Test error when retrieving a handle record, giving a None type.""" # Test variable handlerecord_string = RECORD handlerecord_json = json.loads(handlerecord_string) testhandle = handlerecord_json['handle'] givenrecord = None # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: dict_record = self.inst.retrieve_handle_record(testhandle, givenrecord) 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_value_from_handle @mock.patch('b2handle.handleclient.requests.Session.get') def test_get_value_from_handle_when_handle_inexistent(self, getpatch): """Test error when retrieving a handle record, giving a None type.""" # Test variables testhandle = 'who/cares' key = 'foo' # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(HandleNotFoundException): self.inst.get_value_from_handle(testhandle, key=key) @mock.patch('b2handle.handleclient.requests.Session.get') def test_is_10320LOC_empty_handle_does_not_exist(self, getpatch): """Test exception""" # Test variables testhandle = 'who/cares' # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(HandleNotFoundException): self.inst.is_10320LOC_empty(testhandle) @mock.patch('b2handle.handleclient.requests.Session.get') def test_is_url_contained_in_10320LOC_handle_does_not_exist( self, getpatch): """Test exception""" # Test variables testhandle = 'who/cares' one_url = 'http://bla' list_of_urls = ['http://bla', 'http://foo.foo'] # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(HandleNotFoundException): self.inst.is_URL_contained_in_10320LOC(testhandle, url=one_url) with self.assertRaises(HandleNotFoundException): self.inst.is_URL_contained_in_10320LOC(testhandle, url=list_of_urls) # Instantiation @mock.patch('b2handle.handleclient.requests.Session.get') 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 = EUDATHandleClient.instantiate_with_username_and_password( 'http://someurl', '100:my/testhandle', 'passywordy') self.assertIsInstance(inst, EUDATHandleClient) @mock.patch('b2handle.handleclient.requests.Session.get') 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 = EUDATHandleClient.instantiate_with_username_and_password( 'http://someurl', '100:john/doe', 'passywordy') @mock.patch('b2handle.handleclient.requests.Session.get') 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 = b2handle.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 = EUDATHandleClient.instantiate_with_credentials(credentials) # If the user name has no index, exception is already thrown in credentials creation! #self.assertRaises(HandleSyntaxError, b2handle.PIDClientCredentials, 'url', 'prefix/suffix', randompassword) @mock.patch('b2handle.handleclient.requests.Session.get') 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 = b2handle.clientcredentials.PIDClientCredentials( handle_server_url='some/url', username='******', password='******') # Run code to be tested # Create instance with credentials inst = EUDATHandleClient.instantiate_with_credentials(credentials) # Check desired outcomes self.assertIsInstance(inst, EUDATHandleClient) @mock.patch( 'b2handle.handlesystemconnector.HandleSystemConnector.check_if_username_exists' ) 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 = EUDATHandleClient.instantiate_with_credentials(credentials) self.assertIsInstance(inst, EUDATHandleClient) @mock.patch( 'b2handle.handlesystemconnector.HandleSystemConnector.check_if_username_exists' ) @mock.patch('b2handle.handleclient.requests.Session.get') 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 = EUDATHandleClient.instantiate_with_credentials( credentials, REST_API_url_extension='bar/bar/bar') self.assertIsInstance(inst, EUDATHandleClient) # 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)
class EUDATHandleClientNoaccessTestCase(unittest.TestCase): def setUp(self): self.inst = EUDATHandleClient() def tearDown(self): pass # Init def test_constructor_no_args(self): """Test constructor without args: No exception raised.""" inst = EUDATHandleClient() self.assertIsInstance(inst, EUDATHandleClient, 'Not a client instance!') def test_constructor_with_url(self): """Test constructor with one arg (well-formatted server URL): No exception raised.""" inst = EUDATHandleClient('http://foo.bar') self.assertIsInstance(inst, EUDATHandleClient, 'Not a client instance!') def test_constructor_with_url(self): """Test constructor with one arg (ill-formatted server URL): No exception raised.""" inst = EUDATHandleClient('foo') self.assertIsInstance(inst, EUDATHandleClient, '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 = EUDATHandleClient.instantiate_for_read_access() self.assertIsInstance(inst, EUDATHandleClient) 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 = EUDATHandleClient.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 = EUDATHandleClient.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)
class EUDATHandleClientNoaccessTestCase(unittest.TestCase): def setUp(self): self.inst = EUDATHandleClient() def tearDown(self): pass # Init def test_constructor_no_args(self): """Test constructor without args: No exception raised.""" inst = EUDATHandleClient() self.assertIsInstance(inst, EUDATHandleClient, 'Not a client instance!') def test_constructor_with_url(self): """Test constructor with one arg (well-formatted server URL): No exception raised.""" inst = EUDATHandleClient('http://foo.bar') self.assertIsInstance(inst, EUDATHandleClient, 'Not a client instance!') def test_constructor_with_url(self): """Test constructor with one arg (ill-formatted server URL): No exception raised.""" inst = EUDATHandleClient('foo') self.assertIsInstance(inst, EUDATHandleClient, '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 = EUDATHandleClient.instantiate_for_read_access() self.assertIsInstance(inst, EUDATHandleClient) 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 = EUDATHandleClient.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 = EUDATHandleClient.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)
class EUDATHandleClientReadaccessFakedTestCase(unittest.TestCase): '''Testing methods for retrieving values and indices.''' def setUp(self): self.inst = EUDATHandleClient() 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 = json.load(open('resources/handlerecord_for_reading.json')) handle = handlerecord['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 = json.load(open('resources/handlerecord_for_reading.json')) 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 = json.load(open('resources/handlerecord_for_reading.json')) 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 = self.inst.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 = json.load(open('resources/handlerecord_for_reading.json')) 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 = json.load(open('resources/handlerecord_for_reading.json')) 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 = json.load(open('resources/handlerecord_for_reading.json')) 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 = json.load(open('resources/handlerecord_for_reading.json')) 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 = json.load(open('resources/handlerecord_for_reading.json')) 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!') # is_10320LOC_empty def test_is_10320LOC_empty_notempty(self): """Test if presence of 10320/LOC is detected.""" handlerecord = json.load(open('resources/handlerecord_with_10320LOC.json')) handle = handlerecord['handle'] answer = self.inst.is_10320LOC_empty(handle, handlerecord) self.assertFalse(answer, 'The record contains a 10320/LOC, but the is_empty does not return False.') def test_is_10320LOC_empty_no10320LOC(self): """Test if absence of 10320/LOC is detected.""" handlerecord = json.load(open('resources/handlerecord_without_10320LOC.json')) handle = handlerecord['handle'] answer = self.inst.is_10320LOC_empty(handle, handlerecord) self.assertTrue(answer, 'The record contains no 10320/LOC, but the is_empty does not return True.') def test_is_10320LOC_empty_empty10320LOC(self): """Test if emptiness of 10320/LOC is detected.""" handlerecord = json.load(open('resources/handlerecord_with_empty_10320LOC.json')) handle = handlerecord['handle'] answer = self.inst.is_10320LOC_empty(handle, handlerecord) self.assertTrue(answer, 'The record contains an empty 10320/LOC, but the is_empty does not return True.') # is_URL_contained_in_1302loc def test_is_URL_contained_in_10320LOC_true(self): """Test if presence of URL is found in 10320/LOC.""" handlerecord = json.load(open('resources/handlerecord_with_10320LOC.json')) handle = handlerecord['handle'] answer = self.inst.is_URL_contained_in_10320LOC(handle, 'http://foo.bar', handlerecord) val = self.inst.get_value_from_handle(handle, '10320/LOC', handlerecord) self.assertTrue(answer, 'The URL exists in the 10320/LOC, and still the method does not return True:\n'+str(val)) def test_is_URL_contained_in_10320LOC_false(self): """Test if absence of URL is detected in existing 10320/LOC.""" handlerecord = json.load(open('resources/handlerecord_with_10320LOC.json')) handle = handlerecord['handle'] answer = self.inst.is_URL_contained_in_10320LOC(handle, 'http://bar.bar', handlerecord) self.assertFalse(answer, 'The 10320/LOC does not contain the URL, and still the method does not return False.') def test_is_URL_contained_in_inexistent_10320LOC(self): """Test if absence of URL is detected if 10320/LOC does not exist.""" handlerecord = json.load(open('resources/handlerecord_without_10320LOC.json')) handle = handlerecord['handle'] answer = self.inst.is_URL_contained_in_10320LOC(handle, 'http://whatever.foo', handlerecord) self.assertFalse(answer, 'The 10320/LOC does not exist, and still the method does not return False.') def test_is_URL_contained_in_empty_10320LOC(self): """Test if absence of URL is detected if 10320/LOC is empty.""" handlerecord = json.load(open('resources/handlerecord_with_empty_10320LOC.json')) handle = handlerecord['handle'] answer = self.inst.is_URL_contained_in_10320LOC(handle, 'http://whatever.foo', handlerecord) self.assertFalse(answer, 'The 10320/LOC is empty, and still the method does not return False.')
class EUDATHandleClientReadaccessPatchedTestCase(unittest.TestCase): """Testing methods that read the 10320/loc entry.""" def setUp(self): self.inst = EUDATHandleClient() def tearDown(self): pass # retrieve_handle_record_json: @patch("b2handle.handleclient.requests.get") def test_retrieve_handle_record_json_normal(self, getpatch): """Test if retrieve_handle_record_json returns the correct things..""" # Test variables: handlerecord = open("resources/handlerecord_for_reading.json").read() expected = json.loads(handlerecord) # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord) getpatch.return_value = mock_response # Call method and check result: received = self.inst.retrieve_handle_record_json(expected["handle"]) self.assertEqual(received, expected, "Unexpected return from handle retrieval.") @patch("b2handle.handleclient.requests.get") def test_retrieve_handle_record_json_handle_does_not_exist(self, getpatch): """Test return value (None) if handle does not exist (retrieve_handle_record_json).""" # Test variables: testhandle = "dont/exist" # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: json_record = self.inst.retrieve_handle_record_json(testhandle) self.assertIsNone( json_record, "The return value should be None if the handle does not exist, not: " + str(json_record) ) @patch("b2handle.handleclient.requests.get") def test_retrieve_handle_record_json_handle_empty(self, getpatch): """Test return value if handle is empty (retrieve_handle_record_json).""" # Test variables: testhandle = "dont/exist" # Define the replacement for the patched method: mock_response = MockResponse(empty=True) getpatch.return_value = mock_response # Call method and check result: json_record = self.inst.retrieve_handle_record_json(testhandle) self.assertEquals(json_record["responseCode"], 200, "Unexpected return value: " + str(json_record)) @patch("b2handle.handleclient.requests.get") def test_retrieve_handle_record_json_genericerror(self, getpatch): """Test exception if retrieve_handle_record_json returns a strange HTTP code.""" # Test variables: testhandle = "dont/exist" # Define the replacement for the patched method: mock_response = MockResponse(status_code=99999) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(GenericHandleError): json_record = self.inst.retrieve_handle_record_json(testhandle) # retrieve_handle_record: # @patch('b2handle.handleclient.EUDATHandleClient._EUDATHandleClient__send_handle_get_request') @patch("b2handle.handleclient.requests.get") def test_retrieve_handle_record_when_json_not_given(self, getpatch): """Test retrieving a handle record""" # Test variables handlerecord_string = open("resources/handlerecord_for_reading.json").read() handlerecord_json = json.loads(handlerecord_string) testhandle = handlerecord_json["handle"] # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: dict_record = self.inst.retrieve_handle_record(testhandle) 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.") @patch("b2handle.handleclient.requests.get") def test_retrieve_handle_record_when_handle_is_wrong(self, getpatch): """Test error when retrieving a handle record with contradicting inputs.""" # Test variable testhandle = "something/else" handlerecord_string = open("resources/handlerecord_for_reading.json").read() handlerecord_json = json.loads(handlerecord_string) # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(GenericHandleError): self.inst.retrieve_handle_record(testhandle) @patch("b2handle.handleclient.requests.get") def test_retrieve_handle_record_when_handle_is_None(self, getpatch): """Test error when retrieving a handle record with a None input.""" # Test variable testhandle = None # Call method and check result: with self.assertRaises(HandleSyntaxError): self.inst.retrieve_handle_record(testhandle) @patch("b2handle.handleclient.requests.get") def test_retrieve_handle_record_when_handle_is_wrong(self, getpatch): """Test error when retrieving a nonexistent handle record.""" # Test variable testhandle = "who/cares" # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: hrec = self.inst.retrieve_handle_record(testhandle) self.assertIsNone(hrec, "The handle record for a nonexistent handle should be None!") @patch("b2handle.handleclient.requests.get") def test_retrieve_handle_record_when_handlerecord_is_None(self, getpatch): """Test error when retrieving a handle record, giving a None type.""" # Test variable handlerecord_string = open("resources/handlerecord_for_reading.json").read() handlerecord_json = json.loads(handlerecord_string) testhandle = handlerecord_json["handle"] givenrecord = None # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: dict_record = self.inst.retrieve_handle_record(testhandle, givenrecord) 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_value_from_handle @patch("b2handle.handleclient.requests.get") def test_get_value_from_handle_when_handle_inexistent(self, getpatch): """Test error when retrieving a handle record, giving a None type.""" # Test variables testhandle = "who/cares" key = "foo" # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(HandleNotFoundException): self.inst.get_value_from_handle(testhandle, key=key) # check if username exists @patch("b2handle.handleclient.requests.get") def test_check_if_username_exists_normal(self, getpatch): """Test whether username exists.""" # Test variables handlerecord_string = open("resources/handlerecord_for_reading.json").read() handlerecord_json = json.loads(handlerecord_string) testhandle = "100:" + handlerecord_json["handle"] # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: res = self.inst.check_if_username_exists(testhandle) self.assertTrue(res, 'The handle exists, so "check_if_username_exists" should return true!') @patch("b2handle.handleclient.requests.get") def test_check_if_username_exists_inconsistent_info(self, getpatch): """Test exception when contradictory inputs are given.""" # Test variables handlerecord_string = open("resources/handlerecord_for_reading.json").read() testhandle = "who/cares" # Define the replacement for the patched method: mock_response = MockResponse(success=True, content=handlerecord_string) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(GenericHandleError): self.inst.check_if_username_exists(testhandle) @patch("b2handle.handleclient.requests.get") def test_check_if_username_exists_it_doesnot(self, getpatch): """Test exception""" # Test variables testhandle = "who/cares" # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(HandleNotFoundException): self.inst.check_if_username_exists(testhandle) @patch("b2handle.handleclient.requests.get") def test_is_10320LOC_empty_handle_does_not_exist(self, getpatch): """Test exception""" # Test variables testhandle = "who/cares" # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(HandleNotFoundException): self.inst.is_10320LOC_empty(testhandle) @patch("b2handle.handleclient.requests.get") def test_is_url_contained_in_10320LOC_handle_does_not_exist(self, getpatch): """Test exception""" # Test variables testhandle = "who/cares" one_url = "http://bla" list_of_urls = ["http://bla", "http://foo.foo"] # Define the replacement for the patched method: mock_response = MockResponse(notfound=True) getpatch.return_value = mock_response # Call method and check result: with self.assertRaises(HandleNotFoundException): self.inst.is_URL_contained_in_10320LOC(testhandle, url=one_url) with self.assertRaises(HandleNotFoundException): self.inst.is_URL_contained_in_10320LOC(testhandle, url=list_of_urls) # Instantiation @patch("b2handle.handleclient.requests.get") 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 = EUDATHandleClient.instantiate_with_username_and_password( "http://someurl", "100:my/testhandle", "passywordy" ) self.assertIsInstance(inst, EUDATHandleClient) @patch("b2handle.handleclient.requests.get") 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 = EUDATHandleClient.instantiate_with_username_and_password( "http://someurl", "100:john/doe", "passywordy" ) @patch("b2handle.handleclient.requests.get") 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 = b2handle.clientcredentials.PIDClientCredentials( "some/url", testusername_inexistent, "some_password" ) # Run code to be tested + check exception: # Create instance with credentials with self.assertRaises(HandleNotFoundException): inst = EUDATHandleClient.instantiate_with_credentials(credentials) # If the user name has no index, exception is already thrown in credentials creation! # self.assertRaises(HandleSyntaxError, b2handle.PIDClientCredentials, 'url', 'prefix/suffix', randompassword) @patch("b2handle.handleclient.requests.get") 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 = b2handle.clientcredentials.PIDClientCredentials( "some/url", "100:my/testhandle", "some_password_123" ) # Run code to be tested # Create instance with credentials inst = EUDATHandleClient.instantiate_with_credentials(credentials) # Check desired outcomes self.assertIsInstance(inst, EUDATHandleClient) @patch("b2handle.handleclient.EUDATHandleClient.check_if_username_exists") 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 = EUDATHandleClient.instantiate_with_credentials(credentials) self.assertIsInstance(inst, EUDATHandleClient) @patch("b2handle.handleclient.EUDATHandleClient.check_if_username_exists") @patch("b2handle.handleclient.requests.get") 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": "test2", "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 = EUDATHandleClient.instantiate_with_credentials(credentials, REST_API_url_extension="bar/bar/bar") self.assertIsInstance(inst, EUDATHandleClient) # 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)