def testIsHostname(self):
self.assertTrue(self.data_validation_instance.isHostname(
u'university.edu.'))
self.assertTrue(self.data_validation_instance.isHostname(
u'blah.university.edu.'))
self.assertFalse(self.data_validation_instance.isHostname(
u'university.edu'))
self.assertFalse(self.data_validation_instance.isHostname(u'.edu.'))
self.assertFalse(self.data_validation_instance.isHostname(u'not_valid'))
self.assertFalse(self.data_validation_instance.isHostname(2))
#Despite what I have written in these hostnames, don't actually read them
#and believe what they say.
ok_hostname_1 = '%s' % (u'this.is.a.super.long.target.host.name.'
'that.should.trip.the.length.check.in.'
'core.helpers.and.if.it.doesnt.we.have.'
'problems.and.need.to.fix.something.or.'
'roster.will.ship.with.bugs.but.software.'
'has.been.shipped.with.bugs.before.so.'
'maybe.it.wont.be.too.awful.')
hostname_too_long = '%s' % (u'this.is.a.super.long.target.host.name.'
'that.should.trip.the.length.check.in.'
'core.helpers.and.if.it.doesnt.we.have.'
'problems.and.need.to.fix.something.or.'
'roster.will.ship.with.bugs.but.software.'
'has.been.shipped.with.bugs.before.so.'
'maybe.it.wont.be.tooo.awful.')
ok_hostname_2 = '%s' % (u'thisisanothersuperlongtargethostnamethat'
'shouldtripthecheckincor.helpers.for.'
'having.a.component.that.is.too.long.')
hostname_component_too_long = '%s' % (u'thisisanothersuperlongtargethost'
'namethatshouldtripthecheckincore.'
'helpers.for.having.a.component.'
'that.is.to.long.')
#Just long enough to be valid
self.assertEqual(len(punycode_lib.Uni2Puny(ok_hostname_1)), 255)
self.assertTrue(self.data_validation_instance.isHostname(ok_hostname_1))
#Just long enough to be invalid
self.assertEqual(len(punycode_lib.Uni2Puny(hostname_too_long)), 256)
self.assertFalse(
self.data_validation_instance.isHostname(hostname_too_long))
#First component is just long enough to be valid
self.assertEqual(len(punycode_lib.Uni2Puny(ok_hostname_2.split('.')[0])),
63)
self.assertTrue(self.data_validation_instance.isHostname(ok_hostname_2))
#First component is just long enough to be invalid
self.assertEqual(
len(punycode_lib.Uni2Puny(hostname_component_too_long.split('.')[0])),
64)
self.assertFalse(
self.data_validation_instance.isHostname(hostname_component_too_long))
def testPunycodeModule(self):
file = codecs.open('test_data/snowman', mode='r', encoding='utf-8')
unicode = file.read().replace('\n', '')
self.assertEqual(unicode, u'\u2603\u2190\u2191.sn')
punycode = punycode_lib.Uni2Puny(unicode)
self.assertEqual(punycode, 'xn--35gc625a.sn')
unicode = punycode_lib.Puny2Uni(punycode)
self.assertEqual(unicode, u'\u2603\u2190\u2191.sn')
ascii = 'sub.ascii.com.'
punycode = punycode_lib.Uni2Puny(ascii)
self.assertEqual(punycode, ascii)
ascii = punycode_lib.Puny2Uni(punycode)
self.assertEqual(ascii, punycode)
def testisTarget(self):
#Despite what I have written in these targets, don't actually read them
#and believe what they say.
target_too_long = '%s' % ('this.is.a.super.long.target.host.name.that.'
'should.trip.the.length.check.in.core.helpers.'
'and.if.it.doesnt.we.have.problems.and.need.to.'
'fix.something.or.roster.will.ship.with.bugs.but.'
'software.has.been.shipped.with.bugs.before.so.'
'maybe.it.wont.be.too.bad.com')
ok_target_1 = '%s' % ('this.is.a.super.long.target.host.name.that.should.'
'trip.the.length.check.in.core.helpers.and.if.it.'
'doesnt.we.have.problems.and.need.to.fix.something.'
'or.roster.will.ship.with.bugs.but.software.has.been.'
'shipped.with.bugs.before.so.maybe.it.wont.be.too.'
'bad.co')
target_component_too_long = '%s' % ('thisisanothersuperlongtargethostname'
'thatshouldtripthecheckincore.helpers.'
'for.having.a.component.that.is.too.'
'long')
ok_target_2 = '%s' % ('thisisanothersuperlongtargethostnamethatshouldtrip'
'thecheckincor.helpers.for.having.a.component.that.'
'is.too.long')
self.assertEqual(len(punycode_lib.Uni2Puny(ok_target_1)), 255)
self.assertTrue(self.data_validation_instance.isTarget(ok_target_1))
self.assertEqual(len(punycode_lib.Uni2Puny(target_too_long)), 256)
self.assertFalse(self.data_validation_instance.isTarget(target_too_long))
self.assertEqual(len(punycode_lib.Uni2Puny(ok_target_2.split('.')[0])), 63)
self.assertTrue(self.data_validation_instance.isTarget(ok_target_2))
self.assertEqual(
len(punycode_lib.Uni2Puny(target_component_too_long.split('.')[0])), 64)
self.assertFalse(
self.data_validation_instance.isTarget(target_component_too_long))
#Now we basically do the entire test over again but with unicode targets,
#just to make sure. (I don't think it's necessary but whatever)
self.assertEqual(len(punycode_lib.Uni2Puny(unicode(ok_target_1))), 255)
self.assertTrue(self.data_validation_instance.isTarget(ok_target_1))
self.assertEqual(len(punycode_lib.Uni2Puny(unicode(target_too_long))), 256)
self.assertFalse(self.data_validation_instance.isTarget(target_too_long))
self.assertEqual(
len(punycode_lib.Uni2Puny(unicode(ok_target_2).split('.')[0])), 63)
self.assertTrue(self.data_validation_instance.isTarget(ok_target_2))
self.assertEqual(len(punycode_lib.Uni2Puny(
unicode(target_component_too_long).split('.')[0])), 64)
self.assertFalse(
self.data_validation_instance.isTarget(target_component_too_long))
def isTarget(self, target):
"""Checks that a target and it's components have the correct length
Inputs:
target: target string
Outputs:
bool: if it is a valid target"""
target = punycode_lib.Uni2Puny(unicode(target))
if (len(target) > 255):
return False
for component in target.split('.'):
if (len(component) > 63):
return False
return True
def CookData(self, data):
"""Cooks data for zone exporter
Inputs:
data: dictionary of raw data from database
Outputs:
dict: dictionary with dns_server_sets and dns_servers keys, then keyed by
dns_server_set and dns_server, respectively ex:
{u'dns_server_sets':
{u'external_dns':
{'dns_servers': [u'[ns1.university.edu]',
u'[dns2.university.edu]',
u'[dns3.university.edu]']}
'views':
{u'external':
{u'university.edu':
{'records': [
{u'serial_number': 20091227,
u'refresh_seconds': 5,
'target': u'university.edu.',
u'name_server': u'ns1.university.edu.',
u'retry_seconds': 5, 'ttl': 3600,
u'minimum_seconds': 5, 'record_type': u'soa',
'view_name': u'external',
'last_user': u'sharrell',
'zone_name': u'university.edu',
u'admin_email': u'[email protected].',
u'expiry_seconds': 5},
{'target': u'computer1', 'ttl': 3600,
'record_type': u'a', 'view_name': u'external',
'last_user': u'sharrell',
'zone_name': u'university.edu',
u'assignment_ip': u'1.2.3.5'},
'zone_origin': u'example.',
'zone_type': u'master'}}}},
u'dns_servers':
{u'ns1.university.edu':
{'dns_server_remote_bind_directory': u'/etc/named/',
'dns_server_remote_test_directory': u'/etc/named/test/',
'dns_server_ssh_username': u'dchayes'},
u'dns2.university.edu':
{'dns_server_remote_bind_directory': u'/etc/bind/',
'dns_server_remote_test_directory': u'/etc/bind/test/',
'dns_server_ssh_username': u'ssh_user'}}}
u'dns3.university.edu':
{'dns_server_remote_bind_directory': u'/etc/bind/',
'dns_server_remote_test_directory': u'/etc/bind/test/',
'dns_server_ssh_username': u'dchayes'}}}
"""
cooked_data = {}
cooked_data['dns_server_sets'] = {}
cooked_data['dns_servers'] = {}
sorted_records = self.SortRecords(data['records'])
for dns_server_set in data['dns_server_sets']:
dns_server_set_name = dns_server_set['dns_server_set_name']
if (not dns_server_set_name in cooked_data['dns_server_sets']):
cooked_data['dns_server_sets'][dns_server_set_name] = {}
if (not 'dns_servers'
in cooked_data['dns_server_sets'][dns_server_set_name]):
cooked_data['dns_server_sets'][dns_server_set_name][
'dns_servers'] = []
if (not 'views'
in cooked_data['dns_server_sets'][dns_server_set_name]):
cooked_data['dns_server_sets'][dns_server_set_name][
'views'] = {}
for dns_server_set_assignment in data[
'dns_server_set_assignments']:
if (dns_server_set_assignment[
'dns_server_set_assignments_dns_server_set_name']
== dns_server_set['dns_server_set_name']
and dns_server_set_assignment[
'dns_server_set_assignments_dns_server_name']
not in cooked_data['dns_server_sets']
[dns_server_set_name]['dns_servers']):
cooked_data['dns_server_sets'][dns_server_set_name][
'dns_servers'].append(dns_server_set_assignment[
'dns_server_set_assignments_dns_server_name'])
cooked_data['dns_server_sets'][dns_server_set_name][
'view_order'] = {}
for dns_server_set_view_assignment in data[
'dns_server_set_view_assignments']:
dns_server_set_name = dns_server_set_view_assignment[
'dns_server_set_view_assignments_dns_server_set_name']
view_name = dns_server_set_view_assignment[
'dns_server_set_view_assignments_view_name']
view_order = dns_server_set_view_assignment['view_order']
view_options = dns_server_set_view_assignment['view_options']
if (dns_server_set_name ==
dns_server_set['dns_server_set_name']):
cooked_data['dns_server_sets'][dns_server_set_name][
'view_order'][view_order] = view_name
for view_dependency in data['view_dependency_assignments']:
if (view_name == view_dependency[
'view_dependency_assignments_view_name']):
if (not view_name in cooked_data['dns_server_sets']
[dns_server_set_name]['views']):
cooked_data['dns_server_sets'][
dns_server_set_name]['views'][
view_name] = {}
for view_names in data['views']:
if (view_names['view_name'] == view_name):
cooked_data['dns_server_sets'][
dns_server_set_name]['views'][
view_name]['view_options'] = (
iscpy.Deserialize(
view_options).replace(
'\n', '\n\t'))
break
if (not 'acls' in cooked_data['dns_server_sets']
[dns_server_set_name]['views'][view_name]):
cooked_data['dns_server_sets'][
dns_server_set_name]['views'][view_name][
'acls'] = self.ListACLNamesByView(
data, view_name)
if (not 'zones' in cooked_data['dns_server_sets']
[dns_server_set_name]['views'][view_name]):
cooked_data['dns_server_sets'][
dns_server_set_name]['views'][view_name][
'zones'] = {}
for zone in data['zone_view_assignments']:
view_dependency_name = view_dependency[
'view_dependency_assignments_view_dependency']
zone_name = zone[
'zone_view_assignments_zone_name']
if (view_dependency_name == zone[
'zone_view_assignments_view_dependency']
and
((zone_name, view_dependency_name)
in sorted_records
or zone['zone_view_assignments_zone_type']
== 'slave')):
if (not zone_name
in cooked_data['dns_server_sets']
[dns_server_set_name]['views']
[view_name]['zones']):
cooked_data['dns_server_sets'][
dns_server_set_name]['views'][
view_name]['zones'][
zone_name] = {}
if ('records' not in
cooked_data['dns_server_sets']
[dns_server_set_name]['views']
[view_name]['zones'][zone_name]):
cooked_data['dns_server_sets'][
dns_server_set_name]['views'][
view_name]['zones'][zone_name][
'records'] = []
cooked_data['dns_server_sets'][
dns_server_set_name]['views'][
view_name]['zones'][zone_name][
'zone_origin'] = (
punycode_lib.Uni2Puny(
zone['zone_origin']))
cooked_data['dns_server_sets'][
dns_server_set_name]['views'][
view_name]['zones'][zone_name][
'zone_options'] = iscpy.Deserialize(
zone['zone_options'])
cooked_data['dns_server_sets'][
dns_server_set_name]['views'][
view_name]['zones'][zone_name][
'zone_type'] = zone[
'zone_view_assignments_zone_type']
# if the zone is a slave
if ((zone_name, view_dependency_name)
not in sorted_records):
continue
for record in sorted_records[(
zone_name,
view_dependency_name)].values():
try:
record[
'target'] = punycode_lib.Uni2Puny(
record['target'])
except (KeyError):
pass
try:
record[
'assignment_host'] = punycode_lib.Uni2Puny(
record['assignment_host'])
except (KeyError):
pass
cooked_data['dns_server_sets'][
dns_server_set_name]['views'][
view_name]['zones'][zone_name][
'records'].extend(
sorted_records[(
zone_name,
view_dependency_name
)].values())
# Insert dns_servers into cooked_data
for dns_server in data['dns_servers']:
dns_server_name = dns_server['dns_server_name']
if (not dns_server_name in cooked_data['dns_servers']):
cooked_data['dns_servers'][dns_server_name] = {}
cooked_data['dns_servers'][dns_server_name][
'dns_server_ssh_username'] = (
dns_server['dns_server_ssh_username'])
cooked_data['dns_servers'][dns_server_name][
'dns_server_remote_test_directory'] = dns_server[
'dns_server_remote_test_directory']
cooked_data['dns_servers'][dns_server_name][
'dns_server_remote_bind_directory'] = dns_server[
'dns_server_remote_bind_directory']
return cooked_data
def testUni2Puny(self):
file = codecs.open('test_data/snowman', mode='r', encoding='utf-8')
unicode = file.read().replace('\n', '')
self.assertEqual(unicode, u'\u2603\u2190\u2191.sn')
punycode = punycode_lib.Uni2Puny(unicode)
self.assertEqual(punycode, 'xn--35gc625a.sn')