1

import ipaddr

     2

import pvl.args

     3

import unittest

     4

     5

from pvl.hosts import config, dhcp, zone

     6

from pvl.hosts.host import Host

     7

from StringIO import StringIO

     8

     9

class ConfFile(StringIO):

    10

    def __init__(self, name, buffer):

    11

        StringIO.__init__(self, buffer)

    12

        self.name = name

    13

    14

class TestConfig(unittest.TestCase):

    15

    def setUp(self):

    16

        self.options = pvl.args.options(

    17

                hosts_charset   = 'utf-8',

    18

                hosts_domain    = None,

    19

                hosts_include   = None,

    20

        )

    21

    22

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

    23

        self.assertEquals(str(host), host_str)

    24

    25

        for attr, value in attrs.iteritems():

    26

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

    27

    28

    def assertHostsEqual(self, hosts, expected):

    29

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

    30

            host_str, attrs = expect

    31

    32

            self.assertHostEqual(host, host_str, attrs)

    33

    34

    def testApplyHostsFileError(self):

    35

        with self.assertRaises(config.HostConfigError):

    36

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

    37

    38

    def testApplyHosts(self):

    39

        conf_file = ConfFile('test', """

    40

[foo]

    41

    ip = 127.0.0.1

    42

    43

[bar]

    44

    ip = 127.0.0.2

    45

        """)

    46

        expected = [

    47

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

    48

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

    49

        ]

    50

    51

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

    52

    53

    def testApply(self):

    54

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

    55

                ('foo@test', dict(

    56

                    ip          = ipaddr.IPAddress('127.0.0.1'),

    57

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

    58

                )),

    59

                ('bar@test', dict(

    60

                    ip          = ipaddr.IPAddress('127.0.0.2'),

    61

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

    62

                )),

    63

        ])

    64

    65

    def testApplyHostsExpand(self):

    66

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

    67

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

    68

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

    69

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

    70

        ])

    71

    72

    def testApplyHostConfigDict(self):

    73

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

    74

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

    75

        })

    76

    77

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

    78

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

    79

        ))

    80

    81

    def testApplyHostsConfigError(self):

    82

        with self.assertRaises(config.HostConfigError):

    83

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

    84

                'ethernet': 'foo',

    85

                'ethernet.eth0': 'bar',

    86

            })

    87

   104

class TestZoneMixin(object):

   105

    def assertZoneEquals(self, rrs, expected):

   106

        gather = { }

   107

   108

        for rr in rrs:

   109

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

   110

   111

            self.assertNotIn(key, gather)

   112

   113

            gather[key] = rr.data

   114

   115

        self.assertDictEqual(gather, expected)

   116

   117

   118

