def create_objects(nvars):
# There needs to be major exception handling here. Things can go pretty
# wrong.
ip_type = nvars.get('ip_type', None)
network_str = nvars.get('network_str', None)
network = Network(network_str=network_str, ip_type=ip_type)
network.update_network()
site_pk = nvars.get('site_pk', '')
if not site_pk:
site = None
else:
site = Site.objects.get(pk=site_pk)
network.site = site
if nvars.get('vlan_action', '') == "new":
vlan_name = nvars.get('vlan_name', None)
vlan_number = nvars.get('vlan_number', None)
vlan = Vlan(name=vlan_name, number=vlan_number)
elif nvars.get('vlan_action', '') == "existing":
vlan_number = nvars.get('vlan_pk', '')
if not vlan_number:
raise ValidationError("You selected to use an existing vlan. "
"Pleasechoose a vlan.")
vlan = Vlan.objects.get(pk=vlan_number)
else:
vlan = None
network.vlan = vlan
return site, network, vlan
def do_basic_add(self, network, prefixlen, ip_type,
ame=None, number=None, site=None):
s = Network(network_str=network + "/" + prefixlen,
ip_type=ip_type, site=site)
s.clean()
s.save()
self.assertTrue(s)
return s
def setUp(self):
self.d = Domain(name="com")
self.d.save()
Domain(name="arpa").save()
Domain(name="in-addr.arpa").save()
Domain(name="10.in-addr.arpa").save()
self.s = Network(network_str="10.0.0.0/16", ip_type='4')
self.s.update_network()
self.s.save()
self.s1 = Network(network_str="10.2.1.0/24", ip_type='4')
self.s1.update_network()
self.s1.save()
def setUp(self):
self.d = Domain(name="com")
self.d.save()
Domain(name="arpa").save()
Domain(name="in-addr.arpa").save()
Domain(name="10.in-addr.arpa").save()
self.s = Network(network_str="10.0.0.0/16", ip_type='4')
self.s.update_network()
self.s.save()
self.s1 = Network(network_str="10.2.1.0/24", ip_type='4')
self.s1.update_network()
self.s1.save()
def test_check_valid_ranges_v4_valid(self):
n = Network(network_str='10.0.0.0/8')
n.full_clean()
n.save()
r = Range(ip_type='4', start_str='10.4.0.2', end_str='10.4.255.254',
network=n)
r.full_clean()
r.save()
n.network_str = '10.4.0.0/16'
n.full_clean()
n.save()
def test8_create_ipv4_interface(self):
v, _ = Vlan.objects.get_or_create(name="8db", number=3)
s, _ = Site.objects.get_or_create(name="8scl3")
s1, _ = Site.objects.get_or_create(name="8dmz", parent=s)
d, _ = Domain.objects.get_or_create(name="8scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="8dmz.8scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="8db.8dmz.8scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="15.in-addr.arpa")
n = Network(network_str="15.0.0.0/8", ip_type="4")
n.clean()
n.site = s1
n.vlan = v
n.save()
r = Range(start_str="15.0.0.0",
end_str="15.0.0.2",
network=n,
ip_type='4')
r.clean()
r.save()
intr, errors = create_ipv4_interface(label="foo",
vlan_str="8db",
site_str="8dmz.8scl3",
system=self.system,
mac="11:22:33:44:55:66",
domain_suffix="mozilla.com")
self.assertEqual(errors, None)
self.assertTrue(isinstance(intr, StaticInterface))
def test2_create_ipv4_interface_from_domain(self):
v, _ = Vlan.objects.get_or_create(name="private", number=3)
s, _ = Site.objects.get_or_create(name="phx1")
s1, _ = Site.objects.get_or_create(name="corp", parent=s)
d, _ = Domain.objects.get_or_create(name="phx1.mozilla.com")
d1, _ = Domain.objects.get_or_create(name="corp.phx1.mozilla.com")
d2, _ = Domain.objects.get_or_create(
name="private.corp.phx1.mozilla.com")
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="14.in-addr.arpa")
n = Network(network_str="14.0.0.0/8", ip_type="4")
n.clean()
n.site = s1
n.vlan = v
n.save()
r = Range(start_str="14.0.0.0",
end_str="14.0.0.2",
network=n,
ip_type='4')
r.clean()
r.save()
intr, errors = create_ipv4_intr_from_domain("foo", "private.corp.phx1",
self.system,
"11:22:33:44:55:66")
self.assertEqual(errors, None)
self.assertTrue(isinstance(intr, StaticInterface))
def test_check_valid_ranges_v4_start_low_end_high(self):
n = Network(network_str='10.0.0.0/8')
n.full_clean()
n.save()
r = Range(ip_type='4', start_str='10.3.0.2', end_str='10.5.255.254',
network=n)
r.full_clean()
r.save()
n.network_str = '10.4.0.0/16'
with self.assertRaises(ValidationError):
n.full_clean()
n.save()
def setUp(self):
self.system = System()
self.system.save()
d1 = create_fake_zone("oregonstate.com", suffix="")
soa = d1.soa
self.soa = soa
v, _ = Vlan.objects.get_or_create(name="private", number=3)
s, _ = Site.objects.get_or_create(name="phx1")
s1, _ = Site.objects.get_or_create(name="corp", parent=s)
d, _ = Domain.objects.get_or_create(name="phx1.oregonstate.com")
d.soa = soa
d.save()
d1, _ = Domain.objects.get_or_create(name="corp.phx1.oregonstate.com")
d1.soa = soa
d1.save()
d2, _ = Domain.objects.get_or_create(
name="private.corp.phx1.oregonstate.com")
d2.soa = soa
d2.save()
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="15.in-addr.arpa")
n = Network(network_str="15.0.0.0/8", ip_type="4")
n.clean()
n.site = s1
n.vlan = v
n.save()
r = Range(start_str="15.0.0.0", end_str="15.0.0.10",
network=n, ip_type='4')
r.clean()
r.save()
def test6_create_ipv4_interface(self):
v, _ = Vlan.objects.get_or_create(name="6db", number=3)
s, _ = Site.objects.get_or_create(name="6scl3")
d, _ = Domain.objects.get_or_create(name="6scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="6db.6scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="11.in-addr.arpa")
n = Network(network_str="11.0.0.0/8", ip_type="4")
n.clean()
n.site = s
n.vlan = v
n.save()
r = Range(start_str="11.0.0.0",
end_str="11.0.0.2",
network=n,
ip_type='4')
r.clean()
r.save()
s = StaticInterface(label="fab",
domain=d,
ip_type="4",
ip_str="11.0.0.0",
system=self.system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
s = StaticInterface(label="fab",
domain=d,
ip_type="4",
ip_str="11.0.0.1",
system=self.system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
s = StaticInterface(label="fab",
domain=d,
ip_type="4",
ip_str="11.0.0.2",
system=self.system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
intr, errors = create_ipv4_interface("foo", "6db", "6scl3",
self.system, "11:22:33:44:55:66",
"mozilla.com")
self.assertEqual(intr, None)
self.assertTrue("vlan" not in errors)
self.assertTrue("site" not in errors)
self.assertTrue("domain" not in errors)
self.assertTrue("network" not in errors)
self.assertTrue("range" not in errors)
self.assertTrue("ip" in errors)
def setUp(self):
self.d = Domain(name="com")
self.s = Network(network_str="1234:1234:1234::/16", ip_type='6')
self.s.update_network()
self.s.save()
self.s1 = Network(network_str="1234:1134:1234::/32", ip_type='6')
self.s1.update_network()
self.s1.save()
self.s2 = Network(network_str="fff::/4", ip_type='6')
self.s2.update_network()
self.s2.save()
self.s3 = Network(network_str="ffff::/4", ip_type='6')
self.s3.update_network()
self.s3.save()
def test8_create_ipv4_interface(self):
v, _ = Vlan.objects.get_or_create(name="8db", number=3)
s, _ = Site.objects.get_or_create(name="8scl3")
s1, _ = Site.objects.get_or_create(name="8dmz", parent=s)
d, _ = Domain.objects.get_or_create(name="8scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="8dmz.8scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="8db.8dmz.8scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="15.in-addr.arpa")
n = Network(network_str="15.0.0.0/8", ip_type="4")
n.clean()
n.site = s1
n.vlan = v
n.save()
r = Range(start_str="15.0.0.0", end_str="15.0.0.2",
network=n)
r.clean()
r.save()
intr, errors = create_ipv4_interface(
"foo", "8db", "8dmz.8scl3", self.system,
"11:22:33:44:55:66", "mozilla.com")
self.assertEqual(errors, None)
self.assertTrue(isinstance(intr, StaticInterface))
def test2_create_ipv4_interface_from_domain(self):
v, _ = Vlan.objects.get_or_create(name="private", number=3)
s, _ = Site.objects.get_or_create(name="phx1")
s1, _ = Site.objects.get_or_create(name="corp", parent=s)
d, _ = Domain.objects.get_or_create(name="phx1.mozilla.com")
d1, _ = Domain.objects.get_or_create(name="corp.phx1.mozilla.com")
d2, _ = Domain.objects.get_or_create(
name="private.corp.phx1.mozilla.com")
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="14.in-addr.arpa")
n = Network(network_str="14.0.0.0/8", ip_type="4")
n.clean()
n.site = s1
n.vlan = v
n.save()
r = Range(start_str="14.0.0.0", end_str="14.0.0.2",
network=n)
r.clean()
r.save()
intr, errors = create_ipv4_intr_from_domain(
"foo", "private.corp.phx1", self.system,
"11:22:33:44:55:66")
self.assertEqual(errors, None)
self.assertTrue(isinstance(intr, StaticInterface))
def test1_create_ipv4_interface_from_domain(self):
v, _ = Vlan.objects.get_or_create(name="private", number=3)
s, _ = Site.objects.get_or_create(name="phx1")
d, _ = Domain.objects.get_or_create(name="phx1.mozilla.com")
d, _ = Domain.objects.get_or_create(name="private.phx1.mozilla.com")
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="13.in-addr.arpa")
n = Network(network_str="13.0.0.0/8", ip_type="4")
n.clean()
n.site = s
n.vlan = v
n.save()
r = Range(start_str="13.0.0.0", end_str="13.0.0.2",
network=n, ip_type='4')
r.clean()
r.save()
intr, errors = create_ipv4_intr_from_domain(
label="foo", domain_name="private.phx1", system=self.system,
mac="11:22:33:44:55:66")
self.assertEqual(errors, None)
self.assertTrue(isinstance(intr, StaticInterface))
def do_basic_add_network(self, network, prefixlen, ip_type, name=None,
vlan=None, site=None):
n = Network(network_str=network + "/" + prefixlen, ip_type=ip_type,
site=site, vlan=vlan)
n.clean()
n.save()
return n
def create_objects(nvars):
# There needs to be major exception handling here. Things can go pretty
# wrong.
ip_type = nvars.get('ip_type', None)
network_str = nvars.get('network_str', None)
network = Network(network_str=network_str, ip_type=ip_type)
network.update_network()
site_pk = nvars.get('site_pk', '')
if not site_pk:
site = None
else:
site = Site.objects.get(pk=site_pk)
network.site = site
if nvars.get('vlan_action', '') == "new":
vlan_name = nvars.get('vlan_name', None)
vlan_number = nvars.get('vlan_number', None)
vlan = Vlan(name=vlan_name, number=vlan_number)
elif nvars.get('vlan_action', '') == "existing":
vlan_number = nvars.get('vlan_pk', '')
if not vlan_number:
raise ValidationError("You selected to use an existing vlan. "
"Pleasechoose a vlan.")
vlan = Vlan.objects.get(pk=vlan_number)
else:
vlan = None
network.vlan = vlan
return site, network, vlan
def setUp(self):
self.d = Domain(name="com")
self.s = Network(network_str="1234:1234:1234::/16", ip_type='6')
self.s.update_network()
self.s.save()
self.s1 = Network(network_str="1234:1134:1234::/32", ip_type='6')
self.s1.update_network()
self.s1.save()
self.s2 = Network(network_str="fff::/4", ip_type='6')
self.s2.update_network()
self.s2.save()
self.s3 = Network(network_str="ffff::/4", ip_type='6')
self.s3.update_network()
self.s3.save()
def do_basic_add(self,
network,
prefixlen,
ip_type,
name=None,
number=None):
s = Network(network_str=network + "/" + prefixlen, ip_type=ip_type)
s.clean()
s.save()
self.assertTrue(s)
return s
def test5_create_ipv4_interface(self):
v, _ = Vlan.objects.get_or_create(name="5db", number=3)
s, _ = Site.objects.get_or_create(name="5scl3")
d, _ = Domain.objects.get_or_create(name="5scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="5db.5scl3.mozilla.com")
n = Network(network_str="10.0.0.0/8", ip_type="4")
n.clean()
n.site = s
n.vlan = v
n.save()
intr, errors = create_ipv4_interface("foo", "5db", "5scl3",
self.system, "11:22:33:44:55:66",
"mozilla.com")
self.assertEqual(intr, None)
self.assertTrue("vlan" not in errors)
self.assertTrue("site" not in errors)
self.assertTrue("domain" not in errors)
self.assertTrue("network" not in errors)
self.assertTrue("range" in errors)
def test6_create_ipv4_interface(self):
v, _ = Vlan.objects.get_or_create(name="6db", number=3)
s, _ = Site.objects.get_or_create(name="6scl3")
d, _ = Domain.objects.get_or_create(name="6scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="6db.6scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="11.in-addr.arpa")
n = Network(network_str="11.0.0.0/8", ip_type="4")
n.clean()
n.site = s
n.vlan = v
n.save()
r = Range(start_str="11.0.0.0", end_str="11.0.0.2",
network=n, ip_type='4')
r.clean()
r.save()
s = StaticInterface(label="fab", domain=d, ip_type="4",
ip_str="11.0.0.0", system=self.system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
s = StaticInterface(label="fab", domain=d, ip_type="4",
ip_str="11.0.0.1", system=self.system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
s = StaticInterface(label="fab", domain=d, ip_type="4",
ip_str="11.0.0.2", system=self.system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
intr, errors = create_ipv4_interface(
"foo", "6db", "6scl3", self.system,
"11:22:33:44:55:66", "mozilla.com")
self.assertEqual(intr, None)
self.assertTrue("vlan" not in errors)
self.assertTrue("site" not in errors)
self.assertTrue("domain" not in errors)
self.assertTrue("network" not in errors)
self.assertTrue("range" not in errors)
self.assertTrue("ip" in errors)
def setUp(self):
self.system = System()
Domain.objects.get_or_create(name="com")
d1, _ = Domain.objects.get_or_create(name="mozilla.com")
soa, _ = SOA.objects.get_or_create(primary="fo.bar",
contact="foo.bar.com",
comment="foo bar")
self.s = soa
d1.soa = soa
d1.save()
v, _ = Vlan.objects.get_or_create(name="private", number=3)
s, _ = Site.objects.get_or_create(name="phx1")
s1, _ = Site.objects.get_or_create(name="corp", parent=s)
d, _ = Domain.objects.get_or_create(name="phx1.mozilla.com")
d.soa = soa
d.save()
d1, _ = Domain.objects.get_or_create(name="corp.phx1.mozilla.com")
d1.soa = soa
d1.save()
d2, _ = Domain.objects.get_or_create(
name="private.corp.phx1.mozilla.com")
d2.soa = soa
d2.save()
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="ipv6.arpa")
d, _ = Domain.objects.get_or_create(name="15.in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="2.in-addr.arpa")
n = Network(network_str="15.0.0.0/8", ip_type="4")
n.clean()
n.site = s1
n.vlan = v
n.save()
r = Range(start_str="15.0.0.0", end_str="15.0.0.10", network=n)
r.clean()
r.save()
def test5_create_ipv4_interface(self):
v, _ = Vlan.objects.get_or_create(name="5db", number=3)
s, _ = Site.objects.get_or_create(name="5scl3")
d, _ = Domain.objects.get_or_create(name="5scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="5db.5scl3.mozilla.com")
n = Network(network_str="10.0.0.0/8", ip_type="4")
n.clean()
n.site = s
n.vlan = v
n.save()
intr, errors = create_ipv4_interface(
"foo", "5db", "5scl3", self.system,
"11:22:33:44:55:66", "mozilla.com")
self.assertEqual(intr, None)
self.assertTrue("vlan" not in errors)
self.assertTrue("site" not in errors)
self.assertTrue("domain" not in errors)
self.assertTrue("network" not in errors)
self.assertTrue("range" in errors)
def test7_create_ipv4_interface(self):
v, _ = Vlan.objects.get_or_create(name="7db", number=3)
s, _ = Site.objects.get_or_create(name="7scl3")
d, _ = Domain.objects.get_or_create(name="7scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="7db.7scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="12.in-addr.arpa")
n = Network(network_str="12.0.0.0/8", ip_type="4")
n.clean()
n.site = s
n.vlan = v
n.save()
r = Range(start_str="12.0.0.0", end_str="12.0.0.2", network=n)
r.clean()
r.save()
intr, errors = create_ipv4_interface("foo", "7db", "7scl3",
self.system, "11:22:33:44:55:66",
"mozilla.com")
self.assertEqual(errors, None)
self.assertTrue(isinstance(intr, StaticInterface))
def setUp(self):
self.system = System()
Domain.objects.get_or_create(name="com")
d1, _ = Domain.objects.get_or_create(name="mozilla.com")
soa, _ = SOA.objects.get_or_create(
primary="fo.bar", contact="foo.bar.com",
comment="foo bar")
self.s = soa
d1.soa = soa
d1.save()
v, _ = Vlan.objects.get_or_create(name="private", number=3)
s, _ = Site.objects.get_or_create(name="phx1")
s1, _ = Site.objects.get_or_create(name="corp", parent=s)
d, _ = Domain.objects.get_or_create(name="phx1.mozilla.com")
d.soa = soa
d.save()
d1, _ = Domain.objects.get_or_create(name="corp.phx1.mozilla.com")
d1.soa = soa
d1.save()
d2, _ = Domain.objects.get_or_create(
name="private.corp.phx1.mozilla.com")
d2.soa = soa
d2.save()
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="ipv6.arpa")
d, _ = Domain.objects.get_or_create(name="15.in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="2.in-addr.arpa")
n = Network(network_str="15.0.0.0/8", ip_type="4")
n.clean()
n.site = s1
n.vlan = v
n.save()
r = Range(start_str="15.0.0.0", end_str="15.0.0.10",
network=n)
r.clean()
r.save()
class V4RangeTests(TestCase):
def setUp(self):
self.d = Domain(name="com")
self.d.save()
Domain(name="arpa").save()
Domain(name="in-addr.arpa").save()
Domain(name="10.in-addr.arpa").save()
self.s = Network(network_str="10.0.0.0/16", ip_type='4')
self.s.update_network()
self.s.save()
self.s1 = Network(network_str="10.2.1.0/24", ip_type='4')
self.s1.update_network()
self.s1.save()
def do_add(self, start_str, end_str, default_domain, \
network, rtype, ip_type):
r = Range(start_str=start_str,
end_str=end_str,
network=network,
ip_type=ip_type)
r.__repr__()
r.save()
return r
def test1_create(self):
start_str = "10.0.0.1"
end_str = "10.0.0.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
def test2_create(self):
start_str = "10.0.1.1"
end_str = "10.0.1.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
def test1_bad_create(self):
# start == end
start_str = "10.0.0.0"
end_str = "10.1.0.0"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test2_bad_create(self):
# start > end
start_str = "10.0.0.2"
end_str = "10.0.0.1"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test3_bad_create(self):
# outside of network
start_str = "11.0.0.2"
end_str = "10.0.0.88"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test4_bad_create(self):
# outside of network
start_str = "10.2.0.0"
end_str = "10.2.1.88"
default_domain = self.d
network = self.s1
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test5_bad_create(self):
# duplicate
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test6_bad_create(self):
# Partial overlap
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.4.1"
end_str = "10.0.4.30"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test7_bad_create(self):
# Partial overlap
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.4.1"
end_str = "10.0.4.56"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test8_bad_create(self):
# Full overlap
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.4.2"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test9_bad_create(self):
# Full overlap
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.4.2"
end_str = "10.0.4.54"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test10_bad_create(self):
# Duplicate add
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.5.2"
end_str = "10.0.5.56"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test11_bad_create(self):
# More overlap tests
start_str = "10.0.4.5"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.4.60"
end_str = "10.0.4.63"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.4.1"
end_str = "10.0.4.4"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.4.2"
end_str = "10.0.4.54"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test12_bad_create(self):
# Update range to something outside of the subnet.
start_str = "10.0.4.5"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.4.60"
end_str = "10.0.4.63"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "10.0.4.1"
end_str = "10.0.4.4"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
r = self.do_add(**kwargs)
r.end_str = "160.0.4.60"
self.assertRaises(ValidationError, r.clean)
def test13_bad_create(self):
start_str = "10.0.4.5"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test1_freeip(self):
start_str = "10.0.33.1"
end_str = "10.0.33.3"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
system = System()
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
r = self.do_add(**kwargs)
self.assertEqual(str(r.get_next_ip()), "10.0.33.1")
self.assertEqual(str(r.get_next_ip()), "10.0.33.1")
s = StaticInterface(label="foo",
domain=self.d,
ip_type='4',
ip_str=str(r.get_next_ip()),
system=system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
self.assertEqual(str(r.get_next_ip()), "10.0.33.2")
s = StaticInterface(label="foo",
domain=self.d,
ip_type='4',
ip_str=str(r.get_next_ip()),
system=system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
self.assertEqual(str(r.get_next_ip()), "10.0.33.3")
s = StaticInterface(label="foo",
domain=self.d,
ip_type='4',
ip_str=str(r.get_next_ip()),
system=system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
self.assertEqual(r.get_next_ip(), None)
def test_check_valid_ranges_v4_start_low_end_high(self):
n = Network(network_str='10.0.0.0/8')
n.full_clean()
n.save()
r = Range(ip_type='4',
start_str='10.3.0.2',
end_str='10.5.255.254',
network=n)
r.full_clean()
r.save()
n.network_str = '10.4.0.0/16'
with self.assertRaises(ValidationError):
n.full_clean()
n.save()
def test_check_valid_ranges_v4_valid(self):
n = Network(network_str='10.0.0.0/8')
n.full_clean()
n.save()
r = Range(ip_type='4',
start_str='10.4.0.2',
end_str='10.4.255.254',
network=n)
r.full_clean()
r.save()
n.network_str = '10.4.0.0/16'
n.full_clean()
n.save()
def test1_create_ipv4_interface_network_str(self):
v, _ = Vlan.objects.get_or_create(name="12db", number=3)
s, _ = Site.objects.get_or_create(name="12scl3")
d, _ = Domain.objects.get_or_create(name="12scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="12db.12scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="12.in-addr.arpa")
n = Network(network_str="12.0.0.0/24", ip_type="4")
n.clean()
n.site = s
n.vlan = v
n.save()
n1 = Network(network_str="12.0.1.0/24", ip_type="4")
n1.clean()
n1.site = s
n1.vlan = v
n1.save()
r = Range(start_str="12.0.0.0", end_str="12.0.0.2",
network=n)
r.clean()
r.save()
r1 = Range(start_str="12.0.1.0", end_str="12.0.1.2",
network=n1)
r1.clean()
r1.save()
intr, errors = create_ipv4_interface(
"foo", "12db", "12scl3", self.system,
"11:22:33:4e:55:66", "mozilla.com")
self.assertTrue('network' in errors)
self.assertTrue(
errors['network'][0].find("too many networks associated") != -1)
# Look for a non-existant network
intr, errors = create_ipv4_interface(
"foo", "12db", "12scl3", self.system,
"11:22:33:4e:55:66", "mozilla.com", network_str="12.0.99.0/24")
self.assertTrue('network' in errors)
intr, errors = create_ipv4_interface(
"foo", "12db", "12scl3", self.system,
"11:22:33:4e:55:66", "mozilla.com", network_str="12.0.0.0/24")
self.assertFalse(errors)
self.assertTrue(isinstance(intr, StaticInterface))
def test_overlap_validation(self):
n1 = Network(network_str='1::/65', ip_type='6')
n1.update_network()
n1.save()
self.assertFalse(n1 in get_total_overlap(n1))
self.assertFalse(n1 in get_partial_overlap(n1))
n2 = Network(network_str='1::/66', ip_type='6')
n2.update_network()
self.assertEqual(n1.start_upper, n2.start_upper)
self.assertEqual(n1.end_upper, n2.end_upper)
self.assertFalse(n1 in get_total_overlap(n2))
self.assertTrue(n1 in get_partial_overlap(n2))
n2 = Network(network_str='1::/64', ip_type='6')
n2.update_network()
self.assertEqual(n1.start_upper, n2.start_upper)
self.assertEqual(n1.end_upper, n2.end_upper)
self.assertTrue(n1 in get_total_overlap(n2))
self.assertTrue(n1 in get_partial_overlap(n2))
n2 = Network(network_str='1:0:0:0:8000::/65', ip_type='6')
n2.update_network()
self.assertEqual(n1.start_upper, n2.start_upper)
self.assertEqual(n1.end_upper, n2.end_upper)
self.assertFalse(n1 in get_total_overlap(n2))
self.assertFalse(n1 in get_partial_overlap(n2))
n1 = Network(network_str='2::/16', ip_type='6')
n1.update_network()
n1.save()
self.assertFalse(n1 in get_total_overlap(n1))
self.assertFalse(n1 in get_partial_overlap(n1))
n2 = Network(network_str='2::/17', ip_type='6')
n2.update_network()
self.assertEqual(n1.start_upper, n2.start_upper)
self.assertNotEqual(n1.end_upper, n2.end_upper)
self.assertFalse(n1 in get_total_overlap(n2))
self.assertTrue(n1 in get_partial_overlap(n2))
n2 = Network(network_str='2::/15', ip_type='6')
n2.update_network()
self.assertEqual(n1.start_upper, n2.start_upper)
self.assertNotEqual(n1.end_upper, n2.end_upper)
self.assertTrue(n1 in get_total_overlap(n2))
self.assertTrue(n1 in get_partial_overlap(n2))
n2 = Network(network_str='3::/16', ip_type='6')
n2.update_network()
self.assertNotEqual(n1.start_upper, n2.start_upper)
self.assertNotEqual(n1.end_upper, n2.end_upper)
self.assertFalse(n1 in get_total_overlap(n2))
self.assertFalse(n1 in get_partial_overlap(n2))
site = Site.objects.get(name=site_str)
except ObjectDoesNotExist, e:
continue
queries, s_misc = sif(site)
range_queries += queries
misc = misc.union(s_misc)
for network_str in network_fs:
try:
# Guess which network type they are searching by looking for ':'
if network_str.find(':') > -1:
network = ipaddr.IPv6Address(network_str=network_str,
ip_type='6')
network.update_network()
else:
network = Network(network_str=network_str, ip_type='4')
network.update_network()
except ValidationError, e:
continue
except ipaddr.AddressValueError, e:
continue
queries, n_misc = nif(network)
range_queries += queries
misc = misc.union(n_misc)
for vlan_str in vlan_fs:
try:
vlan = Vlan.objects.get(name=vlan_str)
except ObjectDoesNotExist, e:
try:
vlan = Vlan.objects.get(name=vlan_str)
class V4RangeTests(TestCase):
def setUp(self):
self.d = Domain(name="com")
self.d.save()
Domain(name="arpa").save()
Domain(name="in-addr.arpa").save()
Domain(name="10.in-addr.arpa").save()
self.s = Network(network_str="10.0.0.0/16", ip_type='4')
self.s.update_network()
self.s.save()
self.s1 = Network(network_str="10.2.1.0/24", ip_type='4')
self.s1.update_network()
self.s1.save()
def do_add(self, start_str, end_str, default_domain, \
network, rtype, ip_type):
r = Range(start_str=start_str, end_str=end_str, network=network,
ip_type=ip_type)
r.__repr__()
r.save()
return r
def test1_create(self):
start_str = "10.0.0.1"
end_str = "10.0.0.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
def test2_create(self):
start_str = "10.0.1.1"
end_str = "10.0.1.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
def test1_bad_create(self):
# start == end
start_str = "10.0.0.0"
end_str = "10.1.0.0"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test2_bad_create(self):
# start > end
start_str = "10.0.0.2"
end_str = "10.0.0.1"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test3_bad_create(self):
# outside of network
start_str = "11.0.0.2"
end_str = "10.0.0.88"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test4_bad_create(self):
# outside of network
start_str = "10.2.0.0"
end_str = "10.2.1.88"
default_domain = self.d
network = self.s1
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test5_bad_create(self):
# duplicate
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test6_bad_create(self):
# Partial overlap
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.4.1"
end_str = "10.0.4.30"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test7_bad_create(self):
# Partial overlap
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.4.1"
end_str = "10.0.4.56"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test8_bad_create(self):
# Full overlap
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.4.2"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test9_bad_create(self):
# Full overlap
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.4.2"
end_str = "10.0.4.54"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test10_bad_create(self):
# Duplicate add
start_str = "10.0.4.1"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.5.2"
end_str = "10.0.5.56"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test11_bad_create(self):
# More overlap tests
start_str = "10.0.4.5"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.4.60"
end_str = "10.0.4.63"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.4.1"
end_str = "10.0.4.4"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.4.2"
end_str = "10.0.4.54"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test12_bad_create(self):
# Update range to something outside of the subnet.
start_str = "10.0.4.5"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.4.60"
end_str = "10.0.4.63"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "10.0.4.1"
end_str = "10.0.4.4"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
r = self.do_add(**kwargs)
r.end_str = "160.0.4.60"
self.assertRaises(ValidationError, r.clean)
def test13_bad_create(self):
start_str = "10.0.4.5"
end_str = "10.0.4.55"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test1_freeip(self):
start_str = "10.0.33.1"
end_str = "10.0.33.3"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '4'
system = System()
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain, 'network': network,
'rtype': rtype, 'ip_type': ip_type}
r = self.do_add(**kwargs)
self.assertEqual(str(r.get_next_ip()), "10.0.33.1")
self.assertEqual(str(r.get_next_ip()), "10.0.33.1")
s = StaticInterface(label="foo", domain=self.d, ip_type='4',
ip_str=str(r.get_next_ip()), system=system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
self.assertEqual(str(r.get_next_ip()), "10.0.33.2")
s = StaticInterface(label="foo", domain=self.d, ip_type='4',
ip_str=str(r.get_next_ip()), system=system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
self.assertEqual(str(r.get_next_ip()), "10.0.33.3")
s = StaticInterface(label="foo", domain=self.d, ip_type='4',
ip_str=str(r.get_next_ip()), system=system,
mac="00:00:00:00:00:00")
s.clean()
s.save()
self.assertEqual(r.get_next_ip(), None)
def test1_create_ipv4_interface_network_str(self):
v, _ = Vlan.objects.get_or_create(name="12db", number=3)
s, _ = Site.objects.get_or_create(name="12scl3")
d, _ = Domain.objects.get_or_create(name="12scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="12db.12scl3.mozilla.com")
d, _ = Domain.objects.get_or_create(name="arpa")
d, _ = Domain.objects.get_or_create(name="in-addr.arpa")
d, _ = Domain.objects.get_or_create(name="12.in-addr.arpa")
n = Network(network_str="12.0.0.0/24", ip_type="4")
n.clean()
n.site = s
n.vlan = v
n.save()
n1 = Network(network_str="12.0.1.0/24", ip_type="4")
n1.clean()
n1.site = s
n1.vlan = v
n1.save()
r = Range(start_str="12.0.0.0",
end_str="12.0.0.2",
network=n,
ip_type='4')
r.clean()
r.save()
r1 = Range(start_str="12.0.1.0",
end_str="12.0.1.2",
network=n1,
ip_type='4')
r1.clean()
r1.save()
intr, errors = create_ipv4_interface("foo", "12db", "12scl3",
self.system, "11:22:33:4e:55:66",
"mozilla.com")
self.assertTrue('network' in errors)
self.assertTrue(
errors['network'][0].find("too many networks associated") != -1)
# Look for a non-existant network
intr, errors = create_ipv4_interface("foo",
"12db",
"12scl3",
self.system,
"11:22:33:4e:55:66",
"mozilla.com",
network_str="12.0.99.0/24")
self.assertTrue('network' in errors)
intr, errors = create_ipv4_interface("foo",
"12db",
"12scl3",
self.system,
"11:22:33:4e:55:66",
"mozilla.com",
network_str="12.0.0.0/24")
self.assertFalse(errors)
self.assertTrue(isinstance(intr, StaticInterface))
def search_ip(request):
if request.method == "POST":
form = IpSearchForm(request.POST)
try:
if form.is_valid():
ip_type = form.cleaned_data['ip_type']
search_ip = form.cleaned_data['search_ip']
try:
if ip_type == '4':
network = ipaddr.IPv4Network(search_ip)
if ip_type == '6':
network = ipaddr.IPv6Network(search_ip)
except ipaddr.AddressValueError, e:
form._errors['__all__'] = ErrorList(
["Bad IPv{0} Address {1}".format(ip_type, search_ip)])
return render(request, 'cydhcp/cydhcp_form.html',
{'form': form})
try:
network = Network.objects.get(network_str=search_ip)
search_ip = network
found_exact = True
except ObjectDoesNotExist:
found_exact = False
network = Network(ip_type,
network_str=search_ip,
ip_type=ip_type)
parent = calc_parent(network)
eldars, sub_networks = calc_networks(network)
if ip_type == '6':
sip_upper, sip_lower = ipv6_to_longs(network.network.ip)
eip_upper, eip_lower = ipv6_to_longs(
network.network.broadcast)
else:
sip_upper, sip_lower = 0, int(network.network.ip)
eip_upper, eip_lower = 0, int(network.network.broadcast)
addrs_count = AddressRecord.objects.filter(
ip_upper__gte=sip_upper,
ip_lower__gte=sip_lower,
ip_upper__lte=eip_upper,
ip_lower__lte=eip_lower).count()
if addrs_count > 100:
addrs = None # This is too much
else:
addrs = AddressRecord.objects.filter(
ip_upper__gte=sip_upper,
ip_lower__gte=sip_lower,
ip_upper__lte=eip_upper,
ip_lower__lte=eip_lower)
ptrs_count = PTR.objects.filter(
ip_upper__gte=sip_upper,
ip_lower__gte=sip_lower,
ip_upper__lte=eip_upper,
ip_lower__lte=eip_lower).count()
if ptrs_count > 100:
ptrs = None # This is too much
else:
ptrs = PTR.objects.filter(ip_upper__gte=sip_upper,
ip_lower__gte=sip_lower,
ip_upper__lte=eip_upper,
ip_lower__lte=eip_lower)
return render(
request, 'cydhcp/cydhcp_results.html', {
'search_ip': search_ip,
'found_exact': found_exact,
'addrs': addrs,
'addrs_count': addrs_count,
'ptrs_count': ptrs_count,
'ptrs': ptrs,
'parent': parent,
'eldars': eldars,
'sub_networks': sub_networks,
})
except ValidationError, e:
form._errors['__all__'] = ErrorList(e.messages)
return render(request, 'cydhcp/cydhcp_form.html', {'form': form})
class V6RangeTests(TestCase):
def setUp(self):
self.d = Domain(name="com")
self.s = Network(network_str="1234:1234:1234::/16", ip_type='6')
self.s.update_network()
self.s.save()
self.s1 = Network(network_str="1234:1134:1234::/32", ip_type='6')
self.s1.update_network()
self.s1.save()
self.s2 = Network(network_str="fff::/4", ip_type='6')
self.s2.update_network()
self.s2.save()
self.s3 = Network(network_str="ffff::/4", ip_type='6')
self.s3.update_network()
self.s3.save()
def do_add(self, start_str, end_str, default_domain, network, \
rtype, ip_type):
r = Range(start_str=start_str,
end_str=end_str,
network=network,
ip_type=ip_type)
r.__repr__()
r.save()
return r
def test1_create(self):
start_str = "1234:1234:1234:1::"
end_str = "1234:1234:1234:1234:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
def test2_create(self):
start_str = "1234:1234:1234:1234::"
end_str = "1234:1234:1235:1234:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
def test3_create(self):
start_str = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fff0"
end_str = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe"
default_domain = self.d
network = self.s3
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
r = self.do_add(**kwargs)
self.assertEqual(r.start_upper, 0xffffffffffffffff)
self.assertEqual(r.start_lower, 0xfffffffffffffff0)
self.assertEqual(r.end_upper, 0xffffffffffffffff)
self.assertEqual(r.end_lower, 0xfffffffffffffffe)
"""
def test1_bad_create(self):
# start == end
start_str = "1234:1235:1234:1234::"
end_str = "1234:1235:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
"""
def test2_bad_create(self):
# start > end
start_str = "1234:1235:1234:1235::"
end_str = "1234:1235:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test3_bad_create(self):
# outside of network
start_str = "2235:1235:1234:1233::"
end_str = "2235:1235:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test4_bad_create(self):
# outside of network
start_str = "1234:1234:1234:1::"
end_str = "1234:1234:1234:1234:1234:1234::"
default_domain = self.d
network = self.s1
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test5_bad_create(self):
# duplicate
start_str = "1234:123e:1234:1234::"
end_str = "1234:123e:1235:1234:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
start_str = "1234:123e:1234:1234::"
end_str = "1234:123e:1235:1234:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test6_bad_create(self):
# Partial overlap
#start_str = "10.0.4.1"
#end_str = "10.0.4.55"
start_str = "fe:1::"
end_str = "fe:1:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
#start_str = "10.0.4.1"
#end_str = "10.0.4.30"
start_str = "fe:1::"
end_str = "fe:1:3::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test7_bad_create(self):
# Partial overlap
#start_str = "10.0.4.1"
#end_str = "10.0.4.55"
start_str = "fe1:1::"
end_str = "fe1:1:3::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
#start_str = "10.0.4.1"
#end_str = "10.0.4.56"
start_str = "fe1:1::"
end_str = "fe1:1:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test8_bad_create(self):
# Full overlap
#start_str = "10.0.4.1"
#end_str = "10.0.4.55"
start_str = "fe2:1::"
end_str = "fe2:1:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
#start_str = "10.0.4.2"
#end_str = "10.0.4.55"
start_str = "fe2:1:2::"
end_str = "fe2:1:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test9_bad_create(self):
# Full overlap
#start_str = "10.0.4.1"
#end_str = "10.0.4.55"
start_str = "fe3:1:1::"
end_str = "fe3:1:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
#start_str = "10.0.4.2"
#end_str = "10.0.4.54"
start_str = "fe3:1:2::"
end_str = "fe3:1:3::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test10_bad_create(self):
# Duplicate add
#start_str = "10.0.4.1"
#end_str = "10.0.4.55"
start_str = "fe5:1:1::"
end_str = "fe5:1:55::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
#start_str = "10.0.5.2"
#end_str = "10.0.5.56"
start_str = "fe5:1:56::"
end_str = "fe5:1:57::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test11_bad_create(self):
# More overlap tests
#start_str = "10.0.4.5"
#end_str = "10.0.4.55"
start_str = "fe6:4:5::"
end_str = "fe6:4:55::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
#start_str = "10.0.4.60"
#end_str = "10.0.4.63"
start_str = "fe6:4:60::"
end_str = "fe6:4:63::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
#start_str = "10.0.4.1"
#end_str = "10.0.4.4"
start_str = "fe6:4:1::"
end_str = "fe6:4:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
#start_str = "10.0.4.2"
#end_str = "10.0.4.54"
start_str = "fe6:4:2::"
end_str = "fe6:4:54::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test12_bad_create(self):
# Update range to something outside of the subnet.
#start_str = "10.0.4.5"
#end_str = "10.0.4.55"
start_str = "fe7:4:5::"
end_str = "fe7:4:55::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
#start_str = "10.0.4.60"
#end_str = "10.0.4.63"
start_str = "fe7:4:60::"
end_str = "fe7:4:63::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
#start_str = "10.0.4.1"
#end_str = "10.0.4.4"
start_str = "fe7:4:1::"
end_str = "fe7:4:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
r = self.do_add(**kwargs)
r.end_str = "ffff:ffff:ffff::"
self.assertRaises(ValidationError, r.clean)
def test13_bad_create(self):
#start_str = "10.0.4.5"
#end_str = "10.0.4.55"
start_str = "fe8:4:5::"
end_str = "fe8:4:55::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {
'start_str': start_str,
'end_str': end_str,
'default_domain': default_domain,
'network': network,
'rtype': rtype,
'ip_type': ip_type
}
self.do_add(**kwargs)
self.assertRaises(ValidationError, self.do_add, **kwargs)
site = Site.objects.get(name=site_str)
except ObjectDoesNotExist, e:
continue
queries, s_misc = sif(site)
range_queries += queries
misc = misc.union(s_misc)
for network_str in network_fs:
try:
# Guess which network type they are searching by looking for ':'
if network_str.find(':') > -1:
network = ipaddr.IPv6Address(
network_str=network_str, ip_type='6')
network.update_network()
else:
network = Network(network_str=network_str, ip_type='4')
network.update_network()
except ValidationError, e:
continue
except ipaddr.AddressValueError, e:
continue
queries, n_misc = nif(network)
range_queries += queries
misc = misc.union(n_misc)
for vlan_str in vlan_fs:
try:
vlan = Vlan.objects.get(name=vlan_str)
except ObjectDoesNotExist, e:
try:
vlan = Vlan.objects.get(name=vlan_str)
def calc_parent_str(network_str, ip_type):
network = Network(network_str=network_str, ip_type=ip_type)
return calc_parent(network)
class V6RangeTests(TestCase):
def setUp(self):
self.d = Domain(name="com")
self.s = Network(network_str="1234:1234:1234::/16", ip_type='6')
self.s.update_network()
self.s.save()
self.s1 = Network(network_str="1234:1134:1234::/32", ip_type='6')
self.s1.update_network()
self.s1.save()
self.s2 = Network(network_str="fff::/4", ip_type='6')
self.s2.update_network()
self.s2.save()
self.s3 = Network(network_str="ffff::/4", ip_type='6')
self.s3.update_network()
self.s3.save()
def do_add(self, start_str, end_str, default_domain, network, \
rtype, ip_type):
r = Range(start_str=start_str, end_str=end_str, network=network,
ip_type=ip_type)
r.__repr__()
r.save()
return r
def test1_create(self):
start_str = "1234:1234:1234:1::"
end_str = "1234:1234:1234:1234:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
def test2_create(self):
start_str = "1234:1234:1234:1234::"
end_str = "1234:1234:1235:1234:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
def test3_create(self):
start_str = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fff0"
end_str = "ffff:ffff:ffff:ffff:ffff:ffff:ffff:fffe"
default_domain = self.d
network = self.s3
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
r = self.do_add(**kwargs)
self.assertEqual(r.start_upper, 0xffffffffffffffff)
self.assertEqual(r.start_lower, 0xfffffffffffffff0)
self.assertEqual(r.end_upper, 0xffffffffffffffff)
self.assertEqual(r.end_lower, 0xfffffffffffffffe)
"""
def test1_bad_create(self):
# start == end
start_str = "1234:1235:1234:1234::"
end_str = "1234:1235:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
"""
def test2_bad_create(self):
# start > end
start_str = "1234:1235:1234:1235::"
end_str = "1234:1235:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test3_bad_create(self):
# outside of network
start_str = "2235:1235:1234:1233::"
end_str = "2235:1235:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test4_bad_create(self):
# outside of network
start_str = "1234:1234:1234:1::"
end_str = "1234:1234:1234:1234:1234:1234::"
default_domain = self.d
network = self.s1
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test5_bad_create(self):
# duplicate
start_str = "1234:123e:1234:1234::"
end_str = "1234:123e:1235:1234:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
start_str = "1234:123e:1234:1234::"
end_str = "1234:123e:1235:1234:1234:1234::"
default_domain = self.d
network = self.s
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test6_bad_create(self):
# Partial overlap
#start_str = "10.0.4.1"
#end_str = "10.0.4.55"
start_str = "fe:1::"
end_str = "fe:1:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
#start_str = "10.0.4.1"
#end_str = "10.0.4.30"
start_str = "fe:1::"
end_str = "fe:1:3::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test7_bad_create(self):
# Partial overlap
#start_str = "10.0.4.1"
#end_str = "10.0.4.55"
start_str = "fe1:1::"
end_str = "fe1:1:3::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
#start_str = "10.0.4.1"
#end_str = "10.0.4.56"
start_str = "fe1:1::"
end_str = "fe1:1:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test8_bad_create(self):
# Full overlap
#start_str = "10.0.4.1"
#end_str = "10.0.4.55"
start_str = "fe2:1::"
end_str = "fe2:1:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
#start_str = "10.0.4.2"
#end_str = "10.0.4.55"
start_str = "fe2:1:2::"
end_str = "fe2:1:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test9_bad_create(self):
# Full overlap
#start_str = "10.0.4.1"
#end_str = "10.0.4.55"
start_str = "fe3:1:1::"
end_str = "fe3:1:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
#start_str = "10.0.4.2"
#end_str = "10.0.4.54"
start_str = "fe3:1:2::"
end_str = "fe3:1:3::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test10_bad_create(self):
# Duplicate add
#start_str = "10.0.4.1"
#end_str = "10.0.4.55"
start_str = "fe5:1:1::"
end_str = "fe5:1:55::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
#start_str = "10.0.5.2"
#end_str = "10.0.5.56"
start_str = "fe5:1:56::"
end_str = "fe5:1:57::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test11_bad_create(self):
# More overlap tests
#start_str = "10.0.4.5"
#end_str = "10.0.4.55"
start_str = "fe6:4:5::"
end_str = "fe6:4:55::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
#start_str = "10.0.4.60"
#end_str = "10.0.4.63"
start_str = "fe6:4:60::"
end_str = "fe6:4:63::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
#start_str = "10.0.4.1"
#end_str = "10.0.4.4"
start_str = "fe6:4:1::"
end_str = "fe6:4:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
#start_str = "10.0.4.2"
#end_str = "10.0.4.54"
start_str = "fe6:4:2::"
end_str = "fe6:4:54::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.assertRaises(ValidationError, self.do_add, **kwargs)
def test12_bad_create(self):
# Update range to something outside of the subnet.
#start_str = "10.0.4.5"
#end_str = "10.0.4.55"
start_str = "fe7:4:5::"
end_str = "fe7:4:55::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
#start_str = "10.0.4.60"
#end_str = "10.0.4.63"
start_str = "fe7:4:60::"
end_str = "fe7:4:63::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
#start_str = "10.0.4.1"
#end_str = "10.0.4.4"
start_str = "fe7:4:1::"
end_str = "fe7:4:4::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
r = self.do_add(**kwargs)
r.end_str = "ffff:ffff:ffff::"
self.assertRaises(ValidationError, r.clean)
def test13_bad_create(self):
#start_str = "10.0.4.5"
#end_str = "10.0.4.55"
start_str = "fe8:4:5::"
end_str = "fe8:4:55::"
default_domain = self.d
network = self.s2
rtype = 's'
ip_type = '6'
kwargs = {'start_str': start_str, 'end_str': end_str,
'default_domain': default_domain,
'network': network, 'rtype': rtype, 'ip_type': ip_type}
self.do_add(**kwargs)
self.assertRaises(ValidationError, self.do_add, **kwargs)
