1

import itertools

     2

import re

     3

import unittest

     4

     5

from pvl.dhcp import config

     6

from StringIO import StringIO

     7

     8

class File(StringIO):

     9

    @classmethod

    10

    def lines (cls, *lines):

    11

        return cls('\n'.join(lines) + '\n')

    12

    13

    def __init__(self, buffer, name='test.file'):

    14

        StringIO.__init__(self, buffer)

    15

        self.name = name

    16

    17

class ConfigTest(unittest.TestCase):

    18

    def setUp(self):

    19

        self.parser = config.DHCPConfigParser(name='test')

    20

    21

    def assertLexEqual(self, lexed, expected):

    22

        self.assertEqual(list(lexed), expected)

    23

    24

    def assertBlockEqual(self, block, (key, items, blocks)):

    25

        self.assertEqual(block.key, key)

    26

        self.assertEqual(block.items, items)

    27

    28

        for _block, expect_block in itertools.izip_longest(block.blocks, blocks):

    29

            self.assertBlockEqual(_block, expect_block)

    30

    31

    def _testLex(self, lines, expected):

    32

        lexed = [item for line in lines for item in self.parser.lex(line)]

    33

    34

        self.assertEqual(lexed, expected)

    35

    36

    def _testParse(self, lines, expected):

    37

        for block, expect in itertools.izip_longest(self.parser.parse_lines(lines), expected):

    38

            self.assertIsNotNone(block, expect)

    39

            self.assertIsNotNone(expect, block)

    40

    41

            self.assertBlockEqual(block, expect)

    42

    43

    def testLexerEmpty(self):

    44

        self._testLex([''], [])

    45

    46

    def testLexerSingleToken(self):

    47

        self._testLex(['foo;'], [

    48

            ('item', ('foo', )),

    49

        ])

    50

    51

    def testLexerSingleTokenWhitespace(self):

    52

        self._testLex([' foo ;'], [

    53

            ('item', ('foo', )),

    54

        ])

    55

    56

    def testLexerSingleLine(self):

    57

        self._testLex(['foo { bar "quux"; } # ignore'], [

    58

            ('open', ('foo', )),

    59

            ('item', ('bar', 'quux')),

    60

            ('close', None),

    61

        ])

    62

    63

    def testLexerSingleTokenLines(self):

    64

        self._testLex(['foo {'], [('open', ('foo', ))])

    65

        self._testLex([' bar;'], [('item', ('bar', ))])

    66

        self._testLex(['}'], [('close', None)])

    67

    68

    def testLexerSingleTokens(self):

    69

        self._testLex(['foo', '  {  ', 'bar', '', '"quux"', ';', '}'], [

    70

            ('open', ('foo', )),

    71

            ('item', ('bar', 'quux')),

    72

            ('close', None),

    73

        ])

    74

    75

    def testParse(self):

    76

        self._testParse(['foo {'], [])

    77

        self._testParse([' bar;', ' quux asdf;'], [])

    78

        self._testParse(['}'], [

    79

            (('foo', ), [('bar', ), ('quux', 'asdf')], []),

    80

        ])

    81

    82

    def testParseConf(self):

    83

        self.assertBlockEqual(config.DHCPConfigParser.load(File("""

    84

group {

    85

    next-server boot.test;

    86

    filename "/debian/wheezy/pxelinux.0";

    87

    88

    include "hosts/test.conf";

    89

    90

    host foo {

    91

        fixed-address       192.0.2.1;

    92

        hardware ethernet   00:11:22:33:44:55;

    93

    }

    94

}

   106

        ]))

   107

   108

class ConfigBuildTest(unittest.TestCase):

   109

    def assertEqualWhitespace(self, value, expected):

   110

        # normalize

   111

        value = re.sub(r'\s+', ' ', value)

   112

        expected = re.sub(r'\s+', ' ', expected)

   113

   114

        self.assertEqual(value, expected)

   115

   116

    def assertLinesEqual(self, lines, expected):

   117

        for line, expect in itertools.izip_longest(lines, expected):

   118

            self.assertEqualWhitespace(line, expect)

   119

   120

    def testBuildConf(self):

   121

        self.assertLinesEqual(

   122

                config.build_block(config.Block(('group', ), [

   123

                        ('next-server', 'boot.test'),

   124

                        ('filename', "/debian/wheezy/pxelinux.0"),

   125

                        ('include', "hosts/test.conf"),

   126

                    ], [

   127

                        config.Block(('host', 'foo'), [

   128

                            ('option', 'host-name', "foo.test"),

   129

                            ('fixed-address', '192.0.2.1'),

   130

                            ('hardware', 'ethernet', '00:11:22:33:44:55'),

   131

                        ]),

   132

                    ]

   133

                )),

   134

                """

   135

group {

   136

    next-server boot.test;

   137

    filename "/debian/wheezy/pxelinux.0";

   138

    include "hosts/test.conf";

   139

   140

    host foo {

   141

        option host-name    "foo.test";

   142

        fixed-address       192.0.2.1;

   143

        hardware ethernet   00:11:22:33:44:55;

   144

    }

   145

}

   146

                """.strip().splitlines()

   147

        )