class TestForwardZone(TestZoneMixin, unittest.TestCase):

   119

    def testHostOutOfOrigin(self):

   120

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

   121

   122

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

   123

   124

    def testHostIP(self):

   125

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

   126

                ip  = '192.0.2.1',

   127

                ip6 = '2001:db8::192.0.2.1',

   128

        )

   129

   130

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

   131

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

   132

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

   133

        })

   134

   135

    def testHostAlias(self):

   136

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

   137

                ip      = '192.0.2.1',

   138

                alias   = 'test *.test',

   139

        )

   140

   141

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

   142

   143

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

   144

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

   145

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

   146

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

   147

        })

   148

   149

    def testHostAlias46(self):

   150

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

   151

                ip      = '192.0.2.1',

   152

                ip6     = '2001:db8::192.0.2.1',

   153

                alias4  = 'test4',

   154

                alias6  = 'test6',

   155

        )

   156

   157

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

   158

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

   159

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

   160

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

   161

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

   162

        })

   163

   164

    def testHostAlias4Missing(self):

   165

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

   166

                ip6     = '2001:db8::192.0.2.1',

   167

                alias4  = 'test4',

   168

                alias6  = 'test6',

   169

        )

   170

   171

        with self.assertRaises(zone.HostZoneError):

   172

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

   173

   174

    def testHostAlias6Missing(self):

   175

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

   176

                ip      = '192.0.2.1',

   177

                alias4  = 'test4',

   178

                alias6  = 'test6',

   179

        )

   180

   181

        with self.assertRaises(zone.HostZoneError):

   182

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

   183

   184

    def testHostFQDN(self):

   185

        h = Host.build('host.example.net', None,

   186

                ip          = '192.0.2.3',

   187

        )

   188

   189

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

   190

   191

        })

   192

   193

    def testHostDelegate(self):

   194

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

   195

                forward = 'host.example.net',

   196

        )

   197

   198

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

   199

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

   200

        })

   201

   202

    def testHostForwardAlias(self):

   203

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

   204

                forward = 'host.example.net',

   205

                alias   = 'test',

   206

        )

   207

   208

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

   209

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

   210

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

   211

        })

   212

   213

    def testHostLocation(self):

   214

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

   215

                ip          = '192.0.2.1',

   216

                location    = 'test',

   217

        )

   218

   219

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

   220

   221

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

   222

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

   223

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

   224

        })

   225

   226

    def testHostLocationDomain(self):

   227

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

   228

                ip          = '192.0.2.1',

   229

                location    = 'test@bar.domain',

   230

        )

   231

   232

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

   233

   234

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

   235

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

   236

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

   237

        })

   238

   239

    def testHostLocationDomainOutOfOrigin(self):

   240

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

   241

                ip          = '192.0.2.1',

   242

                location    = 'test@bar.domain',

   243

        )

   244

   245

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

   246

   247

        with self.assertRaises(zone.HostZoneError):

   248

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

   249

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

   250

            })

   251

   252

        # TODO

   253

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

   254

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

   255

        #})

   256

   257

    def testHostsForward(self):

   258

        hosts = [

   259

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

   260

                    ip      = '192.0.2.1',

   261

                    ip6     = '2001:db8::192.0.2.1',

   262

                    alias   = 'test',

   263

                ),

   264

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

   265

                    ip      = '192.0.2.2',

   266

                ),

   267

                Host.build('quux', 'example',

   268

                    ip      = '192.0.2.3',

   269

                ),

   270

        ]

   271

   272

        rrs = zone.apply_hosts_forward(hosts, 'domain', add_origin=True)

   273

   274

        # handle the $ORIGIN directive

   275

        rd = next(rrs)

   276

   277

        self.assertEquals(unicode(rd), '$ORIGIN\tdomain.')

   278

   279

        self.assertZoneEquals(rrs, {

   280

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

   281

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

   282

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

   283

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

   284

        })

   285

   286

    def testHostsConflict(self):

   287

        hosts = [

   288

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

   289

                    ip      = '192.0.2.1',

   290

                ),

   291

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

   292

                    ip      = '192.0.2.2',

   293

                )

   294

        ]

   295

   296

        with self.assertRaises(zone.HostZoneError):

   297

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

   298

   299

    def testHostsAliasConflict(self):

   300

        hosts = [

   301

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

   302

                    ip          = '192.0.2.1',

   303

                ),

   304

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

   305

                    ip          = '192.0.2.2',

   306

                    alias       = 'foo',

   307

                )

   308

        ]

   309

   310

        # with A first

   311

        with self.assertRaises(zone.HostZoneError):

   312

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

   313

   314

        # also with CNAME first

   315

        with self.assertRaises(zone.HostZoneError):

   316

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

   317

   318

    def testHostsAlias4Conflict(self):

   319

        hosts = [

   320

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

   321

                    ip          = '192.0.2.1',

   322

                ),

   323

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

   324

                    ip          = '192.0.2.2',

   325

                    alias4      = 'foo',

   326

                )

   327

        ]

   328

   329

        with self.assertRaises(zone.HostZoneError):

   330

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

   331

   332

   333

