def test_when_exten_changes_but_is_available(self, dao_get,
validate_extension_available):
dao_get.return_value = Extension(exten='1000', context='default')
extension = Extension(id=1, exten='1001', context='default')
validator.validate_extension_available_for_edit(extension)
dao_get.assert_called_once_with(extension.id)
validate_extension_available.assert_called_once_with(extension)
def test_when_exten_does_not_change(self, dao_get,
validate_extension_available):
dao_get.return_value = Extension(exten='1000')
extension = Extension(id=1, exten='1000')
validator.validate_extension_available_for_edit(extension)
dao_get.assert_called_once_with(extension.id)
self.assertNotCalled(validate_extension_available)
def test_create_same_exten_and_context(self):
exten = 'extension'
context = 'toto'
extension = Extension(exten=exten, context=context)
extension_dao.create(extension)
extension = Extension(exten=exten, context=context)
self.assertRaises(ElementCreationError, extension_dao.create,
extension)
def test_list_extensions_with_two_extensions(self, mock_extension_services_search):
extension1 = Extension(id=1, exten='1324', context='default')
extension2 = Extension(id=2, exten='1325', context='default')
expected_response = {'total': 2,
'items': [self.build_item(extension1),
self.build_item(extension2)]}
mock_extension_services_search.return_value = SearchResult(2, [extension1, extension2])
response = self.app.get(BASE_URL)
mock_extension_services_search.assert_any_call()
self.assert_response_for_list(response, expected_response)
def test_commented_is_not_a_boolean(self):
extension = Extension(exten='1000', context='default', commented='lol')
self.assertRaisesRegexp(
InvalidParametersError,
'Invalid parameters: Commented must be a bool',
validator.validate_invalid_parameters, extension)
def test_on_empty_extension_number(self):
extension = Extension(context='toto')
self.assertRaisesRegexp(InvalidParametersError,
'Invalid parameters: Exten required',
validator.validate_invalid_parameters,
extension)
def _create_extensions(channel, extensions):
from xivo_dao.data_handler.extension import services as extension_services
from xivo_dao.data_handler.extension.model import Extension
for extinfo in extensions:
extension = Extension(**extinfo)
extension_services.create(extension)
def test_on_empty_context(self):
extension = Extension(exten='1000')
self.assertRaisesRegexp(InvalidParametersError,
'Invalid parameters: Context required',
validator.validate_invalid_parameters,
extension)
def test_is_extension_valid_for_context_range_when_extension_is_alphanumeric(self, context_ranges):
extension = Extension(exten='ABC123',
context='default')
self.assertRaises(InvalidParametersError,
context_services.is_extension_valid_for_context_range,
extension,
ContextRangeType.users)
def test_validate_context_exists_when_context_exists(self, find_by_name):
find_by_name.return_value = Mock()
extension = Extension(exten='1000', context='default')
validator.validate_context_exists(extension)
find_by_name.assert_called_once_with(extension.context)
def test_build_line_for_device_with_a_sip_line_with_proxy_backup(
self, config_manager, find_by_line_id, extension_dao_get):
username = '******'
secret = 'password'
exten = '1250'
context = 'default'
display_name = 'Francis Dagobert'
callerid = '"%s" <%s>' % (display_name, exten)
proxy_ip = '10.39.5.1'
registrar_ip = proxy_ip
proxy_backup = '10.39.5.2'
configregistrar = 'default'
line = LineSIP(id=1,
device_slot=1,
context=context,
username=username,
name=username,
secret=secret,
callerid=callerid,
configregistrar=configregistrar)
device = Device(id=self.device_id)
provd_base_config = {"raw_config": {}}
config_registrar_dict = self._give_me_a_provd_configregistrar(
proxy_ip, proxy_backup)
config_manager().get.side_effect = (provd_base_config,
config_registrar_dict)
find_by_line_id.return_value = LineExtension(line_id=line.id,
extension_id=3)
extension_dao_get.return_value = Extension(exten=exten,
context=context)
expected_arg = {
"raw_config": {
"sip_lines": {
"1": {
'username': username,
'auth_username': username,
'display_name': display_name,
'number': exten,
'password': secret,
'proxy_ip': proxy_ip,
'registrar_ip': registrar_ip,
'backup_registrar_ip': proxy_backup,
'backup_proxy_ip': proxy_backup
}
}
}
}
device_services.build_line_for_device(device, line)
config_manager().get.assert_any_call(self.device_id)
config_manager().get.assert_any_call(configregistrar)
config_manager().update.assert_called_with(expected_arg)
def test_validate_extension_in_range_when_extension_inside_of_range(
self, is_extension_valid_for_context):
is_extension_valid_for_context.return_value = True
extension = Extension(exten='1000', context='default')
validator.validate_extension_in_range(extension)
is_extension_valid_for_context.assert_called_once_with(extension)
def test_find_by_exten_context(self, find_by_exten_context):
expected = Extension(exten='1000', context='default')
find_by_exten_context.return_value = expected
result = extension_services.find_by_exten_context(expected.exten, expected.context)
find_by_exten_context.assert_called_once_with(expected.exten, expected.context)
assert_that(result, equal_to(expected))
def test_validate_context_exists_when_context_does_not_exist(
self, find_by_name):
find_by_name.return_value = None
extension = Extension(exten='1000', context='default')
self.assertRaises(NonexistentParametersError,
validator.validate_context_exists, extension)
find_by_name.assert_called_once_with(extension.context)
def test_validate_extension_in_range_when_extension_outside_of_range(
self, is_extension_valid_for_context):
is_extension_valid_for_context.return_value = False
extension = Extension(exten='9999', context='default')
self.assertRaises(InvalidParametersError,
validator.validate_extension_in_range, extension)
is_extension_valid_for_context.assert_called_once_with(extension)
def test_edit_extension_with_error_from_dao(self, Session):
session = Mock()
session.commit.side_effect = SQLAlchemyError()
Session.return_value = session
extension = Extension(exten='extension', context='context')
self.assertRaises(ElementEditionError, extension_dao.edit, extension)
session.begin.assert_called_once_with()
session.rollback.assert_called_once_with()
def test_validate_extension_available_when_extension_does_not_exist(
self, find_by_exten_context):
find_by_exten_context.return_value = None
extension = Extension(exten='1000', context='default')
validator.validate_extension_available(extension)
find_by_exten_context.assert_called_once_with(extension.exten,
extension.context)
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 test_validate_extension_available_when_extension_exists(
self, find_by_exten_context):
find_by_exten_context.return_value = Mock(Extension)
extension = Extension(exten='1000', context='default')
self.assertRaises(ElementAlreadyExistsError,
validator.validate_extension_available, extension)
find_by_exten_context.assert_called_once_with(extension.exten,
extension.context)
def test_delete(self, validate_delete, extension_dao_delete, extension_notifier_deleted):
exten = 'extension'
context = 'toto'
extension = Extension(id=1,
exten=exten,
context=context)
extension_services.delete(extension)
validate_delete.assert_called_once_with(extension)
extension_dao_delete.assert_called_once_with(extension)
extension_notifier_deleted.assert_called_once_with(extension)
def test_edit(self, validate_edit, extension_dao_edit, extension_notifier_edited):
exten = '1000'
context = 'toto'
extension = Extension(id=1,
exten=exten,
context=context)
extension_dao_edit.return_value = extension
extension_services.edit(extension)
validate_edit.assert_called_once_with(extension)
extension_dao_edit.assert_called_once_with(extension)
extension_notifier_edited.assert_called_once_with(extension)
def test_create(self, validate_create, extension_dao_create, extension_notifier_created):
exten = '1000'
context = 'toto'
extension = Extension(exten=exten,
context=context)
extension_dao_create.return_value = extension
result = extension_services.create(extension)
assert_that(result, equal_to(extension))
validate_create.assert_called_once_with(extension)
extension_dao_create.assert_called_once_with(extension)
extension_notifier_created.assert_called_once_with(extension)
def test_is_extension_valid_for_context_range(self,
is_extension_included_in_ranges,
find_all_specific_context_ranges):
extension = Extension(exten='1000',
context='default')
context_range = find_all_specific_context_ranges.return_value = Mock()
is_extension_included_in_ranges.return_value = True
result = context_services.is_extension_valid_for_context_range(extension, ContextRangeType.users)
find_all_specific_context_ranges.assert_called_once_with(extension.context, ContextRangeType.users)
is_extension_included_in_ranges.assert_called_once_with('1000', context_range)
assert_that(result, equal_to(True))
def test_create(self):
exten = 'extension'
context = 'toto'
commented = True
extension = Extension(exten=exten,
context=context,
commented=commented)
created_extension = extension_dao.create(extension)
row = self.session.query(ExtensionSchema).filter(
ExtensionSchema.id == created_extension.id).first()
assert_that(row.id, equal_to(created_extension.id))
assert_that(row.exten, equal_to(exten))
assert_that(row.context, equal_to(context))
assert_that(row.commented, equal_to(1))
assert_that(row.type, equal_to('user'))
assert_that(row.typeval, equal_to('0'))
def test_edit(self):
exten = 'extension'
context = 'toto'
commented = True
extension = Extension(id=self.existing_extension.id,
exten=exten,
context=context,
commented=commented)
extension_dao.edit(extension)
row = self.session.query(ExtensionSchema).get(extension.id)
assert_that(row.id, equal_to(extension.id))
assert_that(row.exten, equal_to(exten))
assert_that(row.context, equal_to(context))
assert_that(row.commented, equal_to(1))
assert_that(row.type, equal_to('user'))
assert_that(row.typeval, equal_to('0'))
def test_missing_parameters_when_extension_has_no_parameters(self):
extension = Extension()
self.assertRaises(MissingParametersError,
validator.validate_missing_parameters, extension)
def setUp(self):
super(TestResources, self).setUp()
self.extension = Extension(id=1, exten='1234', context='default')
def test_missing_parameters_when_extension_has_minimal_parameters(self):
extension = Extension(exten='1000', context='default')
validator.validate_missing_parameters(extension)
def prepare_extension(self, **kwargs):
extension_row = self.add_extension(**kwargs)
return Extension(id=extension_row.id,
exten=extension_row.exten,
context=extension_row.context,
commented=bool(extension_row.commented))