def generate_data(self, data): model = RackServerModelFactory() return { 'device_1': Device.get_or_create_by_mac( '02:42:ac:11:ff:ff', parent=data['deprecated_dc']['a'], dc=data['deprecated_dc']['a'].name, rack=data['deprecated_racks']['a'].name, service=data['services']['backup_systems'], device_environment=data['envs']['prod'], model=model, )[0], 'device_2': DeviceFactory( parent=data['deprecated_dc']['b'], dc=data['deprecated_dc']['b'].name, rack=data['deprecated_racks']['b'].name, service=data['services']['databases'], device_environment=data['envs']['prod'], model=model, ), 'device_3': DeviceFactory( parent=data['deprecated_dc']['b'], dc=data['deprecated_dc']['b'].name, rack=data['deprecated_racks']['b'].name, service=data['services']['load_balancing'], device_environment=data['envs']['prod'], model=DeviceModelFactory(name='F5', type=DeviceType.load_balancer), ), }
def test_orientation_property(self): dev_1 = DeviceFactory(name='h101.dc') dev_2 = DeviceFactory(name='h101.dc') DCAssetFactory(device_info=DeviceInfoFactory( ralph_device_id=dev_2.id, orientation=Orientation.middle.id, ), ) self.assertEqual(dev_1.orientation, '') self.assertEqual(dev_2.orientation, 'middle') with self.assertRaises(AttributeError): dev_2.orientation = Orientation.back.id
def setUp(self): self.client = login_as_su() self.device = DeviceFactory() self.url = reverse( 'admin:discovery_device_change', args=(self.device.id, ), )
def test_change_service_state(self): """Change Service state from active to another state when Service have connected Devices""" data = json.dumps({'state': CI_STATE_TYPES.INACTIVE.id}) service = ServiceCatalogFactory(state=CI_STATE_TYPES.ACTIVE.id) device = DeviceFactory(service=service) response = self.patch( '/api/v0.9/ci/{}/'.format(service.id), data, CONTENT_TYPE='application/json', ) self.assertEqual( json.loads(response.content)['ci']['state'], 'You can not change state because this service has linked devices.', ) device.service = None device.save() response = self.patch( '/api/v0.9/ci/{}/'.format(service.id), data, CONTENT_TYPE='application/json', ) chenged_service = CI.objects.get(id=service.id) self.assertEqual(chenged_service.state, CI_STATE_TYPES.INACTIVE.id)
def setUp(self): self.sample_dev = DeviceFactory() self.sample_ip_1 = IPAddressFactory( address="127.0.0.1", device=self.sample_dev, ) self.sample_ip_2 = IPAddressFactory(address="127.0.0.2")
def test_change_service_state(self): """Change Service state from active to another state when Service have connected Devices""" service = ServiceCatalogFactory(state=CI_STATE_TYPES.ACTIVE.id) device = DeviceFactory(service=service) data = { 'base-state': CI_STATE_TYPES.INACTIVE.id, 'base-status': service.status, 'base-layers': 1, 'base-name': service.name, 'base-type': CI_TYPES.SERVICE.id, } url = reverse('ci_edit', args=(service.id,)) response = self.client.post(url, data, follow=True) msg = response.context['form'].errors['state'][0] self.assertTrue('You can not change state to INACTIVE' in msg) device.service = None device.save() url = reverse('ci_edit', args=(service.id,)) response = self.client.post(url, data, follow=True) self.assertEqual(response.context['form'].errors, {})
def test_position_edit_blocking(self): url = reverse( 'racks', kwargs={ 'rack': '-', 'details': 'add_device', 'device': '', }, ) dev = DeviceFactory() asset = DCAssetFactory(device_info=DeviceInfoFactory( ralph_device_id=dev.id, ), ) post_data = { 'asset': asset.id, } response = self.client.post(url, post_data, follow=True) self.assertFalse(response.context['form'].is_valid()) from ralph.ui.widgets import ReadOnlyWidget self.assertTrue( isinstance( response.context['form'].fields['chassis_position'].widget, ReadOnlyWidget, ), ) self.assertTrue( isinstance( response.context['form'].fields['position'].widget, ReadOnlyWidget, ), )
def test_migrate(self): """Resetting the management_ip should migrate the data from legacy way to the preferred way""" dev = DeviceFactory() dev.management = IPAddressFactory(is_management=True) dev.management_ip = dev.management_ip self.assertEqual(dev.ipaddress_set.all()[0], dev.management_ip) self.assertIsNone(dev.management)
def test_when_device_does_not_exist_and_there_is_no_asset_identity(self): device = DeviceFactory() util._create_device = lambda x: device util.create_deployments([self.data], self.user, self.mass_deployment) deployments = Deployment.objects.all() self.assertEqual(deployments.count(), 1) self.assertEqual(deployments[0].device, device)
def test_model_is_empty(self): device = DeviceFactory() url = reverse( 'search', kwargs={'device': device.id, 'details': 'info'}, ) self.assertEqual(device.model, None) response = self.client.get(url) self.assertEqual(response.status_code, 200)
def test_set_tuple(self): """Setting the management_ip by tuple""" dev = DeviceFactory() data = ('hostname.dc1', '10.1.2.3') dev.management_ip = data self.assertEqual( (dev.management_ip.hostname, dev.management_ip.address), data, )
def setUp(self): sample_role = VentureRoleFactory() RolePropertyFactory( symbol='my_custom_property_1', type=RolePropertyTypeFactory(symbol='STRING'), role=sample_role, ) self.sample_device = DeviceFactory(venture=sample_role.venture, venture_role=sample_role) self.sample_user = UserFactory()
def test_asset_found_by_device_hostname(self): hostname = 'blade-408-1-sw1.dc4.local' device = DeviceFactory(name=hostname) DCAssetFactory(device_info__ralph_device_id=device.id) base_url = self._generate_url( 'ralph_assets.models', 'LinkedDeviceNameLookup', ) self._check_lookup_count(base_url, searched_term=hostname, expected_count=1)
def setUp(self): self.sample_dev = DeviceFactory() self.sample_ip_1 = IPAddressFactory( address="10.0.0.1", device=self.sample_dev, hostname="dev1.dc", ) self.sample_ip_2 = IPAddressFactory( address="10.0.0.2", hostname='dev2.dc', )
def setUp(self): self.device = DeviceFactory() self.regular_ipaddr = IPAddressFactory() self.management_ipaddr = IPAddressFactory(is_management=True) self.device.ipaddress_set.add(self.regular_ipaddr) self.device.ipaddress_set.add(self.management_ipaddr) self.url = reverse('search', kwargs={ 'details': 'addresses', 'device': str(self.device.pk), }) self.client = login_as_su()
def test_when_device_does_not_exist_and_asset_identity_is_given(self): device = DeviceFactory() device_info = DeviceInfoFactory(ralph_device_id=device.id) asset = AssetFactory( barcode="testbarcode", device_info=device_info, ) self.data.update({"asset_identity": asset.barcode}) util.create_deployments([self.data], self.user, self.mass_deployment) deployments = Deployment.objects.all() self.assertEqual(deployments.count(), 1) self.assertEqual(deployments[0].device, device)
def generate_data(self, data): from itertools import cycle services = cycle([ data['services']['backup_systems'], data['services']['databases'] ]) envs = cycle(list(data['envs'].values())) model = DeviceModel.objects.create(name='XEN', type=DeviceType.virtual_server) result = {} for i in range(5): result['virtual_{}'.format(i)] = DeviceFactory( model=model, service=services.next(), device_environment=envs.next(), parent=data['devices']['device_1'], name='XEN-{}'.format(i), ) return result
def generate_data(self, data): from uuid import uuid1 from itertools import cycle services = cycle([ data['services']['backup_systems'], data['services']['databases'] ]) envs = cycle(list(data['envs'].values())) model = DeviceModel.objects.create(name='OpenStack Juno Tenant', type=DeviceType.cloud_server) result = {} for i in range(5): result['tenant_{}'.format(i)] = DeviceFactory( model=model, service=services.next(), device_environment=envs.next(), sn='openstack-{}'.format(uuid1()), name='Tenant-{}'.format(i), ) return result
def setUp(self): super(TestChangeIPAddress, self).setUp() self.user = create_user() self.sample_dev = DeviceFactory() self.sample_ip_1 = IPAddressFactory( address="10.0.1.1", device=self.sample_dev, hostname="d001.dc", ) self.sample_dhcp_entry_1 = DHCPEntryFactory( ip="10.0.1.1", mac="aa:cc:bb:11:22:33", ) self.sample_dns_domain = DNSDomainFactory(name='dc') self.sample_dns_record = DNSRecordFactory( name='d001.dc', type='A', content='10.0.1.1', domain=self.sample_dns_domain, )
def setUp(self): self.client = login_as_su() self.device = DeviceFactory() self.url = reverse('admin:discovery_ipaddress_add')
def setUp(self): self.dev = DeviceFactory(service=ServiceCatalogFactory())
def test_dc_asset_with_linked_device(self): core_device = DeviceFactory() device_info = DeviceInfoFactory(ralph_device_id=core_device.id) asset = DCAssetFactory(device_info=device_info) self.assertEqual(asset.linked_device, core_device)
def test_mass_deployment(self): ip = '10.80.80.101' self.test_prepare_mass_deployment() ip_address = IPAddressFactory() device_model = DeviceModelFactory( type=DeviceType.rack, name="testrack", ) device = DeviceFactory( name="testdevice", model=device_model, sn="testsn", ) device.ipaddress.add(ip_address) ethernet = EthernetFactory.create( mac="0022b0000000", device=device, ) self.network.racks.add(device) mass_deployment = MassDeployment.objects.all()[0] dns_domain = DNSDomainFactory(name='dc') dns_record = DNSRecordFactory( name='d001.dc', type='A', content=ip_address.address, domain=dns_domain, ) url = reverse( 'mass_deploy', kwargs={"deployment": mass_deployment.id}, ) csv = ('{0}; {1}; {2}; ' '{3}; 10.80.80.102; {4}; {5} ; {6} ; {7} ; {8} ; {9}'.format( dns_record.name, ip, device.sn, ethernet.mac, self.network.name, self.venture_role.venture.symbol.upper(), self.venture_role.name, self.service.name, self.device_environment.name, self.preboot.name, )) response = self.client.post(url, { 'csv': csv, }) self._base_check_for_mass_deployment(response, 'generated_csv', csv) deployment = Deployment.objects.get(device=device) self.assertEqual(deployment.venture, self.venture_role.venture) self.assertEqual(deployment.venture_role, self.venture_role) self.assertEqual(deployment.service, self.service) self.assertEqual( deployment.device_environment, self.device_environment, ) self.assertEqual(deployment.preboot, self.preboot) self.assertEqual(deployment.ip, ip) self.assertEqual( deployment.mac, MACAddressField.normalize(ethernet.mac), )
def test_set_string(self): """Setting the management_ip by string""" dev = DeviceFactory() dev.management_ip = '10.1.2.3' self.assertEqual(dev.management_ip.address, '10.1.2.3')
def test_legacy(self): """Legacy way of setting management_ip is readable.""" dev = DeviceFactory() dev.management = IPAddressFactory(is_management=True) self.assertEqual(dev.management, dev.management_ip)
def test_preferred(self): """Preferred way of setting management_ip is readable.""" dev = DeviceFactory() management = IPAddressFactory(is_management=True) dev.ipaddress_set.add(management) self.assertEqual(management, dev.management_ip)