def test_vif_get_fixed_ips(self): vif = fake_network_cache_model.new_vif() fixed_ips = vif.fixed_ips() ips = [fake_network_cache_model.new_ip(dict(address='10.10.0.2')), fake_network_cache_model.new_ip( dict(address='10.10.0.3'))] * 2 self.assertEqual(fixed_ips, ips)
def test_add_dns(self): subnet = fake_network_cache_model.new_subnet() dns = fake_network_cache_model.new_ip(dict(address='9.9.9.9')) subnet.add_dns(dns) self.assertEqual(subnet['dns'], [fake_network_cache_model.new_ip(dict(address='1.2.3.4')), fake_network_cache_model.new_ip(dict(address='2.3.4.5')), fake_network_cache_model.new_ip(dict(address='9.9.9.9'))])
def test_create_model(self): ninfo = model.NetworkInfo([fake_network_cache_model.new_vif(), fake_network_cache_model.new_vif( {'address': 'bb:bb:bb:bb:bb:bb'})]) self.assertEqual(ninfo.fixed_ips(), [fake_network_cache_model.new_ip({'address': '10.10.0.2'}), fake_network_cache_model.new_ip( {'address': '10.10.0.3'})] * 4)
def test_add_ip(self): subnet = fake_network_cache_model.new_subnet() subnet.add_ip( fake_network_cache_model.new_ip(dict(address='192.168.1.102'))) self.assertEqual(subnet['ips'], [ fake_network_cache_model.new_ip(dict(address='192.168.1.100')), fake_network_cache_model.new_ip(dict(address='192.168.1.101')), fake_network_cache_model.new_ip(dict(address='192.168.1.102')) ])
def test_add_dns_a_lot(self): subnet = fake_network_cache_model.new_subnet() for i in xrange(10): subnet.add_dns(fake_network_cache_model.new_ip( dict(address='9.9.9.9'))) self.assertEqual(subnet['dns'], [fake_network_cache_model.new_ip(dict(address='1.2.3.4')), fake_network_cache_model.new_ip(dict(address='2.3.4.5')), fake_network_cache_model.new_ip(dict(address='9.9.9.9'))])
def test_hydrate(self): ninfo = model.NetworkInfo([fake_network_cache_model.new_vif(), fake_network_cache_model.new_vif( {'address': 'bb:bb:bb:bb:bb:bb'})]) deserialized = model.NetworkInfo.hydrate(ninfo) self.assertEqual(ninfo.fixed_ips(), [fake_network_cache_model.new_ip({'address': '10.10.0.2'}), fake_network_cache_model.new_ip( {'address': '10.10.0.3'})] * 4)
def _test_injected_network_template(self, should_inject, use_ipv6=False, gateway=True): """Check that netutils properly decides whether to inject based on whether the supplied subnet is static or dynamic. """ network = fake_network_cache_model.new_network({'subnets': []}) subnet_dict = {} if not gateway: subnet_dict['gateway'] = None if not should_inject: subnet_dict['dhcp_server'] = '10.10.0.1' network.add_subnet(fake_network_cache_model.new_subnet(subnet_dict)) if should_inject and use_ipv6: gateway_ip = fake_network_cache_model.new_ip(dict( address='1234:567::1')) ip = fake_network_cache_model.new_ip(dict( address='1234:567::2')) ipv6_subnet_dict = dict( cidr='1234:567::/48', gateway=gateway_ip, ips=[ip]) if not gateway: ipv6_subnet_dict['gateway'] = None network.add_subnet(fake_network_cache_model.new_subnet( ipv6_subnet_dict)) # Behave as though CONF.flat_injected is True network['meta']['injected'] = True vif = fake_network_cache_model.new_vif({'network': network}) ninfo = model.NetworkInfo([vif]) template = netutils.get_injected_network_template(ninfo, use_ipv6=use_ipv6) # will just ignore the improper behavior. if not should_inject: self.assertTrue(template is None) else: self.assertTrue('auto eth0' in template) self.assertTrue('iface eth0 inet static' in template) self.assertTrue('address 10.10.0.2' in template) self.assertTrue('netmask 255.255.255.0' in template) self.assertTrue('broadcast 10.10.0.255' in template) if gateway: self.assertTrue('gateway 10.10.0.1' in template) else: self.assertFalse('gateway' in template) self.assertTrue('dns-nameservers 1.2.3.4 2.3.4.5' in template) if use_ipv6: self.assertTrue('iface eth0 inet6 static' in template) self.assertTrue('address 1234:567::2' in template) self.assertTrue('netmask 48' in template) if gateway: self.assertTrue('gateway 1234:567::1' in template)
def _setup_injected_network_scenario(self, should_inject=True, use_ipv4=True, use_ipv6=False, gateway=True, dns=True, two_interfaces=False, libvirt_virt_type=None): """Check that netutils properly decides whether to inject based on whether the supplied subnet is static or dynamic. """ network = fake_network_cache_model.new_network({'subnets': []}) subnet_dict = {} if not gateway: subnet_dict['gateway'] = None if not dns: subnet_dict['dns'] = None if not should_inject: subnet_dict['dhcp_server'] = '10.10.0.1' if use_ipv4: network.add_subnet( fake_network_cache_model.new_subnet(subnet_dict)) if should_inject and use_ipv6: gateway_ip = fake_network_cache_model.new_ip( dict(address='1234:567::1')) ip = fake_network_cache_model.new_ip(dict(address='1234:567::2')) ipv6_subnet_dict = dict( cidr='1234:567::/48', gateway=gateway_ip, dns=[ fake_network_cache_model.new_ip( dict(address='2001:4860:4860::8888')), fake_network_cache_model.new_ip( dict(address='2001:4860:4860::8844')) ], ips=[ip]) if not gateway: ipv6_subnet_dict['gateway'] = None network.add_subnet( fake_network_cache_model.new_subnet(ipv6_subnet_dict)) # Behave as though CONF.flat_injected is True network['meta']['injected'] = True vif = fake_network_cache_model.new_vif({'network': network}) vifs = [vif] if two_interfaces: vifs.append(vif) nwinfo = model.NetworkInfo(vifs) return netutils.get_injected_network_template( nwinfo, use_ipv6=use_ipv6, libvirt_virt_type=libvirt_virt_type)
def test_add_ip_a_lot(self): subnet = fake_network_cache_model.new_subnet() for i in xrange(10): subnet.add_ip( fake_network_cache_model.new_ip(dict(address='192.168.1.102'))) self.assertEqual(subnet['ips'], [ fake_network_cache_model.new_ip(dict(address='10.10.0.2')), fake_network_cache_model.new_ip(dict(address='10.10.0.3')), fake_network_cache_model.new_ip(dict(address='192.168.1.102')) ])
def test_vif_get_labeled_ips(self): vif = fake_network_cache_model.new_vif() labeled_ips = vif.labeled_ips() ip_dict = { 'network_id': 1, 'ips': [fake_network_cache_model.new_ip( {'address': '10.10.0.2'}), fake_network_cache_model.new_ip( {'address': '10.10.0.3'})] * 2, 'network_label': 'public'} self.assertEqual(labeled_ips, ip_dict)
def test_add_ip(self): subnet = fake_network_cache_model.new_subnet() subnet.add_ip(fake_network_cache_model.new_ip(dict(address="192.168.1.102"))) self.assertEqual( subnet["ips"], [ fake_network_cache_model.new_fixed_ip(dict(address="10.10.0.2")), fake_network_cache_model.new_fixed_ip(dict(address="10.10.0.3")), fake_network_cache_model.new_ip(dict(address="192.168.1.102")), ], )
def test_add_ip(self): subnet = fake_network_cache_model.new_subnet() subnet.add_ip(fake_network_cache_model.new_ip( dict(address='192.168.1.102'))) self.assertEqual(subnet['ips'], [fake_network_cache_model.new_ip( dict(address='10.10.0.2')), fake_network_cache_model.new_ip( dict(address='10.10.0.3')), fake_network_cache_model.new_ip( dict(address='192.168.1.102'))])
def test_add_dns_a_lot(self): subnet = fake_network_cache_model.new_subnet() for i in xrange(10): subnet.add_dns(fake_network_cache_model.new_ip(dict(address="9.9.9.9"))) self.assertEqual( subnet["dns"], [ fake_network_cache_model.new_ip(dict(address="1.2.3.4")), fake_network_cache_model.new_ip(dict(address="2.3.4.5")), fake_network_cache_model.new_ip(dict(address="9.9.9.9")), ], )
def test_create_async_model(self): def async_wrapper(): return model.NetworkInfo( [fake_network_cache_model.new_vif(), fake_network_cache_model.new_vif( {'address': 'bb:bb:bb:bb:bb:bb'})]) ninfo = model.NetworkInfoAsyncWrapper(async_wrapper) self.assertEqual(ninfo.fixed_ips(), [fake_network_cache_model.new_ip({'address': '10.10.0.2'}), fake_network_cache_model.new_ip( {'address': '10.10.0.3'})] * 4)
def test_add_dns(self): subnet = fake_network_cache_model.new_subnet() dns = fake_network_cache_model.new_ip(dict(address="9.9.9.9")) subnet.add_dns(dns) self.assertEqual( subnet["dns"], [ fake_network_cache_model.new_ip(dict(address="1.2.3.4")), fake_network_cache_model.new_ip(dict(address="2.3.4.5")), fake_network_cache_model.new_ip(dict(address="9.9.9.9")), ], )
def _test_injected_network_template(self, should_inject, use_ipv6=False, legacy=False): """Check that netutils properly decides whether to inject based on whether the supplied subnet is static or dynamic. """ network = fake_network_cache_model.new_network({'subnets': []}) if should_inject: network.add_subnet(fake_network_cache_model.new_subnet()) if use_ipv6: gateway_ip = fake_network_cache_model.new_ip(dict( address='1234:567::1')) ip = fake_network_cache_model.new_ip(dict( address='1234:567::2')) subnet_dict = dict( cidr='1234:567::/48', gateway=gateway_ip, ips=[ip]) network.add_subnet(fake_network_cache_model.new_subnet( subnet_dict)) else: subnet_dict = dict(dhcp_server='10.10.0.1') network.add_subnet(fake_network_cache_model.new_subnet( subnet_dict)) # Behave as though CONF.flat_injected is True network['meta']['injected'] = True vif = fake_network_cache_model.new_vif({'network': network}) ninfo = model.NetworkInfo([vif]) if legacy: ninfo = ninfo.legacy() template = netutils.get_injected_network_template(ninfo, use_ipv6=use_ipv6) # NOTE(bnemec): There is a bug with legacy network info that causes # it to inject regardless of whether the network is static or dynamic. # This can't be fixed without changes that would potentially break # existing code, so until legacy network info goes away this test # will just ignore the improper behavior. if not should_inject and not legacy: self.assertTrue(template is None) else: self.assertTrue('auto eth0' in template) self.assertTrue('iface eth0 inet static' in template) self.assertTrue('address 10.10.0.2' in template) self.assertTrue('netmask 255.255.255.0' in template) self.assertTrue('broadcast 10.10.0.255' in template) self.assertTrue('gateway 10.10.0.1' in template) self.assertTrue('dns-nameservers 1.2.3.4 2.3.4.5' in template) if use_ipv6: self.assertTrue('iface eth0 inet6 static' in template) self.assertTrue('address 1234:567::2' in template) self.assertTrue('netmask 48' in template) self.assertTrue('gateway 1234:567::1' in template)
def test_add_ip_a_lot(self): subnet = fake_network_cache_model.new_subnet() for i in xrange(10): subnet.add_ip(fake_network_cache_model.new_ip( dict(address='192.168.1.102'))) self.assertEqual(subnet['ips'], [fake_network_cache_model.new_ip( dict(address='192.168.1.100')), fake_network_cache_model.new_ip( dict(address='192.168.1.101')), fake_network_cache_model.new_ip( dict(address='192.168.1.102'))])
def _setup_injected_network_scenario(self, should_inject=True, use_ipv4=True, use_ipv6=False, gateway=True, dns=True, two_interfaces=False, libvirt_virt_type=None): """Check that netutils properly decides whether to inject based on whether the supplied subnet is static or dynamic. """ network = fake_network_cache_model.new_network({'subnets': []}) subnet_dict = {} if not gateway: subnet_dict['gateway'] = None if not dns: subnet_dict['dns'] = None if not should_inject: subnet_dict['dhcp_server'] = '10.10.0.1' if use_ipv4: network.add_subnet( fake_network_cache_model.new_subnet(subnet_dict)) if should_inject and use_ipv6: gateway_ip = fake_network_cache_model.new_ip(dict( address='1234:567::1')) ip = fake_network_cache_model.new_ip(dict( address='1234:567::2')) ipv6_subnet_dict = dict( cidr='1234:567::/48', gateway=gateway_ip, dns=[fake_network_cache_model.new_ip( dict(address='2001:4860:4860::8888')), fake_network_cache_model.new_ip( dict(address='2001:4860:4860::8844'))], ips=[ip]) if not gateway: ipv6_subnet_dict['gateway'] = None network.add_subnet(fake_network_cache_model.new_subnet( ipv6_subnet_dict)) # Behave as though CONF.flat_injected is True network['meta']['injected'] = True vif = fake_network_cache_model.new_vif({'network': network}) vifs = [vif] if two_interfaces: vifs.append(vif) nwinfo = model.NetworkInfo(vifs) return netutils.get_injected_network_template( nwinfo, use_ipv6=use_ipv6, libvirt_virt_type=libvirt_virt_type)
def test_vif_get_labeled_ips(self): vif = fake_network_cache_model.new_vif() labeled_ips = vif.labeled_ips() ip_dict = { "network_id": 1, "ips": [ fake_network_cache_model.new_ip({"address": "10.10.0.2", "type": "fixed"}), fake_network_cache_model.new_ip({"address": "10.10.0.3", "type": "fixed"}), ] * 2, "network_label": "public", } self.assertEqual(labeled_ips, ip_dict)
def test_hydrate(self): route = model.Route.hydrate( {'gateway': fake_network_cache_model.new_ip( dict(address='192.168.1.1'))}) self.assertEqual(route['cidr'], None) self.assertEqual(route['gateway']['address'], '192.168.1.1') self.assertEqual(route['interface'], None)
def test_create_subnet_with_attrs(self): subnet = fake_network_cache_model.new_subnet() route1 = fake_network_cache_model.new_route() self.assertEqual(subnet['cidr'], '10.10.0.0/24') self.assertEqual(subnet['dns'], [fake_network_cache_model.new_ip(dict(address='1.2.3.4')), fake_network_cache_model.new_ip(dict(address='2.3.4.5'))]) self.assertEqual(subnet['gateway']['address'], '10.10.0.1') self.assertEqual(subnet['ips'], [fake_network_cache_model.new_ip( dict(address='10.10.0.2')), fake_network_cache_model.new_ip( dict(address='10.10.0.3'))]) self.assertEqual(subnet['routes'], [route1]) self.assertEqual(subnet['version'], 4)
def test_hydrate(self): subnet_dict = { "cidr": "255.255.255.0", "dns": [fake_network_cache_model.new_ip(dict(address="1.1.1.1"))], "ips": [fake_network_cache_model.new_fixed_ip(dict(address="2.2.2.2"))], "routes": [fake_network_cache_model.new_route()], "version": 4, "gateway": fake_network_cache_model.new_ip(dict(address="3.3.3.3")), } subnet = model.Subnet.hydrate(subnet_dict) self.assertEqual(subnet["cidr"], "255.255.255.0") self.assertEqual(subnet["dns"], [fake_network_cache_model.new_ip(dict(address="1.1.1.1"))]) self.assertEqual(subnet["gateway"]["address"], "3.3.3.3") self.assertEqual(subnet["ips"], [fake_network_cache_model.new_fixed_ip(dict(address="2.2.2.2"))]) self.assertEqual(subnet["routes"], [fake_network_cache_model.new_route()]) self.assertEqual(subnet["version"], 4)
def _setup_injected_network_scenario( self, should_inject=True, use_ipv4=True, use_ipv6=False, gateway=True, dns=True, two_interfaces=False, libvirt_virt_type=None, ): """Check that netutils properly decides whether to inject based on whether the supplied subnet is static or dynamic. """ network = fake_network_cache_model.new_network({"subnets": []}) subnet_dict = {} if not gateway: subnet_dict["gateway"] = None if not dns: subnet_dict["dns"] = None if not should_inject: subnet_dict["dhcp_server"] = "10.10.0.1" if use_ipv4: network.add_subnet(fake_network_cache_model.new_subnet(subnet_dict)) if should_inject and use_ipv6: gateway_ip = fake_network_cache_model.new_ip(dict(address="1234:567::1")) ip = fake_network_cache_model.new_ip(dict(address="1234:567::2")) ipv6_subnet_dict = dict(cidr="1234:567::/48", gateway=gateway_ip, ips=[ip]) if not gateway: ipv6_subnet_dict["gateway"] = None network.add_subnet(fake_network_cache_model.new_subnet(ipv6_subnet_dict)) # Behave as though CONF.flat_injected is True network["meta"]["injected"] = True vif = fake_network_cache_model.new_vif({"network": network}) vifs = [vif] if two_interfaces: vifs.append(vif) nwinfo = model.NetworkInfo(vifs) return netutils.get_injected_network_template(nwinfo, use_ipv6=use_ipv6, libvirt_virt_type=libvirt_virt_type)
def test_hydrate(self): subnet_dict = { 'cidr': '255.255.255.0', 'dns': [fake_network_cache_model.new_ip(dict(address='1.1.1.1'))], 'ips': [fake_network_cache_model.new_ip(dict(address='2.2.2.2'))], 'routes': [fake_network_cache_model.new_route()], 'version': 4, 'gateway': fake_network_cache_model.new_ip( dict(address='3.3.3.3'))} subnet = model.Subnet.hydrate(subnet_dict) self.assertEqual(subnet['cidr'], '255.255.255.0') self.assertEqual(subnet['dns'], [fake_network_cache_model.new_ip( dict(address='1.1.1.1'))]) self.assertEqual(subnet['gateway']['address'], '3.3.3.3') self.assertEqual(subnet['ips'], [fake_network_cache_model.new_ip( dict(address='2.2.2.2'))]) self.assertEqual(subnet['routes'], [ fake_network_cache_model.new_route()]) self.assertEqual(subnet['version'], 4)
def test_create_subnet_with_attrs(self): subnet = fake_network_cache_model.new_subnet() route1 = fake_network_cache_model.new_route() self.assertEqual(subnet["cidr"], "10.10.0.0/24") self.assertEqual( subnet["dns"], [ fake_network_cache_model.new_ip(dict(address="1.2.3.4")), fake_network_cache_model.new_ip(dict(address="2.3.4.5")), ], ) self.assertEqual(subnet["gateway"]["address"], "10.10.0.1") self.assertEqual( subnet["ips"], [ fake_network_cache_model.new_fixed_ip(dict(address="10.10.0.2")), fake_network_cache_model.new_fixed_ip(dict(address="10.10.0.3")), ], ) self.assertEqual(subnet["routes"], [route1]) self.assertEqual(subnet["version"], 4)
def _test_injected_network_template(self, should_inject, use_ipv4=True, use_ipv6=False, gateway=True): """Check that netutils properly decides whether to inject based on whether the supplied subnet is static or dynamic. """ network = fake_network_cache_model.new_network({'subnets': []}) subnet_dict = {} if not gateway: subnet_dict['gateway'] = None if not should_inject: subnet_dict['dhcp_server'] = '10.10.0.1' if use_ipv4: network.add_subnet( fake_network_cache_model.new_subnet(subnet_dict)) if should_inject and use_ipv6: gateway_ip = fake_network_cache_model.new_ip( dict(address='1234:567::1')) ip = fake_network_cache_model.new_ip(dict(address='1234:567::2')) ipv6_subnet_dict = dict(cidr='1234:567::/48', gateway=gateway_ip, ips=[ip]) if not gateway: ipv6_subnet_dict['gateway'] = None network.add_subnet( fake_network_cache_model.new_subnet(ipv6_subnet_dict)) # Behave as though CONF.flat_injected is True network['meta']['injected'] = True vif = fake_network_cache_model.new_vif({'network': network}) ninfo = model.NetworkInfo([vif]) template = netutils.get_injected_network_template(ninfo, use_ipv6=use_ipv6) # will just ignore the improper behavior. if not should_inject: self.assertTrue(template is None) else: if use_ipv4: self.assertIn('auto eth0', template) self.assertIn('iface eth0 inet static', template) self.assertIn('address 10.10.0.2', template) self.assertIn('netmask 255.255.255.0', template) self.assertIn('broadcast 10.10.0.255', template) if gateway: self.assertIn('gateway 10.10.0.1', template) else: self.assertNotIn('gateway', template) self.assertIn('dns-nameservers 1.2.3.4 2.3.4.5', template) if use_ipv6: self.assertIn('iface eth0 inet6 static', template) self.assertIn('address 1234:567::2', template) self.assertIn('netmask 48', template) if gateway: self.assertIn('gateway 1234:567::1', template) if not use_ipv4 and not use_ipv6: self.assertTrue(template is None)
def test_create_route_with_attrs(self): route = fake_network_cache_model.new_route() fake_network_cache_model.new_ip(dict(address="192.168.1.1")) self.assertEqual(route["cidr"], "0.0.0.0/24") self.assertEqual(route["gateway"]["address"], "192.168.1.1") self.assertEqual(route["interface"], "eth0")
def test_hydrate(self): route = model.Route.hydrate({"gateway": fake_network_cache_model.new_ip(dict(address="192.168.1.1"))}) self.assertIsNone(route["cidr"]) self.assertEqual(route["gateway"]["address"], "192.168.1.1") self.assertIsNone(route["interface"])
def test_create_route_with_attrs(self): route = fake_network_cache_model.new_route() ip = fake_network_cache_model.new_ip(dict(address='192.168.1.1')) self.assertEqual(route['cidr'], '0.0.0.0/24') self.assertEqual(route['gateway']['address'], '192.168.1.1') self.assertEqual(route['interface'], 'eth0')