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

    def testHostAlias(self):

   139

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

   140

                ip      = '192.0.2.1',

   141

                alias   = 'test *.test',

   142

        )

   143

   144

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

   145

   146

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

   147

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

   148

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

   149

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

   150

        })

   151

   152

    def testHostAlias46(self):

   153

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

   154

                ip      = '192.0.2.1',

   155

                ip6     = '2001:db8::192.0.2.1',

   156

                alias4  = 'test4',

   157

                alias6  = 'test6',

   158

        )

   159

   160

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

   161

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

   162

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

   163

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

   164

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

   165

        })

   166

   167

    def testHostAlias4Missing(self):

   168

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

   169

                ip6     = '2001:db8::192.0.2.1',

   170

                alias4  = 'test4',

   171

                alias6  = 'test6',

   172

        )

   173

   174

        with self.assertRaises(zone.HostZoneError):

   175

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

   176

   177

    def testHostAlias6Missing(self):

   178

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

   179

                ip      = '192.0.2.1',

   180

                alias4  = 'test4',

   181

                alias6  = 'test6',

   182

        )

   183

   184

        with self.assertRaises(zone.HostZoneError):

   185

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

   186

   187

    def testHostDelegate(self):

   188

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

   189

                forward = 'host.example.net',

   190

        )

   191

   192

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

   193

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

   194

        })

   195

   196

    def testHostForwardAlias(self):

   197

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

   198

                forward = 'host.example.net',

   199

                alias   = 'test',

   200

        )

   201

   202

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

   203

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

   204

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

   205

        })

   206

   207

    def testHostLocation(self):

   208

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

   209

                ip          = '192.0.2.1',

   210

                location    = 'test',

   211

        )

   212

   213

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

   214

   215

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

   216

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

   217

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

   218

        })

   219

   220

    def testHostLocationDomain(self):

   221

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

   222

                ip          = '192.0.2.1',

   223

                location    = 'test@bar.domain',

   224

        )

   225

   226

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

   227

   228

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

   229

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

   230

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

   231

        })

   232

   233

    def testHostLocationDomainOutOfOrigin(self):

   234

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

   235

                ip          = '192.0.2.1',

   236

                location    = 'test@bar.domain',

   237

        )

   238

   239

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

   240

   241

        with self.assertRaises(zone.HostZoneError):

   242

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

   243

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

   244

            })

   245

   246

        # TODO

   247

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

   248

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

   249

        #})

   250

   251

    def testHostsForward(self):

   252

        hosts = [

   253

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

   254

                    ip      = '192.0.2.1',

   255

                    ip6     = '2001:db8::192.0.2.1',

   256

                    alias   = 'test',

   257

                ),

   258

                host.Host.build('bar', 'domain',

   259

                    ip      = '192.0.2.2',

   260

                )

   261

        ]

   262

   263

        self.assertZoneEquals(zone.apply_hosts_forward(self.options, hosts, 'domain'), {

   264

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

   265

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

   266

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

   267

            ('bar', 'A'): ['192.0.2.2'],

   268

        })

   269

   270

    def testHostsConflict(self):

   271

        hosts = [

   272

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

   273

                    ip      = '192.0.2.1',

   274

                ),

   275

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

   276

                    ip      = '192.0.2.2',

   277

                )

   278

        ]

   279

   280

        with self.assertRaises(zone.HostZoneError):

   281

            self.assertZoneEquals(zone.apply_hosts_forward(self.options, hosts, 'domain'), { })

   282

   283

    def testHostsAliasConflict(self):

   284

        hosts = [

   285

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

   286

                    ip          = '192.0.2.1',

   287

                ),

   288

                host.Host.build('bar', 'domain',

   289

                    ip          = '192.0.2.2',

   290

                    alias       = 'foo',

   291

                )

   292

        ]

   293

   294

        # with A first

   295

        with self.assertRaises(zone.HostZoneError):

   296

            self.assertZoneEquals(zone.apply_hosts_forward(self.options, hosts, 'domain'), { })

   297

   298

        # also with CNAME first

   299

        with self.assertRaises(zone.HostZoneError):

   300

            self.assertZoneEquals(zone.apply_hosts_forward(self.options, reversed(hosts), 'domain'), { })

   301

   302

    def testHostsAlias4Conflict(self):

   303

        hosts = [

   304

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

   305

                    ip          = '192.0.2.1',

   306

                ),

   307

                host.Host.build('bar', 'domain',

   308

                    ip          = '192.0.2.2',

   309

                    alias4      = 'foo',

   310

                )

   311

        ]

   312

   313

        with self.assertRaises(zone.HostZoneError):

   314

            self.assertZoneEquals(zone.apply_hosts_forward(self.options, hosts, 'domain'), { })

   315

   316

   317

class TestReverseZone(TestZoneMixin, unittest.TestCase):

   318

    def setUp(self):

   319

        self.options = Options()

   320

        self.options.unknown_host = False

   321

   375

    def testHostDelegate(self):

   376

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

   377

                ip      = '192.0.2.1',

   378

                ip6     = '2001:db8::192.0.2.1',

   379

                forward = '',

   380

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

   381

        )

   382

   383

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

   384

   385

        })

   386

   387

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

   388

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

   389

        })

   390

   391

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

   392

   393

        })

   394

   395

   396

if __name__ == '__main__':

   397

    unittest.main()