def _create_provd_device(device_id, provd_device):
device_manager = provd_connector.device_manager()
try:
device_manager.update(provd_device)
except Exception as e:
device_manager.remove(device_id)
raise ElementCreationError('device', e)
def test_when_element_creation_error_is_raised(self):
expected_status_code = 400
expected_message = ["Error while creating user: error message"]
exception = ElementCreationError('user', 'error message')
response = make_error_response(exception)
self.assertResponse(response, expected_status_code, expected_message)
def test_create_with_dao_error(self, validate_create, device_dao_create,
notifier_created):
device = Device()
device_dao_create.side_effect = ElementCreationError('Device', '')
self.assertRaises(ElementCreationError, device_services.create, device)
self.assertEquals(notifier_created.call_count, 0)
validate_create.assert_called_once_with(device)
def _create_provd_config(device_id, provd_config):
config_manager = provd_connector.config_manager()
try:
config_manager.add(provd_config)
except Exception as e:
device_manager = provd_connector.device_manager()
device_manager.remove(device_id)
raise ElementCreationError('device', e)
def test_create_with_error_from_dao(self, validate_create, extension_dao_create, extension_notifier_created):
exten = '1000'
context = 'toto'
extension = Extension(exten=exten,
context=context)
error = Exception("message")
extension_dao_create.side_effect = ElementCreationError(error, '')
self.assertRaises(ElementCreationError, extension_services.create, extension)
def create_from_list(session, call_logs):
session.begin()
for call_log in call_logs:
call_log_id = create_call_log(session, call_log)
_link_call_log(session, call_log, call_log_id)
try:
session.commit()
except SQLAlchemyError as e:
session.rollback()
raise ElementCreationError('CallLog', e)
def associate(session, user_line):
session.begin()
try:
user_line_id = _associate_user_line(session, user_line)
except SQLAlchemyError as e:
session.rollback()
raise ElementCreationError('UserLine', e)
user_line.id = user_line_id
return user_line
def test_create_with_error_from_dao(self, voicemail_dao_create, voicemail_notifier_created):
name = 'toto'
number = '4692'
context = 'default'
voicemail = Voicemail(name=name,
number=number,
context=context)
voicemail_dao_create.side_effect = ElementCreationError('voicemail', '')
self.assertRaises(ElementCreationError, voicemail_dao_create, voicemail)
self.assertEquals(voicemail_notifier_created.call_count, 0)
def create(session, voicemail):
voicemail_row = db_converter.to_source(voicemail)
session.begin()
session.add(voicemail_row)
try:
session.commit()
except SQLAlchemyError as e:
session.rollback()
raise ElementCreationError('voicemail', e)
voicemail.id = voicemail_row.uniqueid
return voicemail
def create(session, user):
user_row = db_converter.to_source(user)
user_row.entityid = entity_dao.default_entity_id()
session.begin()
session.add(user_row)
try:
session.commit()
except SQLAlchemyError as e:
session.rollback()
raise ElementCreationError('User', e)
user.id = user_row.id
return user
def test_create_with_error_from_dao(self, line_dao_create, make_provisioning_id):
name = 'line'
context = 'toto'
secret = '1234'
line = LineSIP(name=name,
context=context,
username=name,
secret=secret,
device_slot=1)
error = Exception("message")
line_dao_create.side_effect = ElementCreationError(error, '')
self.assertRaises(ElementCreationError, line_services.create, line)
make_provisioning_id.assert_called_with()
def create(session, extension):
extension_row = db_converter.to_source(extension)
extension_row.type = 'user'
extension_row.typeval = '0'
session.begin()
session.add(extension_row)
try:
session.commit()
except SQLAlchemyError as e:
session.rollback()
raise ElementCreationError('Extension', e)
extension.id = extension_row.id
return extension
def generate_device_id():
device_manager = provd_connector.device_manager()
try:
return device_manager.add({})
except Exception as e:
raise ElementCreationError('device', e)