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)
