mirror of
https://github.com/github/octodns.git
synced 2024-05-11 05:55:00 +00:00
331 lines
10 KiB
Python
331 lines
10 KiB
Python
#
|
|
#
|
|
#
|
|
|
|
from unittest import TestCase
|
|
|
|
from helpers import SimpleProvider
|
|
|
|
from octodns.record.base import Record
|
|
from octodns.record.exception import ValidationError
|
|
from octodns.record.rr import RrParseError
|
|
from octodns.record.sshfp import SshfpRecord, SshfpValue
|
|
from octodns.zone import Zone
|
|
|
|
|
|
class TestRecordSshfp(TestCase):
|
|
zone = Zone('unit.tests.', [])
|
|
|
|
def test_sshfp(self):
|
|
a_values = [
|
|
SshfpValue(
|
|
{
|
|
'algorithm': 10,
|
|
'fingerprint_type': 11,
|
|
'fingerprint': 'abc123',
|
|
}
|
|
),
|
|
SshfpValue(
|
|
{
|
|
'algorithm': 20,
|
|
'fingerprint_type': 21,
|
|
'fingerprint': 'def456',
|
|
}
|
|
),
|
|
]
|
|
a_data = {'ttl': 30, 'values': a_values}
|
|
a = SshfpRecord(self.zone, 'a', a_data)
|
|
self.assertEqual('a', a.name)
|
|
self.assertEqual('a.unit.tests.', a.fqdn)
|
|
self.assertEqual(30, a.ttl)
|
|
self.assertEqual(a_values[0]['algorithm'], a.values[0].algorithm)
|
|
self.assertEqual(
|
|
a_values[0]['fingerprint_type'], a.values[0].fingerprint_type
|
|
)
|
|
self.assertEqual(a_values[0]['fingerprint'], a.values[0].fingerprint)
|
|
self.assertEqual(a_data, a.data)
|
|
|
|
b_value = SshfpValue(
|
|
{'algorithm': 30, 'fingerprint_type': 31, 'fingerprint': 'ghi789'}
|
|
)
|
|
b_data = {'ttl': 30, 'value': b_value}
|
|
b = SshfpRecord(self.zone, 'b', b_data)
|
|
self.assertEqual(b_value['algorithm'], b.values[0].algorithm)
|
|
self.assertEqual(
|
|
b_value['fingerprint_type'], b.values[0].fingerprint_type
|
|
)
|
|
self.assertEqual(b_value['fingerprint'], b.values[0].fingerprint)
|
|
self.assertEqual(b_data, b.data)
|
|
|
|
target = SimpleProvider()
|
|
# No changes with self
|
|
self.assertFalse(a.changes(a, target))
|
|
# Diff in algorithm causes change
|
|
other = SshfpRecord(self.zone, 'a', {'ttl': 30, 'values': a_values})
|
|
other.values[0].algorithm = 22
|
|
change = a.changes(other, target)
|
|
self.assertEqual(change.existing, a)
|
|
self.assertEqual(change.new, other)
|
|
# Diff in fingerprint_type causes change
|
|
other = SshfpRecord(self.zone, 'a', {'ttl': 30, 'values': a_values})
|
|
other.values[0].algorithm = a.values[0].algorithm
|
|
other.values[0].fingerprint_type = 22
|
|
change = a.changes(other, target)
|
|
self.assertEqual(change.existing, a)
|
|
self.assertEqual(change.new, other)
|
|
# Diff in fingerprint causes change
|
|
other = SshfpRecord(self.zone, 'a', {'ttl': 30, 'values': a_values})
|
|
other.values[0].fingerprint_type = a.values[0].fingerprint_type
|
|
other.values[0].fingerprint = 22
|
|
change = a.changes(other, target)
|
|
self.assertEqual(change.existing, a)
|
|
self.assertEqual(change.new, other)
|
|
|
|
# __repr__ doesn't blow up
|
|
a.__repr__()
|
|
|
|
def test_sshfp_value_rdata_text(self):
|
|
|
|
# empty string won't parse
|
|
with self.assertRaises(RrParseError):
|
|
SshfpValue.parse_rdata_text('')
|
|
|
|
# single word won't parse
|
|
with self.assertRaises(RrParseError):
|
|
SshfpValue.parse_rdata_text('nope')
|
|
|
|
# 3rd word won't parse
|
|
with self.assertRaises(RrParseError):
|
|
SshfpValue.parse_rdata_text('0 1 00479b27 another')
|
|
|
|
# algorithm and fingerprint_type not ints
|
|
self.assertEqual(
|
|
{
|
|
'algorithm': 'one',
|
|
'fingerprint_type': 'two',
|
|
'fingerprint': '00479b27',
|
|
},
|
|
SshfpValue.parse_rdata_text('one two 00479b27'),
|
|
)
|
|
|
|
# valid
|
|
self.assertEqual(
|
|
{'algorithm': 1, 'fingerprint_type': 2, 'fingerprint': '00479b27'},
|
|
SshfpValue.parse_rdata_text('1 2 00479b27'),
|
|
)
|
|
|
|
zone = Zone('unit.tests.', [])
|
|
a = SshfpRecord(
|
|
zone,
|
|
'sshfp',
|
|
{
|
|
'ttl': 32,
|
|
'value': {
|
|
'algorithm': 1,
|
|
'fingerprint_type': 2,
|
|
'fingerprint': '00479b27',
|
|
},
|
|
},
|
|
)
|
|
self.assertEqual(1, a.values[0].algorithm)
|
|
self.assertEqual(2, a.values[0].fingerprint_type)
|
|
self.assertEqual('00479b27', a.values[0].fingerprint)
|
|
self.assertEqual('1 2 00479b27', a.values[0].rdata_text)
|
|
|
|
def test_sshfp_value(self):
|
|
a = SshfpValue(
|
|
{'algorithm': 0, 'fingerprint_type': 0, 'fingerprint': 'abcd'}
|
|
)
|
|
b = SshfpValue(
|
|
{'algorithm': 1, 'fingerprint_type': 0, 'fingerprint': 'abcd'}
|
|
)
|
|
c = SshfpValue(
|
|
{'algorithm': 0, 'fingerprint_type': 1, 'fingerprint': 'abcd'}
|
|
)
|
|
d = SshfpValue(
|
|
{'algorithm': 0, 'fingerprint_type': 0, 'fingerprint': 'bcde'}
|
|
)
|
|
|
|
self.assertEqual(a, a)
|
|
self.assertEqual(b, b)
|
|
self.assertEqual(c, c)
|
|
self.assertEqual(d, d)
|
|
|
|
self.assertNotEqual(a, b)
|
|
self.assertNotEqual(a, c)
|
|
self.assertNotEqual(a, d)
|
|
self.assertNotEqual(b, a)
|
|
self.assertNotEqual(b, c)
|
|
self.assertNotEqual(b, d)
|
|
self.assertNotEqual(c, a)
|
|
self.assertNotEqual(c, b)
|
|
self.assertNotEqual(c, d)
|
|
self.assertNotEqual(d, a)
|
|
self.assertNotEqual(d, b)
|
|
self.assertNotEqual(d, c)
|
|
|
|
self.assertTrue(a < b)
|
|
self.assertTrue(a < c)
|
|
|
|
self.assertTrue(b > a)
|
|
self.assertTrue(b > c)
|
|
|
|
self.assertTrue(c > a)
|
|
self.assertTrue(c < b)
|
|
|
|
self.assertTrue(a <= b)
|
|
self.assertTrue(a <= c)
|
|
self.assertTrue(a <= a)
|
|
self.assertTrue(a >= a)
|
|
|
|
self.assertTrue(b >= a)
|
|
self.assertTrue(b >= c)
|
|
self.assertTrue(b >= b)
|
|
self.assertTrue(b <= b)
|
|
|
|
self.assertTrue(c >= a)
|
|
self.assertTrue(c <= b)
|
|
self.assertTrue(c >= c)
|
|
self.assertTrue(c <= c)
|
|
|
|
# Hash
|
|
values = set()
|
|
values.add(a)
|
|
self.assertTrue(a in values)
|
|
self.assertFalse(b in values)
|
|
values.add(b)
|
|
self.assertTrue(b in values)
|
|
|
|
def test_validation(self):
|
|
# doesn't blow up
|
|
Record.new(
|
|
self.zone,
|
|
'',
|
|
{
|
|
'type': 'SSHFP',
|
|
'ttl': 600,
|
|
'value': {
|
|
'algorithm': 1,
|
|
'fingerprint_type': 1,
|
|
'fingerprint': 'bf6b6825d2977c511a475bbefb88aad54a92ac73',
|
|
},
|
|
},
|
|
)
|
|
|
|
# missing algorithm
|
|
with self.assertRaises(ValidationError) as ctx:
|
|
Record.new(
|
|
self.zone,
|
|
'',
|
|
{
|
|
'type': 'SSHFP',
|
|
'ttl': 600,
|
|
'value': {
|
|
'fingerprint_type': 1,
|
|
'fingerprint': 'bf6b6825d2977c511a475bbefb88aad54a92ac73',
|
|
},
|
|
},
|
|
)
|
|
self.assertEqual(['missing algorithm'], ctx.exception.reasons)
|
|
|
|
# invalid algorithm
|
|
with self.assertRaises(ValidationError) as ctx:
|
|
Record.new(
|
|
self.zone,
|
|
'',
|
|
{
|
|
'type': 'SSHFP',
|
|
'ttl': 600,
|
|
'value': {
|
|
'algorithm': 'nope',
|
|
'fingerprint_type': 2,
|
|
'fingerprint': 'bf6b6825d2977c511a475bbefb88aad54a92ac73',
|
|
},
|
|
},
|
|
)
|
|
self.assertEqual(['invalid algorithm "nope"'], ctx.exception.reasons)
|
|
|
|
# unrecognized algorithm
|
|
with self.assertRaises(ValidationError) as ctx:
|
|
Record.new(
|
|
self.zone,
|
|
'',
|
|
{
|
|
'type': 'SSHFP',
|
|
'ttl': 600,
|
|
'value': {
|
|
'algorithm': 42,
|
|
'fingerprint_type': 1,
|
|
'fingerprint': 'bf6b6825d2977c511a475bbefb88aad54a92ac73',
|
|
},
|
|
},
|
|
)
|
|
self.assertEqual(['unrecognized algorithm "42"'], ctx.exception.reasons)
|
|
|
|
# missing fingerprint_type
|
|
with self.assertRaises(ValidationError) as ctx:
|
|
Record.new(
|
|
self.zone,
|
|
'',
|
|
{
|
|
'type': 'SSHFP',
|
|
'ttl': 600,
|
|
'value': {
|
|
'algorithm': 2,
|
|
'fingerprint': 'bf6b6825d2977c511a475bbefb88aad54a92ac73',
|
|
},
|
|
},
|
|
)
|
|
self.assertEqual(['missing fingerprint_type'], ctx.exception.reasons)
|
|
|
|
# invalid fingerprint_type
|
|
with self.assertRaises(ValidationError) as ctx:
|
|
Record.new(
|
|
self.zone,
|
|
'',
|
|
{
|
|
'type': 'SSHFP',
|
|
'ttl': 600,
|
|
'value': {
|
|
'algorithm': 3,
|
|
'fingerprint_type': 'yeeah',
|
|
'fingerprint': 'bf6b6825d2977c511a475bbefb88aad54a92ac73',
|
|
},
|
|
},
|
|
)
|
|
self.assertEqual(
|
|
['invalid fingerprint_type "yeeah"'], ctx.exception.reasons
|
|
)
|
|
|
|
# unrecognized fingerprint_type
|
|
with self.assertRaises(ValidationError) as ctx:
|
|
Record.new(
|
|
self.zone,
|
|
'',
|
|
{
|
|
'type': 'SSHFP',
|
|
'ttl': 600,
|
|
'value': {
|
|
'algorithm': 1,
|
|
'fingerprint_type': 42,
|
|
'fingerprint': 'bf6b6825d2977c511a475bbefb88aad54a92ac73',
|
|
},
|
|
},
|
|
)
|
|
self.assertEqual(
|
|
['unrecognized fingerprint_type "42"'], ctx.exception.reasons
|
|
)
|
|
|
|
# missing fingerprint
|
|
with self.assertRaises(ValidationError) as ctx:
|
|
Record.new(
|
|
self.zone,
|
|
'',
|
|
{
|
|
'type': 'SSHFP',
|
|
'ttl': 600,
|
|
'value': {'algorithm': 1, 'fingerprint_type': 1},
|
|
},
|
|
)
|
|
self.assertEqual(['missing fingerprint'], ctx.exception.reasons)
|