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 TestZoneMixin(object):

    88

    def assertZoneEquals(self, rrs, expected):

    89

        gather = { }

    90

    91

        for rr in rrs:

    92

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

    93

    94

            self.assertNotIn(key, gather)

    95

    96

            gather[key] = rr.data

    97

    98

        self.assertDictEqual(gather, expected)

    99

   100

   101

class TestForwardZone(TestZoneMixin, unittest.TestCase):

   102

    def setUp(self):

   103

        self.options = Options()

   104

        self.options.add_origin = False

   105

   106

    def testResolve(self):

   107

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

   108

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

   109

   110

        with self.assertRaises(zone.HostZoneError):

   111

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

   112

   113

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

   114

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

   115

   116

        with self.assertRaises(zone.HostZoneError):

   117

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

   118

   119

        with self.assertRaises(zone.HostZoneError):

   120

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

   121

   122

    def testHostOutOfOrigin(self):

   123

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

   124

   125

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

   126

   127

    def testHostIP(self):

   128

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

   129

                ip  = '192.0.2.1',

   130

                ip6 = '2001:db8::192.0.2.1',

   131

        )

   132

   133

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

   134

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

   135

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

   136

        })

   137

   138

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

   139

            ('1', 'PTR'): ['host.domain.'],

   140

        })

   141

   142

        self.assertZoneEquals((rr for ip, rr in zone.host_reverse(h, ipaddr.IPNetwork('2001:db8::/64'))), {

   143

            ('1.0.2.0.0.0.0.c.0.0.0.0.0.0.0.0', 'PTR'): ['host.domain.'],

   144

        })

   145

   146

    def testHostAlias(self):

   147

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

   148

                ip      = '192.0.2.1',

   149

                alias   = 'test *.test',

   150

        )

   151

   152

        self.assertEquals(h.alias, ['test', '*.test'])

   153

   154

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

   155

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

   156

            ('test', 'CNAME'): ['host'],

   157

            ('*.test', 'CNAME'): ['host'],

   158

        })

   159

   160

    def testHostAlias46(self):

   161

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

   162

                ip      = '192.0.2.1',

   163

                ip6     = '2001:db8::192.0.2.1',

   164

                alias4  = 'test4',

   165

                alias6  = 'test6',

   166

        )

   167

   168

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

   169

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

   170

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

   171

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

   172

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

   173

        })

   174

   175

    def testHostAlias4Missing(self):

   176

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

   177

                ip6     = '2001:db8::192.0.2.1',

   178

                alias4  = 'test4',

   179

                alias6  = 'test6',

   180

        )

   181

   182

        with self.assertRaises(zone.HostZoneError):

   183

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

   184

   185

    def testHostAlias6Missing(self):

   186

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

   187

                ip      = '192.0.2.1',

   188

                alias4  = 'test4',

   189

                alias6  = 'test6',

   190

        )

   191

   192

        with self.assertRaises(zone.HostZoneError):

   193

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

   194

   195

    def testHostDelegate(self):

   196

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

   197

                forward = 'host.example.net',

   198

        )

   199

   200

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

   201

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

   202

        })

   203

   204

    def testHostForwardAlias(self):

   205

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

   206

                forward = 'host.example.net',

   207

                alias   = 'test',

   208

        )

   209

   210

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

   211

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

   212

            ('test', 'CNAME'): ['host'],

   213

        })

   214

   215

    def testHostLocation(self):

   216

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

   217

                ip          = '192.0.2.1',

   218

                location    = 'test',

   219

        )

   220

   221

        self.assertEquals(h.location, ('test', 'domain'))

   222

   223

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

   224

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

   225

            ('test', 'CNAME'): ['host'],

   226

        })

   227

   228

    def testHostLocationDomain(self):

   229

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

   230

                ip          = '192.0.2.1',

   231

                location    = 'test@bar.domain',

   232

        )

   233

   234

        self.assertEquals(h.location, ('test', 'bar.domain'))

   235

   236

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

   237

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

   238

            ('test.bar', 'CNAME'): ['host.foo'],

   239

        })

   240

   241

    def testHostLocationDomainOutOfOrigin(self):

   242

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

   243

                ip          = '192.0.2.1',

   244

                location    = 'test@bar.domain',

   245

        )

   246

   247

        self.assertEquals(h.location, ('test', 'bar.domain'))

   248

   249

        with self.assertRaises(zone.HostZoneError):

   250

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

   251

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

   252

            })

   253

   254

        # TODO

   255

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

   256

        #    ('test', 'CNAME'): ['host.foo'],

   257

        #})

   325

class TestReverseZone(TestZoneMixin, unittest.TestCase):

   326

    def setUp(self):

   327

        self.options = Options()

   328

        self.options.unknown_host = False

   329

   330

    def testHostDelegate(self):

   331

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

   332

                ip      = '192.0.2.1',

   333

                ip6     = '2001:db8::192.0.2.1',

   334

                forward = '',

   335

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

   336

        )

   337

   338

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

   339

   340

        })

   341

   342

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

   343

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

   344

        })

   345

   346

        self.assertZoneEquals((rr for ip, rr in zone.host_reverse(h, ipaddr.IPNetwork('2001:db8::/64'))), {

   347

   348

        })

   349

   350

   351

if __name__ == '__main__':

   352

    unittest.main()