class TestReverseZone(TestZoneMixin, unittest.TestCase):

   334

    def testHostIP(self):

   335

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

   336

                ip  = '192.0.2.1',

   337

                ip6 = '2001:db8::192.0.2.1',

   338

        )

   339

   340

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

   341

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

   342

        })

   343

   344

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

   345

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

   346

        })

   347

   348

    def testHostIP4(self):

   349

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

   350

                ip  = '192.0.2.1',

   351

        )

   352

   353

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

   354

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

   355

        })

   356

   357

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

   358

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

   359

        })

   360

   361

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

   362

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

   363

        })

   364

   365

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

   366

   367

        })

   368

   369

    def testHostIP6(self):

   370

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

   371

                ip6 = '2001:db8::192.0.2.1',

   372

        )

   373

   374

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

   375

        })

   376

   377

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

   378

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

   379

        })

   380

   381

    def testHostIPOutOfPrefix(self):

   382

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

   383

                ip  = '192.0.2.1',

   384

                ip6 = '2001:db8::192.0.2.1',

   385

        )

   386

   387

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

   388

   389

        })

   390

   391

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

   392

   393

        })

   394

   395

    def testHostFQDN(self):

   396

        h = Host.build('host.example.net', None,

   397

                ip          = '192.0.2.3',

   398

                ip6         = '2001:db8::192.0.2.3',

   399

        )

   400

   401

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

   402

            ('3', 'PTR'): ['host.example.net.'],

   403

   404

        })

   405

   406

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

   407

            ('3.0.2.0.0.0.0.c.0.0.0.0.0.0.0.0', 'PTR'): ['host.example.net.'],

   408

        })

   409

   410

    def testHostDelegate(self):

   411

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

   412

                ip      = '192.0.2.1',

   413

                ip6     = '2001:db8::192.0.2.1',

   414

                forward = '',

   415

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

   416

        )

   417

   418

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

   419

   420

        })

   421

   422

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

   423

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

   424

        })

   425

   426

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

   427

   428

        })

   429

   430

    def testHosts(self):

   431

        hosts = [

   432

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

   433

                    ip      = '192.0.2.1',

   434

                ),

   435

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

   436

                    ip      = '192.0.2.2',

   437

                )

   438

        ]

   439

   440

        self.assertZoneEquals(zone.apply_hosts_reverse(hosts, ipaddr.IPNetwork('192.0.2.1/24')), {

   441

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

   442

            ('2', 'PTR'): ['bar.domain.'],

   443

        })

   444

   445

        # in ip order

   446

        self.assertZoneEquals(zone.apply_hosts_reverse(reversed(hosts), ipaddr.IPNetwork('192.0.2.1/24')), {

   447

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

   448

            ('2', 'PTR'): ['bar.domain.'],

   449

        })

   450

   451

    def testHostsConflict(self):

   452

        hosts = [

   453

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

   454

                    ip      = '192.0.2.1',

   455

                ),

   456

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

   457

                    ip      = '192.0.2.1',

   458

                )

   459

        ]

   460

   461

        with self.assertRaises(zone.HostZoneError):

   462

            self.assertZoneEquals(zone.apply_hosts_reverse(hosts, ipaddr.IPNetwork('192.0.2.1/24')), { })

   463

   464

    def testHostsGenerateUnknown(self):

   465

        hosts = [

   466

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

   467

                    ip      = '192.0.2.1',

   468

                ),

   469

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

   470

                    ip      = '192.0.2.5',

   471

                ),

   472

        ]

   473

   474

        self.assertZoneEquals(zone.apply_hosts_reverse(hosts, ipaddr.IPNetwork('192.0.2.1/29'),

   475

                unknown_host = 'ufc',

   476

                unknown_domain = 'domain',

   477

        ), {

   478

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

   479

            ('2', 'PTR'): ['ufc.domain.'],

   480

            ('3', 'PTR'): ['ufc.domain.'],

   481

            ('4', 'PTR'): ['ufc.domain.'],

   482

            ('5', 'PTR'): ['bar.domain.'],

   483

            ('6', 'PTR'): ['ufc.domain.'],

   484

        })

   485

   486

class TestDhcp(unittest.TestCase):

   487

    def assertBlocksEqual(self, blockdefs, expected):

   488

        for (_block, _items, _opts), (block, items, opts) in zip(blockdefs, expected):

   489

            self.assertEqual(_block, block)

   490