1

# :set encoding=utf8

     2

     3

"""

     4

    Unit tests for qmsk.web.tree_parse

     5

"""

     6

     7

import unittest, os

     8

import tree_parse

     9

    10

class TestTreeParse (unittest.TestCase) :

    11

    VALID = """\

    12

foo

    13

  bar

    14

   quux

    15

    16

  asdf

    17

        further

    18

         still

    19

    20

  and back

    21

""".split('\n')

    22

    23

    def test_read_lines_valid (self) :

    24

        self.assertEquals(list(tree_parse._read_lines(self.VALID)), [

    25

            (1, 0,  "foo"),

    26

            (2, 2,  "bar"),

    27

            (3, 3,  "quux"),

    28

            (5, 2,  "asdf"),

    29

            (6, 8,  "further"),

    30

            (7, 9,  "still"),

    31

            (9, 2,  "and back"),

    32

        ])

    33

    34

    def _parse (self, *lines, **args) :

    35

        return list(tree_parse._read_lines(lines, **args))

    36

    37

    def test_read_lines_decode (self) :

    38

        data_unicode = u'föö'

    39

        data_raw = 'föö'

    40

    41

        self.assertEquals(self._parse(data_unicode.encode('utf8'), charset='utf8'), [(1, 0, data_unicode)])

    42

        self.assertEquals(self._parse(data_unicode, charset=None), [(1, 0, data_unicode)])

    43

        self.assertEquals(self._parse(data_raw, charset=None), [(1, 0, data_raw)])

    44

        self.assertRaises(UnicodeDecodeError, self._parse, data_raw, charset='ascii')

    45

    46

    def test_read_lines_stop (self) :

    47

        self.assertEquals(self._parse(" : foo"), [(1, 1, ": foo")])

    48

        self.assertEquals(self._parse("    : foo", stop_tokens=':'), [(1, 0, ": foo")])

    49

    50

    def test_read_lines_empty (self) :

    51

        self.assertEquals(self._parse(*("foo\n\n  bar".split('\n'))), [(1, 0, "foo"), (3, 2, "bar")])

    52

    53

    def test_read_lines_strip (self) :

    54

        self.assertEquals(self._parse(" foo "), [(1, 1, "foo")])

    55

    56

    def _do (self, *lines, **args) :

    57

        return tree_parse.parse(lines, **args)

    58

    59

    def test_parse_valid (self) :

    60

        self.assertEquals(self._do(*self.VALID), 

    61

            (1, "foo", [

    62

                (2, "bar", [

    63

                    (3, "quux", []),

    64

                ]),

    65

                (5, "asdf", [

    66

                    (6, "further", [

    67

                        (7, "still", []),

    68

                    ]),

    69

                ]),

    70

                (9, "and back", [])

    71

            ])

    72

        )

    73

    74

    def test_parse_invalid (self) :

    75

        self.assertRaises(tree_parse.TreeParseError, self._do, "foo", "  bar", " quux")

    76

    77

    # XXX: don't test root, as that's known-broken still

    78

    79

class TestTreeParseFS (unittest.TestCase) :

    80

    DATA = ["foo", " bar", " quux"]

    81

    def setUp (self) :

    82

        """

    83

            Sets up a temporary file with the path in self.path, and self.DATA

    84

        """

    85

    86

        # XXX: supress warnings

    87

        self.path = os.tempnam()

    88

    89

        # write out DATA

    90

        open(self.path, 'w').write('\n'.join(self.DATA))

    91

    92

    def tearDown (self) :

    93

        """

    94

            Removes the tempfile created earlier

    95

        """

    96

    97

        os.remove(self.path)

    98

    99

    def test_simple (self) :

   100

        self.assertEquals(tree_parse.parse(self.path), (1, "foo", [(2, "bar", []), (3, "quux", [])]))

   101