def test_create(self, validate_create, device_dao_create, notifier_created): expected_device = { 'ip': '10.9.0.5', 'mac': '00:11:22:33:44:55', 'template_id': 'abcd1234', 'plugin': 'superduperplugin', 'vendor': 'Aastra', 'model': '6531i', } device = Device(**expected_device) device_dao_create.return_value = Device(**expected_device) result = device_services.create(device) validate_create.assert_called_with(device) device_dao_create.assert_called_once_with(device) notifier_created.assert_called_once_with(result) self.assertEquals(result.mac, expected_device['mac']) self.assertEquals(result.ip, expected_device['ip']) self.assertEquals(result.template_id, expected_device['template_id']) self.assertEquals(result.plugin, expected_device['plugin']) self.assertEquals(result.vendor, expected_device['vendor']) self.assertEquals(result.model, expected_device['model'])
def test_create_empty_device(self, notifier_created, device_dao_create): device = Device() created_device = Device(id='abcd') device_dao_create.return_value = created_device result = device_services.create(device) self.assertEquals(result.id, created_device.id) device_dao_create.assert_called_once_with(device) notifier_created.assert_called_once_with(result)
def test_to_source_with_parameters(self): device_id = 'abcd1234' device_mac = 'AB:11:22:33:44:55' expected_mac = 'ab:11:22:33:44:55' device = Device(id=device_id, ip='10.0.0.1', mac=device_mac, plugin='xivo-aastra-3.2.2-SP3', vendor='Aastra', model='6731i') expected_provd_device = { 'id': device_id, 'ip': device.ip, 'mac': expected_mac, 'plugin': device.plugin, 'vendor': device.vendor, 'model': device.model, } expected_provd_config = { 'configdevice': 'defaultconfigdevice', 'deletable': True, 'id': device_id, 'parent_ids': ['base', 'defaultconfigdevice'], 'raw_config': {} } provd_device, provd_config = provd_converter.to_source(device) assert_that(provd_device, equal_to(expected_provd_device)) assert_that(provd_config, equal_to(expected_provd_config))
def test_build_edit_with_new_properties_and_no_config(self): device_id = 'abc123' device = Device(id=device_id, ip='10.0.0.1', mac='00:11:22:33:44:55', plugin='aastraplugin', model='6735i', vendor='Aastra', version='0.0.1') provd_device = {'configured': False, 'id': device_id} expected_provd_device = { 'configured': False, 'id': device_id, 'ip': '10.0.0.1', 'mac': '00:11:22:33:44:55', 'plugin': 'aastraplugin', 'model': '6735i', 'vendor': 'Aastra', 'version': '0.0.1' } result_device, result_config = provd_converter.build_edit( device, provd_device, None) assert_that(result_device, equal_to(expected_provd_device))
def test_autoprov_with_error(self, device_manager, config_manager): device = Device(id=self.device_id) device_manager().update.side_effect = Exception('') self.assertRaises(ProvdError, device_services.reset_to_autoprov, device)
def test_edit_with_a_device_associated(self, line_dao_edit, line_notifier_edited, device_dao_find, device_services_rebuild_device_config): name = 'line' context = 'toto' secret = '1234' device_id = '2' device = Device(id=device_id) line = LineSIP(name=name, context=context, username=name, secret=secret, device_id=device_id, device_slot=1) device_dao_find.return_value = device line_services.edit(line) line_dao_edit.assert_called_once_with(line) line_notifier_edited.assert_called_once_with(line) device_dao_find.assert_called_once_with(device_id) device_services_rebuild_device_config.assert_called_once_with(device)
def test_remove_line_from_device(self, config_manager): config_dict = { "raw_config": { "protocol": "sip", "sip_lines": { "1": { "username": "******" }, "2": { "username": "******" } } } } config_manager().get.return_value = config_dict line = LineSIP(device_slot=2) device = Device(id=self.device_id) expected_arg = { "raw_config": { "protocol": "sip", "sip_lines": { "1": { "username": "******" } } } } device_services.remove_line_from_device(device, line) config_manager().get.assert_called_with(self.device_id) config_manager().update.assert_called_with(expected_arg) self.assertEquals(0, config_manager().autocreate.call_count)
def test_remove_line_from_device_no_funckeys(self, device_manager, config_manager, reset_config, reset_to_autoprov): autoprovid = "autoprov1234" config_dict = { "raw_config": { "protocol": "sip", "sip_lines": { "1": { "username": "******" } } } } device_dict = { "ip": "10.60.0.109", "version": "3.2.2.1136", "config": self.device_id, "id": self.device_id } line = LineSIP(device_slot=1) device = Device(id=self.device_id) config_manager().get.return_value = config_dict device_manager().get.return_value = device_dict config_manager().autocreate.return_value = autoprovid try: device_services.remove_line_from_device(device, line) except: self.fail("An exception was raised whereas it should not") reset_config.assert_called_once_with(config_dict) reset_to_autoprov.assert_called_once_with(device)
def test_validate_edit(self, dao_find, template_id_exists, plugin_exists, mac_exists): device_found = Mock(Device) device_found.mac = '00:11:22:33:44:54' dao_find.return_value = device_found template_id_exists.return_value = True plugin_exists.return_value = True mac_exists.return_value = False device_id = '123abc' device = { 'id': device_id, 'mac': '00:11:22:33:44:55', 'ip': '10.0.0.1', 'template_id': 'defaultconfigdevice', 'plugin': 'null', } device = Device(**device) validator.validate_edit(device) dao_find.assert_called_once_with(device_id) template_id_exists.assert_called_once_with(device.template_id) plugin_exists.assert_called_once_with(device.plugin) mac_exists.assert_called_once_with(device.mac)
def test_synchronize_with_error(self, device_manager): device = Device(id=self.device_id) device_manager().synchronize.side_effect = Exception('') self.assertRaises(ProvdError, device_services.synchronize, device) device_manager().synchronize.assert_called_with(self.device_id)
def test_delete_with_error(self, ine_dao_reset, device_dao_delete, device_notifier_deleted): device = Device(id=self.device_id, ip='10.0.0.1') device_dao_delete.side_effect = ElementDeletionError( 'Device', 'Not Exist') self.assertRaises(ElementDeletionError, device_services.delete, device) self.assertEquals(device_notifier_deleted.call_count, 0)
def test_rebuild_device_config_no_result(self, line_find_all_by_device_id, build_line_for_device): device = Device(id=self.device_id) line_find_all_by_device_id.return_value = [] device_services.rebuild_device_config(device) self.assertEquals(build_line_for_device.call_count, 0)
def to_model(device, config=None): filtered_device = dict((key, value) for key, value in device.iteritems() if key in PROVD_DEVICE_KEYS) new_model = Device(**filtered_device) if config: if 'configdevice' in config: new_model.template_id = config['configdevice'] if device['configured'] is True: if device['config'].startswith('autoprov'): new_model.status = 'autoprov' else: new_model.status = 'configured' else: new_model.status = 'not_configured' return new_model
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_rebuild_device_config(self, line_find_all_by_device_id, build_line_for_device): device = Device(id=self.device_id) line1 = LineSIP(device_id=self.device_id) line_find_all_by_device_id.return_value = [line1] device_services.rebuild_device_config(device) build_line_for_device.assert_called_once_with(device, line1)
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 test_validate_create_invalid_mac(self): device = { 'id': '02aff2a361004aaf8a8a686a48dc980d', 'mac': 'ZA:22:33:44:55:66' } device = Device(**device) self.assertRaises(InvalidParametersError, validator.validate_create, device)
def test_validate_create_invalid_ip(self): device = { 'id': '02aff2a361004aaf8a8a686a48dc980d', 'ip': '10.9.0.5156' } device = Device(**device) self.assertRaises(InvalidParametersError, validator.validate_create, device)
def test_delete(self): device_id = 'abc1234' device = Device(id=device_id) with self.provd_managers() as (device_manager, config_manager, _): device_dao.delete(device) device_manager.remove.assert_called_once_with(device_id) config_manager.remove.assert_called_once_with(device_id)
def test_delete_with_error(self): device = Device(id='abcd') with self.provd_managers() as (device_manager, config_manager, _): device_manager.remove.side_effect = Exception self.assertRaises(ElementDeletionError, device_dao.delete, device) device_manager.remove.assert_called_once_with(device.id) self.assertEquals(config_manager.remove.call_count, 0)
def test_validate_create_mac_already_exists(self, dao_mac_exists): device = Device(mac='00:11:22:33:44:55') dao_mac_exists.return_value = True self.assertRaises(ElementAlreadyExistsError, validator.validate_create, device) dao_mac_exists.assert_called_once_with(device.mac)
def test_delete_unassociated(self, device_dao_delete, line_dao_reset_device, device_notifier_deleted): device = Device(id=self.device_id, ip='10.0.0.1') device_services.delete(device) device_dao_delete.assert_called_once_with(device) line_dao_reset_device.assert_called_once_with(device.id) device_notifier_deleted.assert_called_once_with(device)
def test_validate_create_plugin_does_not_exist(self, dao_plugin_exists): device = { 'plugin': 'superduperplugin', } device = Device(**device) dao_plugin_exists.return_value = False self.assertRaises(NonexistentParametersError, validator.validate_create, device)
def test_delete_not_exist(self): device = Device(id='abcd') with self.provd_managers() as (device_manager, config_manager, _): device_manager.remove.side_effect = HTTPError( '', 404, '', '', StringIO('')) self.assertRaises(ElementNotExistsError, device_dao.delete, device) device_manager.remove.assert_called_once_with(device.id) self.assertEquals(config_manager.remove.call_count, 0)
def test_associate_line_to_device(self, line_dao_edit, link_device_config, rebuild_device_config): device = Device(id=self.device_id) line = LineSIP() device_services.associate_line_to_device(device, line) line_dao_edit.assert_called_once_with(line) link_device_config.assert_called_once_with(device) rebuild_device_config.assert_called_once_with(device) self.assertEquals(line.device_id, self.device_id)
def test_answer(self): device = Device(ip='127.0.0.1') snom_controller = SnomController(self._ami_class) answerer = Mock(_SnomAnswerer) snom_controller._get_answerer = Mock(return_value=answerer) snom_controller.answer(device) snom_controller._get_answerer.assert_called_once_with( device.ip, 'guest', 'guest') self._assert_answerer_called_once(answerer)
def test_validate_create_template_does_not_exist(self, dao_template_id_exists): device = { 'template_id': 'mysuperdupertemplate', } device = Device(**device) dao_template_id_exists.return_value = False self.assertRaises(NonexistentParametersError, validator.validate_create, device)
def test_delete_associated(self, device_validate, device_dao_delete, line_dao_reset_device, device_notifier_deleted): device = Device(id=self.device_id, ip='10.0.0.1') device_validate.side_effect = ElementDeletionError( 'Device', 'device is still linked') self.assertRaises(ElementDeletionError, device_services.delete, device) assert_that(device_dao_delete.call_count, equal_to(0)) assert_that(line_dao_reset_device.call_count, equal_to(0)) assert_that(device_notifier_deleted.call_count, equal_to(0))
def test_edit_with_error_on_device_update(self, provd_build_edit): device_id = 'abc1234' device = Device(id=device_id) provd_build_edit.return_value = ({}, {}) with self.provd_managers() as (device_manager, config_manager, _): device_manager.get.return_value = {} config_manager.get.return_value = {} device_manager.update.side_effect = Exception self.assertRaises(ElementEditionError, device_dao.edit, device)
def test_list_devices_with_two_devices(self, device_search): device1 = Device(id='abcdefghijklmnopqrstuvwxyz123456', ip='10.0.0.1', mac='00:11:22:33:44:55') device2 = Device(id='1234567890abcdefghij1234567890abc', ip='10.0.0.2', mac='00:11:22:33:44:56') device_search.return_value = SearchResult(total=2, items=[device1, device2]) expected_result = { 'total': 2, 'items': [self.build_item(device1), self.build_item(device2)] } result = self.app.get(BASE_URL) self.assert_response_for_list(result, expected_result) device_search.assert_called_once_with()
def test_rebuild_device_config_provd_error(self, line_find_all_by_device_id, build_line_for_device): device = Device(id=self.device_id) line1 = LineSIP(device_id=self.device_id) line_find_all_by_device_id.return_value = [line1] build_line_for_device.side_effect = URLError('urlerror') self.assertRaises(ProvdError, device_services.rebuild_device_config, device) build_line_for_device.assert_called_once_with(device, line1)
def test_is_switchboard_plugin_name(self): device = Device() device.plugin = 'xivo-aastra-switchboard' assert_that(device.is_switchboard())
def test_is_switchboard_no_plugin(self): device = Device() assert_that(is_not(device.is_switchboard()))
def test_is_switchboard_option_true(self): device = Device() device.options = {'switchboard': True} assert_that(device.is_switchboard())
def test_is_switchboard_option_false(self): device = Device() device.options = {'switchboard': False} assert_that(is_not(device.is_switchboard()))
def test_is_switchboard_no_option(self): device = Device() device.options = {} assert_that(is_not(device.is_switchboard()))
def test_validate_create_invalid_options_type(self): device = Device() device.options = 'foobar' self.assertRaises(InvalidParametersError, validator.validate_create, device)
def test_validate_create_invalid_switchboard_option_type(self): device = Device() device.options = {'switchboard': 42} self.assertRaises(InvalidParametersError, validator.validate_create, device)