def test_find_user_when_neither_general_user_nor_doctor(self): test_user_name = "test_user_name" self.es.get_general_user_by_user_name = MagicMock( side_effect=elasticsearch.NotFoundError()) self.es.get_doctor_by_user_name = MagicMock( side_effect=elasticsearch.NotFoundError()) res, is_doctor = self.smfhcp_utils.find_user(test_user_name, self.es) self.es.get_general_user_by_user_name.assert_called_with( test_user_name) self.es.get_doctor_by_user_name.assert_called_with(test_user_name) self.assertIsNone(is_doctor) self.assertIsNone(res)
def test_view_post_post_not_present(self): self.es_dao.get_post_by_id = MagicMock(side_effect=elasticsearch.NotFoundError()) request = self.factory.get('/view_post/1234') request.session = dict() request.session['is_authenticated'] = True response = post.view_post(request, TEST_POST_ID) self.assertEqual(response.status_code, 200)
def test_it_logs_NotFoundErrors(self, es, log): """NotFoundErrors from elasticsearch should be caught and logged.""" es.conn.delete.side_effect = elasticsearch.NotFoundError() index.delete(es, mock.Mock()) assert log.exception.called
def test_get_repository_notfounderror_negative(self): client = Mock() client.snapshot.get_repository.side_effect = elasticsearch.NotFoundError(404,'foo','bar') self.assertRaises( curator.CuratorException, curator.get_repository, client, repository=testvars.repo_name )
def test_get_last_processed_block(events_object, monkeypatch): with patch("elasticsearch.Elasticsearch.get") as mock: mock.side_effect = elasticsearch.NotFoundError("Boom!") assert events_object.get_last_processed_block() == int( os.getenv("BFACTORY_BLOCK")) intended_block = -10 # can not be smaller than start block with patch("elasticsearch.Elasticsearch.get") as mock: mock.return_value = {"_source": {"last_block": intended_block}} assert events_object.get_last_processed_block() == 0 monkeypatch.delenv("BFACTORY_BLOCK") with patch("elasticsearch.Elasticsearch.get") as mock: mock.side_effect = elasticsearch.NotFoundError("Boom!") assert (events_object.get_last_processed_block() == 5 ) # startBlock from address.json for ganache
def test_get_snapshot_notfounderror_negative(self): client = Mock() client.snapshot.get_repository.return_value = testvars.test_repo client.snapshot.get.side_effect = elasticsearch.NotFoundError(404, 'Snapshot not found') self.assertRaises( curator.FailedExecution, curator.get_snapshot, client, repository=testvars.repo_name, snapshot=testvars.snap_name )
def delete_contact(self, name): if (not isinstance(name, str)): raise TypeError("Arguments must be strings") if len(name) > 100: raise Exception("Name field must be less than 100 characters") name = name.lower() if self.has(name): self.es.delete(index=INDEX, doc_type='_doc', id=name) return True raise elasticsearch.NotFoundError( "The contact by that name does not exist in the data store")
def test_create_profile_when_user_not_invited(self): self.dummy_smfhcp_utils.find_user = MagicMock(return_value=(None, False)) self.es_dao.get_doctor_activation_by_email_id = MagicMock(side_effect=elasticsearch.NotFoundError()) post_data = { 'user_name': TEST_USER_NAME, 'email': TEST_EMAIL } request = self.factory.post('/create_profile', post_data) response = auth.create_profile(request) self.dummy_smfhcp_utils.find_user.assert_called_with(TEST_USER_NAME, self.es_dao) self.es_dao.get_doctor_activation_by_email_id.assert_called_with(TEST_EMAIL) self.assertEqual(json.loads(response.content.decode(constants.UTF_8))['message'], constants.EMAIL_DOES_NOT_HAVE_INVITE)
def test_index_general_user_when_custom_user_and_user_does_not_exist(self): body = { "user_name": TEST_USER_NAME, "email": TEST_EMAIL, "password_hash": "test_password_hash" } self.es_dao.search_users_by_email = MagicMock(return_value={ "hits": { "total": { "value": 0 } } }) self.es_dao.get_general_user_by_user_name = MagicMock(side_effect=elasticsearch.NotFoundError()) self.es_dao.get_doctor_by_user_name = MagicMock(side_effect=elasticsearch.NotFoundError()) self.es_dao.index_general_user = MagicMock() response = auth.index_general_user(body) self.assertTrue(response) self.es_dao.search_users_by_email.assert_called_with(TEST_EMAIL) self.es_dao.get_general_user_by_user_name.assert_called_with(TEST_USER_NAME) self.es_dao.get_doctor_by_user_name.assert_called_with(TEST_USER_NAME) self.es_dao.index_general_user.assert_called_with(body)
def test_check_email_existence_when_email_valid_for_invite(self): self.es_dao.search_users_by_email = MagicMock(return_value={ "hits": { "total": { "value": 0 } } }) self.es_dao.get_doctor_activation_by_email_id = MagicMock(side_effect=elasticsearch.NotFoundError()) response = auth.check_email_existence(TEST_EMAIL) self.assertTrue(response[0]) self.assertEqual(response[1], constants.SENT_INVITE) self.es_dao.search_users_by_email.assert_called_with(TEST_EMAIL) self.es_dao.get_doctor_activation_by_email_id.assert_called_with(TEST_EMAIL)
def test_index_when_user_not_present(self): self.es_dao.get_general_user_by_user_name = MagicMock(side_effect=elasticsearch.NotFoundError()) self.es_mapper.map_general_user = MagicMock(return_value={"test": "body"}) request = self.factory.get('/login_info') request.session = dict() request.user = DummyObject() request.user.username = TEST_USER_NAME request.user.email = TEST_EMAIL response = auth.index(request) self.assertEqual(response.status_code, 302) self.assertEqual(response.url, '/') self.es_dao.get_general_user_by_user_name.assert_called_with(TEST_USER_NAME) self.es_mapper.map_general_user.assert_called_with(TEST_USER_NAME, TEST_EMAIL) self.dummy_function.assert_called_with({"test": "body"})
def test_find_user_when_doctor(self): test_user_name = "test_user_name" self.es.get_general_user_by_user_name = MagicMock( side_effect=elasticsearch.NotFoundError()) self.es.get_doctor_by_user_name = MagicMock( return_value={'_source': { "test": "pass" }}) res, is_doctor = self.smfhcp_utils.find_user(test_user_name, self.es) self.es.get_general_user_by_user_name.assert_called_with( test_user_name) self.es.get_doctor_by_user_name.assert_called_with(test_user_name) self.assertTrue(is_doctor) self.assertEqual(res['test'], 'pass')
def test_execute_single_with_http_400(self): import elasticsearch es = None params = None runner = mock.Mock(side_effect=elasticsearch.NotFoundError(404, "not found")) total_ops, total_ops_unit, request_meta_data = driver.execute_single(self.context_managed(runner), es, params) self.assertEqual(0, total_ops) self.assertEqual("ops", total_ops_unit) self.assertEqual({ "http-status": 404, "error-description": "not found", "success": False }, request_meta_data)
def search_contact(self, name): if (not isinstance(name, str)): raise TypeError("Argument must be string") if len(name) > 100: raise Exception("Name field must be less than 100 characters") id_ = name.lower() if self.has(id_): data = self.es.get(index=INDEX, doc_type='_doc', id=id_)['_source'] contact = Contact(name=data['name'].capitalize(), address=data['address'], phone_number=data['phnm'], email_address=data['email']) return contact raise elasticsearch.NotFoundError( "The contact by that name does not exist in the data store")
def update_contact(self, name, address='', phone_number='', email_address=''): if (not isinstance(name, str) or not isinstance(address, str) or not isinstance(phone_number, str)): raise TypeError("Arguments must be strings") if len(name) > 100: raise Exception("Name field must be less than 100 characters") if len(address) > 150: raise Exception("Address field must be less than 150 characters") if len(email_address) > 40: raise Exception("Email address must be less than 40 characters") #according to a quick google search, the longest existing phone numbers are 15 digits long if len(phone_number) > 15: raise Exception("Phone number must be less than 16 characters") id_ = name.lower() if self.has(id_): if address == '': address = self.search_contact(name).address if phone_number == '': phone_number = self.search_contact(name).phone_number if email_address == '': email_address = self.search_contact(name).email_address body = { "script": { "source": "ctx._source.address = params.address; ctx._source.phnm = params.phnm; ctx._source.email = params.email", "lang": "painless", "params": { "address": address, "phnm": phone_number, "email": email_address } } } self.es.update(index=INDEX, doc_type='_doc', id=id_, body=body) return True raise elasticsearch.NotFoundError( "Can't update a contact that doesn't exist! Try using add instaed." )
import elasticsearch from voluptuous import * fake_fail = Exception('Simulated Failure') four_oh_one = elasticsearch.TransportError(401, "simulated error") four_oh_four = elasticsearch.TransportError(404, "simulated error") get_alias_fail = elasticsearch.NotFoundError(404, "simulated error") named_index = 'index_name' named_indices = [ "index-2015.01.01", "index-2015.02.01" ] open_index = {'metadata': {'indices' : { named_index : {'state' : 'open'}}}} closed_index = {'metadata': {'indices' : { named_index : {'state' : 'close'}}}} cat_open_index = [{'status': 'open'}] cat_closed_index = [{'status': 'close'}] open_indices = { 'metadata': { 'indices' : { 'index1' : { 'state' : 'open' }, 'index2' : { 'state' : 'open' }}}} closed_indices = { 'metadata': { 'indices' : { 'index1' : { 'state' : 'close' }, 'index2' : { 'state' : 'close' }}}} named_alias = 'alias_name' alias_retval = { "pre_aliased_index": { "aliases" : { named_alias : { }}}} aliases_retval = { "index1": { "aliases" : { named_alias : { } } }, "index2": { "aliases" : { named_alias : { } } }, } alias_one_add = [{'add': {'alias': 'alias', 'index': 'index_name'}}] alias_one_add_with_extras = [ { 'add': { 'alias': 'alias', 'index': 'index_name', 'filter' : { 'term' : { 'user' : 'kimchy' }} } }] alias_one_rm = [{'remove': {'alias': 'my_alias', 'index': named_index}}]