class EthernetTest(RalphTestCase):
def setUp(self):
self.ip1 = IPAddressFactory()
self.eth1 = EthernetFactory()
def test_clear_mac_address_without_ip_should_pass(self):
self.eth1.mac = None
self.eth1.clean()
self.eth1.save()
def test_clear_mac_address_with_ip_without_dhcp_exposition_should_pass(
self): # noqa
self.ip1.ethernet.mac = None
self.ip1.ethernet.clean()
self.ip1.ethernet.save()
def test_clear_mac_address_with_ip_with_dhcp_exposition_should_not_pass(
self): # noqa
self.ip1.dhcp_expose = True
self.ip1.save()
self.ip1.ethernet.mac = None
with self.assertRaises(
ValidationError,
msg='MAC cannot be empty if record is exposed in DHCP'):
self.ip1.ethernet.clean()
def test_change_mac_address_with_ip_with_dhcp_exposition_should_not_pass(
self): # noqa
self.ip1.dhcp_expose = True
self.ip1.save()
self.ip1.ethernet.mac = '11:12:13:14:15:16'
with self.assertRaises(ValidationError,
msg='Cannot change MAC when exposing in DHCP'):
self.ip1.ethernet.clean()
def test_filter_duplicated_hostnames(self):
network = NetworkFactory(address='192.168.1.0/24')
asset = DataCenterAssetFactory()
ethernet = EthernetFactory(base_object=asset)
ethernet.save()
IPAddressFactory(hostname='host1.mydc.net',
address='192.168.1.2',
ethernet=ethernet,
dhcp_expose=True)
ethernet2 = EthernetFactory()
ethernet2.save()
IPAddressFactory(hostname='host1.mydc.net',
address='192.168.1.3',
ethernet=ethernet2,
dhcp_expose=True)
ethernet3 = EthernetFactory()
ethernet3.save()
ip = IPAddressFactory(hostname='host2.mydc.net',
address='192.168.1.4',
ethernet=ethernet3,
dhcp_expose=True)
entries = self.view._get_dhcp_entries(
Network.objects.filter(id__in=[network.id]))
self.assertEqual(DHCPEntry.objects.count(), 3)
self.assertEqual(len(entries), 1)
self.assertEqual(entries[0].pk, ip.pk)
def setUpClass(cls):
from ralph.data_center.tests.factories import (
DataCenterAssetFactory,
RackFactory,
)
super().setUpClass()
cls.dc_asset = DataCenterAssetFactory(
hostname='ralph0.allegro.pl',
service_env__service__name='service',
service_env__environment__name='test',
model__name='DL360',
model__manufacturer__name='Asus',
model__category__name='ATS',
rack=RackFactory(
name='Rack #100',
server_room__name='Server Room A',
server_room__data_center__name='DC1',
),
position=1,
slot_no='1',
configuration_path__class_name='www',
configuration_path__module__name='ralph',
)
cls.dc_ip = IPAddressFactory(
base_object=cls.dc_asset,
ethernet=EthernetFactory(base_object=cls.dc_asset),
)
IPAddressFactory(
base_object=cls.dc_asset,
ethernet=EthernetFactory(base_object=cls.dc_asset),
is_management=True,
)
def setUp(self):
self.cloud_ip = IPAddressFactory(
ethernet__base_object=CloudHostFactory())
# fetch "clean" ip from db to fet base object instead of final instance
# (cloud host in this case)
self.cloud_ip = IPAddress.objects.get(address=self.cloud_ip.address)
self.dc_asset_ip = IPAddressFactory(
ethernet__base_object=DataCenterAssetFactory())
self.dc_asset_ip = IPAddress.objects.get(
address=self.dc_asset_ip.address)
def setUp(self):
self.network = NetworkFactory(address='10.20.30.0/24')
self.ip1 = IPAddressFactory(address='10.20.30.40')
self.ip2 = IPAddressFactory(address='10.20.30.41')
self.ip_other = IPAddressFactory(address='10.30.30.40')
self.user = get_user_model().objects.create_superuser(
username='******', password='******', email='*****@*****.**')
result = self.client.login(username='******', password='******')
self.assertEqual(result, True)
self.factory = RequestFactory()
def test_delete_when_ip_does_not_exist(self):
vip = VIPFactory()
ip = IPAddressFactory()
self.data['ip'] = ip.address
ip.delete()
self.data['port'] = vip.port
self.data['protocol'] = VIPProtocol.from_id(vip.protocol).name
self.assertEqual(VIP.objects.count(), 1)
handle_delete_vip_event(self.data)
self.assertEqual(VIP.objects.count(), 1)
def setUp(self):
self.rack = RackFactory()
self.asset = DataCenterAssetFactory(rack=self.rack,
position=randint(0, 100))
self.ethernets = EthernetFactory.create_batch(2,
base_object=self.asset)
self.ip = IPAddressFactory(base_object=self.asset,
is_management=False,
ethernet=self.ethernets[0])
self.management = IPAddressFactory(base_object=self.asset,
is_management=True,
ethernet=self.ethernets[1])
def test_get_security_scan_for_ip(self):
ip1 = IPAddressFactory(address="192.168.128.1")
self.security_scan1 = SecurityScanFactory(
base_object=ip1.ethernet.base_object)
ip2 = IPAddressFactory(address="192.168.128.2")
self.security_scan2 = SecurityScanFactory(
base_object=ip2.ethernet.base_object)
response = self.client.get(reverse('securityscan-list') + '?' +
'ip={}'.format(ip1.address),
format='json')
self.assertEqual(response.data['count'], 1)
self.assertTrue(
# check if base_object got correct id
response.data['results'][0]
['base_object'].endswith('/{}/'.format(ip1.base_object.id)))
def test_dnsaas_returns_empty_json(self):
cluster = ClusterFactory()
IPAddressFactory(ethernet__base_object=cluster)
cluster.baseobjectcluster_set.create(
is_master=True,
base_object=DataCenterAssetFullFactory(
rack__name='Rack #1',
rack__server_room__name='SR1',
rack__server_room__data_center__name='DC1',
))
httpretty.register_uri(httpretty.GET,
"http://100.200.250.251/api/v2/records/",
body={})
req = RequestFactory().get("/") # url doesn't matter (I hope)
req.user = self.user
mesgs = MagicMock()
v = DNSView(object=cluster)
with patch("ralph.dns.views.messages", mesgs):
v.get_forms(req)
mesgs.error.assert_called()
msgtext = mesgs.error.call_args[0][1]
expected = str(_("Invalid response from DNSaaS:"))
assert msgtext.startswith(expected),\
"%s not in %s" % (expected, msgtext)
def setUp(self):
super().setUp()
self.bo_asset = BackOfficeAssetFactory(
barcode='12345', hostname='host1'
)
self.bo_asset.tags.add('tag1')
self.conf_module_1 = ConfigurationModuleFactory()
self.conf_module_2 = ConfigurationModuleFactory(
parent=self.conf_module_1, name='mod1'
)
self.conf_class_1 = ConfigurationClassFactory(
id=999999,
module=self.conf_module_2, class_name='cls1'
)
self.dc_asset = DataCenterAssetFactory(
barcode='12543', price='9.00',
service_env__service__name='test-service',
service_env__service__uid='sc-123',
service_env__environment__name='prod',
configuration_path=self.conf_class_1,
)
self.dc_asset.tags.add('tag2')
self.ip = IPAddressFactory(
ethernet=EthernetFactory(base_object=self.dc_asset)
)
self.service = ServiceEnvironmentFactory(service__name='myservice')
def test_update_change_cluster(self):
cluster_old = ClusterFactory(name='f5-1-fake-old')
ethernet = EthernetFactory(base_object=cluster_old)
vip = VIPFactory(
ip=IPAddressFactory(ethernet=ethernet),
parent=cluster_old,
)
self.data['load_balancer'] = 'f5-1-fake-new'
self.data['ip'] = vip.ip.address
self.data['port'] = vip.port
self.data['protocol'] = VIPProtocol.from_id(vip.protocol).name
self.assertEqual(VIP.objects.count(), 1)
self.assertEqual(Cluster.objects.count(), 1)
self.assertEqual(Ethernet.objects.count(), 1)
handle_update_vip_event(self.data)
vips = VIP.objects.all()
self.assertEqual(vips.count(), 1)
self.assertEqual(Cluster.objects.count(), 2)
self.assertEqual(Ethernet.objects.count(), 1)
self.assertEqual(vips[0].ip.ethernet, ethernet)
self.assertEqual(
Ethernet.objects.get(
id=ethernet.id).base_object.last_descendant.name,
self.data['load_balancer'])
def test_external_id_is_converted_to_local(self):
ip = IPAddressFactory(address="192.168.128.10")
vulnerability_1 = VulnerabilityFactory()
vulnerability_2 = VulnerabilityFactory()
data = {
'last_scan_date':
'2015-01-01T00:00:00',
'scan_status':
'ok',
'next_scan_date':
'2016-01-01T00:00:00',
'details_url':
'https://example.com/scan-deatils',
'rescan_url':
'https://example.com/rescan-url',
'host_ip':
ip.address,
'vulnerabilities': [vulnerability_1.id],
'external_vulnerabilities':
[vulnerability_2.external_vulnerability_id],
}
scan_serializer = SaveSecurityScanSerializer(context={'request': None})
deserialized = scan_serializer.to_internal_value(data)
self.assertEqual(
deserialized['vulnerabilities'],
[vulnerability_1, vulnerability_2],
)
def test_create_security_scan(self):
ip = IPAddressFactory(address="192.168.128.10")
vulnerability = VulnerabilityFactory()
data = {
'last_scan_date': '2015-01-01T00:00:00',
'scan_status': ScanStatus.ok.name,
'next_scan_date': '2016-01-01T00:00:00',
'details_url': 'https://example.com/scan-deatils',
'rescan_url': 'https://example.com/rescan-url',
'host_ip': ip.address,
'vulnerabilities': [
vulnerability.id,
],
}
url = reverse('securityscan-list')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
security_scan = SecurityScan.objects.get(pk=response.data['id'])
self.assertEqual(security_scan.last_scan_date.isoformat(),
data['last_scan_date'])
self.assertEqual(security_scan.scan_status, ScanStatus.ok)
self.assertEqual(security_scan.next_scan_date.isoformat(),
data['next_scan_date'])
self.assertEqual(security_scan.details_url, data['details_url'])
self.assertEqual(security_scan.rescan_url, data['rescan_url'])
self.assertEqual(security_scan.base_object, ip.base_object)
self.assertEqual(security_scan.vulnerabilities.count(), 1)
self.assertEqual(security_scan.vulnerabilities.get(), vulnerability)
def test_duplicate_hostname_in_different_networks_in_same_dc_should_not_pass(
self): # noqa
name = 'random.hostname.net'
network = NetworkFactory(
address='192.168.0.0/24',
network_environment=NetworkEnvironmentFactory(
data_center=DataCenterFactory(name='DC1')))
network1 = NetworkFactory(
address='1.1.0.0/24',
network_environment=NetworkEnvironmentFactory(
data_center=DataCenterFactory(name='DC1')))
ip = IPAddressFactory(hostname=name,
address='192.168.0.1',
dhcp_expose=True)
self.ip.hostname = name
self.ip.address = '1.1.0.2'
self.ip.dhcp_expose = True
with self.assertRaises(
ValidationError,
msg='Hostname "{hostname}" is already exposed in DHCP in {dc}.'
.format(hostname=name,
dc=network.network_environment.data_center)):
self.ip.validate_hostname_uniqueness_in_dc(name)
with self.assertRaises(
ValidationError,
msg='Hostname "{hostname}" is already exposed in DHCP in {dc}.'
.format(hostname=name,
dc=network1.network_environment.data_center)):
self.ip.clean()
def test_clean_dns_with_no_ips(self, delete_dns_record_mock):
IPAddressFactory(ethernet__base_object=self.instance,
is_management=True)
history = {self.instance.pk: {}}
self.instance.__class__.clean_dns([self.instance],
history_kwargs=history)
self.assertEqual(delete_dns_record_mock.call_count, 0)
def test_get_last_modified_should_return_ip_modified(self):
network = NetworkFactory(address='192.168.1.0/24')
ip = IPAddressFactory(address='192.168.1.2')
returned = self.view.get_last_modified(
Network.objects.filter(id__in=[network.id]))
self.assertEqual(returned.strftime("%Y-%m-%d %H:%M:%S"),
ip.modified.strftime("%Y-%m-%d %H:%M:%S"))
def setUp(self):
self.inline_prefix = 'ethernet_set-'
self.obj1 = PolymorphicTestModel.objects.create(hostname='abc')
self.ip1 = IPAddressFactory(
ethernet__base_object=self.obj1,
ethernet__mac='10:20:30:40:50:60',
hostname='s11.dc.local',
address='127.0.0.1',
is_management=True,
)
self.eth1 = self.ip1.ethernet
self.user = get_user_model().objects.create_superuser(
username='******', password='******', email='*****@*****.**')
result = self.client.login(username='******', password='******')
self.assertEqual(result, True)
self.factory = RequestFactory()
def test_change_mgmt_ip_for_existing_ip_with_object_should_not_pass(self):
IPAddressFactory(address='10.20.30.42')
self.dc_asset.management_ip = '10.20.30.40'
self.dc_asset.refresh_from_db()
self.assertEqual(self.dc_asset.management_ip, '10.20.30.40')
with self.assertRaises(ValidationError):
self.dc_asset.management_ip = '10.20.30.42'
def test_create_scan_sets_is_patched_false_when_vulnerabilities(self):
ip = IPAddressFactory(address="192.168.128.10")
vulnerability = VulnerabilityFactory(patch_deadline=datetime.now() -
timedelta(days=10))
data = {
'last_scan_date': '2015-01-01T00:00:00',
'scan_status': ScanStatus.ok.name,
'next_scan_date': '2016-01-01T00:00:00',
'details_url': 'https://example.com/scan-deatils',
'rescan_url': 'https://example.com/rescan-url',
'host_ip': ip.address,
'vulnerabilities': [
vulnerability.id,
],
}
url = reverse('securityscan-list')
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(
SecurityScan.objects.get(pk=response.data['id']).is_patched,
False,
)
def test_check_ipaddress_unique_with_occupied_ip_should_raise_validation_error(self): # noqa
IPAddressFactory(address='10.20.30.40')
with self.assertRaises(ValidationError):
validate_ip_address(
[self.instance], {'ip_or_network': {
'value': '__other__', '__other__': '10.20.30.40'
}}
)
def test_queries_number(self):
for _ in range(0, 10):
rack = RackFactory()
for position in range(1, 6):
model = DataCenterAssetModelFactory(has_parent=True)
asset = DataCenterAssetFactory(rack=rack,
position=position,
model=model)
ethernets = EthernetFactory.create_batch(2, base_object=asset)
IPAddressFactory(base_object=asset,
is_management=False,
ethernet=ethernets[0])
IPAddressFactory(base_object=asset,
is_management=True,
ethernet=ethernets[1])
with self.assertNumQueries(103):
DataCenterAssetTextResource().export()
def test_remove_entry_from_dhcp(self):
history = {self.instance.pk: {}}
ip = IPAddressFactory(address='10.20.30.40',
hostname='s1234.mydc.net',
ethernet__mac='aa:bb:cc:dd:ee:ff',
ethernet__base_object=self.instance,
dhcp_expose=True)
self.instance.__class__.remove_from_dhcp_entries(
[self.instance], ipaddress=ip.id, history_kwargs=history)
ip.refresh_from_db()
self.assertFalse(ip.dhcp_expose)
self.assertEqual(
history, {
self.instance.pk: {
'DHCP entry':
'10.20.30.40 (s1234.mydc.net) / AA:BB:CC:DD:EE:FF'
}
})
def test_clean_dns(self, delete_dns_record_mock, get_dns_records_mock):
IPAddressFactory(address='10.20.30.41')
IPAddressFactory(ethernet__base_object=self.instance,
is_management=True)
IPAddressFactory(
ethernet__base_object=self.instance,
ethernet__mac=None,
ethernet__label=None,
address='10.20.30.40',
)
delete_dns_record_mock.return_value = False
get_dns_records_mock.return_value = [self._dns_record] * 3
history = {self.instance.pk: {}}
self.instance.__class__.clean_dns([self.instance],
history_kwargs=history)
get_dns_records_mock.assert_called_with(['10.20.30.40'])
self.assertEqual(delete_dns_record_mock.call_count, 3)
delete_dns_record_mock.assert_called_with(10)
def test_ip_inside_defined_network_should_pass(self):
NetworkFactory(address='10.20.30.0/24')
IPAddressFactory(address='10.20.30.40',
ethernet__base_object=self.instance)
validate_ip_address([self.instance], {
'ip_or_network': {
'value': '__other__',
'__other__': '10.20.30.40'
}
})
def test_check_ipaddress_unique_with_ip_assigned_to_the_same_object_should_pass(self):
NetworkFactory(address='10.20.30.0/24')
IPAddressFactory(
address='10.20.30.40', ethernet__base_object=self.instance
)
validate_ip_address(
[self.instance], {'ip_or_network': {
'value': '__other__', '__other__': '10.20.30.40'
}}
)
def test_ip_outside_defined_networks_raise_validation_error(self):
IPAddressFactory(
address='10.20.30.40', ethernet__base_object=self.instance
)
with self.assertRaises(ValidationError):
validate_ip_address(
[self.instance], {'ip_or_network': {
'value': '__other__', '__other__': '10.20.30.40'
}}
)
def test_change_mgmt_ip_for_existing_ip_without_object_should_pass(self):
IPAddressFactory(address='10.20.30.42', ethernet=None)
self.dc_asset.management_ip = '10.20.30.40'
self.dc_asset.refresh_from_db()
self.assertEqual(self.dc_asset.management_ip, '10.20.30.40')
self.dc_asset.management_ip = '10.20.30.42'
self.dc_asset.refresh_from_db()
self.assertEqual(self.dc_asset.management_ip, '10.20.30.42')
self.assertFalse(
IPAddress.objects.filter(address='10.20.30.40').exists())
def test_replace_ip_through_gui(self):
self._prepare_replace_ip_transition()
ethernet = EthernetFactory(base_object=self.instance)
ipaddress = IPAddressFactory(address='10.20.30.1',
ethernet=ethernet,
hostname='test_hostname')
network = self.instance._get_available_networks()[0]
response = self.gui_client.post(reverse(
self.transition_url_name,
args=(self.instance.id, self.assign_replace_ip_transition.id)), {
'replace_ip__ipaddress': ipaddress.id,
'replace_ip__network': network.id
},
follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(
response.redirect_chain[0][0],
reverse(self.redirect_url_name, args=(self.instance.id, )))
ipaddress.refresh_from_db()
self.assertNotEqual(ipaddress.address, '10.20.30.1')
def test_get_last_modified_should_return_assets_ethernet_modified(self):
network = NetworkFactory(address='192.168.1.0/24')
asset = DataCenterAssetFactory()
ethernet = EthernetFactory(base_object=asset)
ethernet.save()
ip = IPAddressFactory(address='192.168.1.2',
base_object=asset,
ethernet=ethernet)
ethernet.save()
returned = self.view.get_last_modified(
Network.objects.filter(id__in=[network.id]))
self.assertEqual(returned.strftime("%Y-%m-%d %H:%M:%S"),
ethernet.modified.strftime("%Y-%m-%d %H:%M:%S"))
class EthernetAPITests(RalphAPITestCase):
def setUp(self):
super().setUp()
self.ip = IPAddressFactory(dhcp_expose=True)
self.eth = self.ip.ethernet
self.eth2 = EthernetFactory()
def test_get_list_of_ethernets(self):
url = reverse('ethernet-list')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['count'], 2)
def test_get_ethernet_with_ip_details(self):
url = reverse('ethernet-detail', args=(self.eth.id, ))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.data['ipaddress'], {
'id':
self.ip.id,
'address':
self.ip.address,
'hostname':
self.ip.hostname,
'dhcp_expose':
self.ip.dhcp_expose,
'is_management':
self.ip.is_management,
'url':
self.get_full_url(
reverse('ipaddress-detail', args=(self.ip.id, ))),
'ui_url':
self.get_full_url(self.ip.get_absolute_url())
})
def test_cannot_delete_when_exposed_in_dhcp(self):
url = reverse('ethernet-detail', args=(self.eth.id, ))
response = self.client.delete(url, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('Could not delete Ethernet when it is exposed in DHCP',
response.data)
def test_filter_by_ipaddress(self):
url = '{}?ipaddress__address={}'.format(reverse('ethernet-list'),
self.ip.address)
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['count'], 1)
