1

#!/usr/bin/env python2.5

     2

"""

     3

    Test conf_dhcp

     4

"""

     5

     6

import dhcp_conf as dhcpc, dhcp, addr

     7

     8

import unittest

     9

    10

class _TestConfObj (unittest.TestCase) :

    11

    def assert_obj (self, obj, lines) :

    12

        """

    13

            Formats the given conf.Object and compares the output against the given lines

    14

        """

    15

    16

        for obj_line, line in zip(obj.fmt_lines(), lines) :

    17

            self.assertEqual(obj_line, line)

    18

    19

class TestDHCPConf (_TestConfObj) :

    20

    def assert_stmt (self, stmt, line) :

    21

        """

    22

            Formats the given Statement, and compares the output against the given line.

    23

    24

            Note that the dhcpc.Statement doesn't have a working fmt_lines implementation.

    25

        """

    26

    27

        self.assertEqual(stmt._fmt_data(), line)

    28

    29

    def test_comment (self) :

    30

        self.assert_obj(dhcpc.Comment("foo bar"),                           [ "# foo bar" ])

    31

    32

    def test_section (self) :

    33

        self.assert_obj(dhcpc.Section(comment="test"),                      [ "# test" ])

    34

    35

        self.assert_obj(dhcpc.Section(params=[

    36

                dhcpc.Parameter("param0"), None

    37

            ], comment="foo"), [

    38

                "# foo",

    39

                "param0;",

    40

            ])

    41

    42

    def test_statement (self) :

    43

        self.assert_stmt(dhcpc.Statement("stmt0"),                           "stmt0")

    44

        self.assert_stmt(dhcpc.Statement("stmt1", [ "this", "that" ]),       "stmt1 this, that")

    45

        self.assert_stmt(dhcpc.Statement("stmt2", dhcpc.Literal("...")),     "stmt2 ...")

    46

        self.assert_stmt(dhcpc.Statement("stmt3", u"quux"),                  "stmt3 quux")

    47

        self.assert_stmt(dhcpc.Statement("stmt4", "bar"),                    "stmt4 bar")

    48

        self.assert_stmt(dhcpc.Statement("stmt5", 1),                        "stmt5 1")

    49

        self.assert_stmt(dhcpc.Statement("stmt6", 1, None, 2),               "stmt6 1 2")

    50

    51

    def test_literal (self) :

    52

        self.assert_obj(dhcpc.Literal("///"),                               [ "///" ])

    53

    54

    def test_parameter (self) :

    55

        self.assert_obj(dhcpc.Parameter("param0", "this", 13, "that"),      [ "param0 this 13 that;" ])

    57

    58

    def test_declaration (self) :

    59

        self.assert_obj(dhcpc.Declaration("decl0", ["arg0", "arg1"], [

    60

            dhcpc.Parameter("param0"),

    61

            None

    62

        ], [

    63

            dhcpc.Declaration("decl0.0", params=[

    64

                dhcpc.Parameter("param0.0.1", "value")

    65

            ])

    68

            "decl0 arg0 arg1 {",

    69

            "\tparam0;",

    70

            "\tdecl0.0 {",

    71

            "\t\tparam0.0.1 value;",

    72

            "\t}",

    73

            "}",

    74

        ])

    75

    76

    def test_shared_network (self) :

    77

        self.assert_obj(dhcpc.SharedNetwork("net0", params=[

    78

            dhcpc.Parameter("param0")

    79

        ]), [

    80

            "shared-network net0 {",

    81

            "\tparam0;",

    82

            "}"

    83

        ])

    84

    85

    def test_subnet (self) :

    86

        self.assert_obj(dhcpc.Subnet(addr.Network("194.197.235.0/24"), params=[

    87

            dhcpc.Parameter("param0")

    88

        ]), [

    89

            "subnet 194.197.235.0 netmask 255.255.255.0 {",

    90

            "\tparam0;",

    91

            "}"

    92

        ])

    93

    94

    def test_group (self) :

    95

        self.assert_obj(dhcpc.Group(decls=[

    96

            dhcpc.Declaration("decl0.0", params=[

    97

                dhcpc.Parameter("param0.0.1", "value")

    98

            ])

    99

        ]), [

   100

            "group {",

   101

            "\tdecl0.0 {",

   102

            "\t\tparam0.0.1 value;",

   103

            "\t}",

   104

            "}"

   105

        ])

   106

   107

    def test_host (self) :

   108

        self.assert_obj(dhcpc.Host("test-hostname", params=[

   109

            dhcpc.Parameter("param0")

   110

        ]), [

   111

            "host test-hostname {",

   112

            "\tparam0;",

   113

            "}"

   114

        ])

   115

   116

    def test_option (self) :

   117

        self.assert_obj(dhcpc.Option("foo", "example.com"), [

   118

            "option foo example.com;",

   119

        ])

   120

   121

class TestDHCP (_TestConfObj) :

   122

    def test_host (self) :

   123

        self.assert_obj(dhcp.Host("testhost", addr.MAC("12:34:56:78:90:ab"), addr.IP("1.2.3.4")), [

   124

                "host testhost {",

   125

                "\thardware ethernet 12:34:56:78:90:ab;",

   126

                "\tfixed-address 1.2.3.4;",

   127

                "}"

   128

            ])

   129

   130

    def test_subnet (self) :

   131

        self.assert_obj(dhcp.Subnet(addr.Network("1.2.3.0/24")), [

   132

                "subnet 1.2.3.0 netmask 255.255.255.0 {",

   133

                "\toption routers 1.2.3.1;",

   134

                "}"

   135

            ])

   136

   137

        self.assert_obj(dhcp.Subnet(addr.Network("1.2.3.0/24"), router_idx=10, range=(20, 30), unknown_clients='allow'), [

   138

                "subnet 1.2.3.0 netmask 255.255.255.0 {",

   139

                "\toption routers 1.2.3.10;",

   140

                "\trange 1.2.3.20 1.2.3.30;",

   141

                "\tallow unknown-clients;",

   142

                "}"

   143

            ])

   144

   145

    def test_config (self) :

   146

        self.assert_obj(dhcp.Config(

   147

                settings        = { 'foo-setting': 'someval' }, 

   148

                options         = { 'bar-opt': ['one', 'two'] },

   149

                shared_network  = "FOO-NET",

   150

                subnets         = [

   151

                        dhcp.Subnet(addr.Network("1.2.3.0/24"))

   152

                    ],

   153

                hosts           = [

   154

                        dhcp.Host("testhost", addr.MAC("12:34:56:78:90:ab"), addr.IP("1.2.3.4"))

   155

                    ],

   156

            ), [

   157

                "foo-setting someval;",

   158

                "option bar-opt one, two;",

   159

                "shared-network FOO-NET {",

   160

                "\tsubnet 1.2.3.0 netmask 255.255.255.0 {",

   161

                "\t\toption routers 1.2.3.1;",

   162

                "\t}",

   163

                "}",

   164

                "host testhost {",

   165

                "\thardware ethernet 12:34:56:78:90:ab;",

   166

                "\tfixed-address 1.2.3.4;",

   167

                "}"

   168

            ])

   169

   170

if __name__ == '__main__' :

   171

    unittest.main()

   172