1

import ipaddr

     2

import unittest

     3

     4

from pvl.hosts import config, host, zone

     5

from StringIO import StringIO

     6

     7

class Options(object):

     8

    hosts_charset   = 'utf-8'

     9

    hosts_domain    = None

    10

    hosts_include   = None

    11

    12

class ConfFile(StringIO):

    13

    def __init__(self, name, buffer):

    14

        StringIO.__init__(self, buffer)

    15

        self.name = name

    16

    17

class TestConfig(unittest.TestCase):

    18

    def setUp(self):

    19

        self.options = Options()

    20

    21

    def assertHostEqual(self, host, host_str, attrs):

    22

        self.assertEquals(str(host), host_str)

    23

    24

        for attr, value in attrs.iteritems():

    25

            self.assertEquals(getattr(host, attr), value)

    26

    27

    def assertHostsEqual(self, hosts, expected):

    28

        for host, expect in zip(hosts, expected):

    29

            host_str, attrs = expect

    30

    31

            self.assertHostEqual(host, host_str, attrs)

    32

    33

    def testApplyHostsFileError(self):

    34

        with self.assertRaises(config.HostConfigError):

    35

            list(config.apply_hosts(self.options, ['nonexistant']))

    36

    37

    def testApplyHosts(self):

    38

        conf_file = ConfFile('test', """

    39

[foo]

    40

    ip = 127.0.0.1

    41

    42

[bar]

    43

    ip = 127.0.0.2

    44

        """)

    45

        expected = [

    46

                ('foo@test', dict(ip=ipaddr.IPAddress('127.0.0.1'))),

    47

                ('bar@test', dict(ip=ipaddr.IPAddress('127.0.0.2'))),

    48

        ]

    49

    50

        self.assertHostsEqual(config.apply_hosts_file(self.options, conf_file), expected)

    51

    52

    def testApply(self):

    53

        self.assertHostsEqual(config.apply(self.options, ['etc/hosts/test']), [

    54

                ('foo@test', dict(

    55

                    ip          = ipaddr.IPAddress('127.0.0.1'),

    56

                    ethernet    = {None: '00:11:22:33:44:55'},

    57

                )),

    58

                ('bar@test', dict(

    59

                    ip          = ipaddr.IPAddress('127.0.0.2'),

    60

                    ethernet    = {None: '01:23:45:67:89:ab'},

    61

                )),

    62

        ])

    63

    64

    def testApplyHostsExpand(self):

    65

        self.assertHostsEqual(config.apply_host_config(self.options, 'asdf', 'asdf{1-3}', ip='10.100.100.$'), [

    66

                ('asdf1@asdf', dict(ip=ipaddr.IPAddress('10.100.100.1'))),

    67

                ('asdf2@asdf', dict(ip=ipaddr.IPAddress('10.100.100.2'))),

    68

                ('asdf3@asdf', dict(ip=ipaddr.IPAddress('10.100.100.3'))),

    69

        ])

    70

    71

    def testApplyHostConfigDict(self):

    72

        host = config.apply_host(self.options, 'foo', 'test', {

    73

            'ethernet.eth0': '00:11:22:33:44:55',

    74

        })

    75

    76

        self.assertHostEqual(host, 'foo@test', dict(

    77

                ethernet    = { 'eth0': '00:11:22:33:44:55' }

    78

        ))

    79

    80

    def testApplyHostsConfigError(self):

    81

        with self.assertRaises(config.HostConfigError):

    82

            config.apply_host(self.options, 'foo', 'test', {

    83

                'ethernet': 'foo',

    84

                'ethernet.eth0': 'bar',

    85

            })

    86

    87

class TestForwardZone(unittest.TestCase):

    88

    def setUp(self):

    89

        self.options = Options()

    90

        self.options.add_origin = False

    91

    92

    def assertZoneEquals(self, rrs, expected):

    93

        gather = { }

    94

    95

        for rr in rrs:

    96

            key = (rr.name.lower(), rr.type.upper())

    97

    98

            self.assertNotIn(key, gather)

    99

   100

            gather[key] = rr.data

   101

   102

        self.assertDictEqual(gather, expected)

   103

   104

    def testResolve(self):

   105

        self.assertEquals(zone.resolve(None, None, 'host'), 'host.')

   106

        self.assertEquals(zone.resolve(None, 'domain', 'host'), 'host.domain.')

   107

   108

        with self.assertRaises(zone.HostZoneError):

   109

            zone.resolve('origin', 'domain', 'host')

   110

   111

        self.assertEquals(zone.resolve('domain', 'domain', 'host'), 'host')

   112

        self.assertEquals(zone.resolve('origin', 'domain.origin', 'host'), 'host.domain')

   113

   114

        with self.assertRaises(zone.HostZoneError):

   115

            zone.resolve('origin', 'domainorigin', 'host')

   116

   117

        with self.assertRaises(zone.HostZoneError):

   118

            zone.resolve('origin', None, 'host.domain')

   119

   120

    def testHostForwardOutOfOrigin(self):

   121

        h = host.Host('host', 'domain', ip=ipaddr.IPAddress('10.0.0.1'))

   122

   123

        self.assertZoneEquals(zone.host_forward(h, 'test'), { })

   124

   126

        h = host.Host.build('host', 'domain',

   127

                ip  = '192.0.2.1',

   128

                ip6 = '2001:db8::192.0.2.1',

   129

        )

   130

   131

        self.assertZoneEquals(zone.host_forward(h, 'domain'), {

   132

            ('host', 'A'): ['192.0.2.1'],

   133

            ('host', 'AAAA'): ['2001:db8::c000:201'],

   134

        })

   135

   144

    def testHostDelegate(self):

   145

        h = host.Host.build('host', 'example.com',

   146

                ip      = '192.0.2.1',

   147

                ip6     = '2001:db8::192.0.2.1',

   148

                forward = 'host.example.net',

   149

                reverse = '1.0/28.2.0.192.in-addr.arpa',

   150

        )

   151

   152

        self.assertZoneEquals(zone.host_forward(h, 'example.com'), {

   153

            ('host', 'CNAME'): ['host.example.net.'],

   154

        })

   155

   156

        self.assertZoneEquals((rr for ip, rr in zone.host_reverse(h, ipaddr.IPNetwork('192.0.2.1/24'))), {

   157

            ('1', 'CNAME'): ['1.0/28.2.0.192.in-addr.arpa.'],

   158

        })

   163

   164

if __name__ == '__main__':

   165

    unittest.main()