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}}]
