Exemplo n.º 1
0
 def test_nonempty_attr(self):
     auto = Tag()
     self.assertEqual(
         auto.tag({
             'tag': 'ol',
             'cdata': {
                 'tag': 'li',
                 'cdata': '1'
             },
             'attr': {
                 'class': 'ordered'
             }
         }), '<ol class="ordered"><li>1</li></ol>', "ol tag correct")
     attr = {'class': ['odd', 'even']}
     self.assertEqual(
         auto.tag({
             'tag':
             'ol',
             'cdata': [{
                 'tag': 'li',
                 'cdata': 1,
                 'attr': attr
             }, {
                 'tag': 'li',
                 'cdata': 2,
                 'attr': attr
             }]
         }), '<ol><li class="odd">1</li><li class="even">2</li></ol>',
         "ol tag correct")
Exemplo n.º 2
0
    def test_tag(self):
        auto = Tag()
        self.assertEqual( auto.encodes, '', 'encodes param not set' )
        self.assertEqual( auto.encode, 0,   'encode param not set' )
        self.assertEqual( auto.indent, '',  'indent param not set' )
        self.assertEqual( auto.level, 0,    'level param not set' )
        self.assertEqual( auto.sort, 0,     'sort param not set' )
        self.assertEqual( auto.newline, '', 'newline param not set' )

        auto = Tag({ 'encodes':'<>', 'encode':1, 'indent':"\t", 'level':4, 'sort':1 })
        self.assertEqual( auto.encodes, '<>',   'encodes param set' )
        self.assertEqual( auto.encode, 1,       'encode param set' )
        self.assertEqual( auto.indent, "\t",    'indent param set' )
        self.assertEqual( auto.level, 4,        'level param set' )
        self.assertEqual( auto.sort, 1,         'sort param set' )
        self.assertEqual( auto.newline, "\n",   'newline param set' )
Exemplo n.º 3
0
    def test_init(self):
        auto = Tag()
        self.assertEqual(auto.encode, 0, "no args encode correct")
        self.assertEqual(auto.encodes, '', "no args encodes correct")
        self.assertEqual(auto.indent, '', "no args indent correct")
        self.assertEqual(auto.level, 0, "no args level correct")
        self.assertEqual(auto.sort, 0, "no args sort correct")
        self.assertEqual(auto.newline, '', "no args newline correct")

        auto = Tag({'encodes': '<>', 'indent': ' ', 'sort': 1, 'level': 2})
        #self.assertEqual( auto.encode, 1,       "encode set correct" )
        self.assertEqual(auto.encodes, '<>', "encodes set correct")
        self.assertEqual(auto.indent, ' ', "indent set correct")
        self.assertEqual(auto.level, 2, "sort set correct")
        self.assertEqual(auto.sort, 1, "sort set correct")
        self.assertEqual(auto.newline, "\n", "newline set correct")
Exemplo n.º 4
0
    def test_nonempty(self):
        auto = Tag()
        self.assertEqual(auto.tag({
            'tag': 'p',
            'cdata': 0
        }), '<p>0</p>', "0 (int) as cdata")
        self.assertEqual(auto.tag({
            'tag': 'p',
            'cdata': '0'
        }), '<p>0</p>', "0 (str) as cdata")
        self.assertEqual(auto.tag({
            'tag': 'html',
            'cdata': ' '
        }), '<html> </html>', "whitespace cdata correct")

        self.assertEqual(
            auto.tag({
                'tag': 'ol',
                'cdata': {
                    'tag': 'li',
                    'cdata': '1'
                }
            }), '<ol><li>1</li></ol>', "ol tag correct")
        self.assertEqual(
            auto.tag({
                'tag':
                'ol',
                'cdata': [{
                    'tag': 'li',
                    'cdata': 1
                }, {
                    'tag': 'li',
                    'cdata': 2
                }]
            }), '<ol><li>1</li><li>2</li></ol>', "ol tag correct")
Exemplo n.º 5
0
 def test_level(self):
     auto = Tag({'indent': ' ', 'level': 3})
     self.assertEqual(auto.tag({
         'tag': 'p',
         'cdata': 0
     }), "   <p>0</p>\n", "paragraph tag correct")
     self.assertEqual(
         auto.tag({
             'tag': 'ol',
             'cdata': {
                 'tag': 'li',
                 'cdata': 1
             }
         }), "   <ol>\n    <li>1</li>\n   </ol>\n", "ol tag correct")
     self.assertEqual(
         auto.tag({
             'tag':
             'ol',
             'cdata': [{
                 'tag': 'li',
                 'cdata': 1
             }, {
                 'tag': 'li',
                 'cdata': 2
             }]
         }), "   <ol>\n    <li>1</li>\n    <li>2</li>\n   </ol>\n",
         "ol tag correct")
Exemplo n.º 6
0
 def test_empty(self):
     auto = Tag()
     self.assertEqual(auto.tag({'tag': 'html'}), '<html />',
                      "no cdata correct")
     self.assertEqual(auto.tag({
         'tag': 'html',
         'cdata': ''
     }), '<html />', "empty cdata correct")
Exemplo n.º 7
0
 def test_empty_attr(self):
     auto = Tag()
     self.assertEqual(auto.tag({
         'tag': 'foo',
         'attr': {
             'bar': 'qux'
         }
     }), '<foo bar="qux" />', "no cdata with attr correct")
     self.assertEqual(
         auto.tag({
             'tag': 'foo',
             'cdata': '',
             'attr': {
                 'bar': 'qux'
             }
         }), '<foo bar="qux" />', "empty cdata with attr correct")
Exemplo n.º 8
0
    def test_simple(self):
        auto = Tag()

        self.assertEqual(
            '<p class="paragraph" />',
            auto.tag({
                'tag': 'p',
                'attr': {
                    'class': 'paragraph'
                }
            }), 'empty paragraph tag correct')

        self.assertEqual(
            '<p class="paragraph">0</p>',
            auto.tag({
                'tag': 'p',
                'attr': {
                    'class': 'paragraph'
                },
                'cdata': 0
            }), 'paragraph tag correct')

        self.assertEqual(
            '<colgroup span="0">0</colgroup>',
            auto.tag({
                'tag': 'colgroup',
                'attr': {
                    'span': 0
                },
                'cdata': 0
            }), 'colgroup tag correct')

        self.assertEqual(
            '<colgroup span="3"><col /></colgroup>',
            auto.tag({
                'attr': {
                    'span': 3
                },
                'cdata': [{
                    'attr': {},
                    'tag': 'col'
                }],
                'tag': 'colgroup'
            }), 'colgroup tag correct')

        self.assertEqual(
            '<colgroup span="3"><col /><col /></colgroup>',
            auto.tag({
                'attr': {
                    'span': 3
                },
                'cdata': [{
                    'attr': {},
                    'tag': 'col'
                }, {
                    'attr': {},
                    'tag': 'col'
                }],
                'tag':
                'colgroup'
            }), 'colgroup tag correct')

        self.assertEqual(
            '<table><colgroup><col /><col /><col /></colgroup><colgroup><col /><col /><col /></colgroup><colgroup><col /><col /><col /></colgroup></table>',
            auto.tag({
                'tag':
                'table',
                'cdata': [{
                    'tag':
                    'colgroup',
                    'attr': {},
                    'cdata': [{
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }]
                }, {
                    'tag':
                    'colgroup',
                    'attr': {},
                    'cdata': [{
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }]
                }, {
                    'tag':
                    'colgroup',
                    'attr': {},
                    'cdata': [{
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }]
                }]
            }), 'colgroup tag correct')

        self.assertEqual(
            '<table><colgroup><col /><col /><col /></colgroup><colgroup><col /><col /><col /></colgroup><colgroup><col /><col /><col /></colgroup><tr><th>a</th><th>b</th><th>c</th></tr><tr><td>1</td><td>2</td><td>3</td></tr><tr><td>4</td><td>5</td><td>6</td></tr></table>',
            auto.tag({
                'tag':
                'table',
                'cdata': [{
                    'tag':
                    'colgroup',
                    'attr': {},
                    'cdata': [{
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }]
                }, {
                    'tag':
                    'colgroup',
                    'attr': {},
                    'cdata': [{
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }]
                }, {
                    'tag':
                    'colgroup',
                    'attr': {},
                    'cdata': [{
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }, {
                        'tag': 'col',
                        'attr': {}
                    }]
                }, {
                    'tag':
                    'tr',
                    'attr': {},
                    'cdata': [{
                        'tag': 'th',
                        'attr': {},
                        'cdata': 'a'
                    }, {
                        'tag': 'th',
                        'attr': {},
                        'cdata': 'b'
                    }, {
                        'tag': 'th',
                        'attr': {},
                        'cdata': 'c'
                    }]
                }, {
                    'tag':
                    'tr',
                    'attr': {},
                    'cdata': [{
                        'tag': 'td',
                        'attr': {},
                        'cdata': '1'
                    }, {
                        'tag': 'td',
                        'attr': {},
                        'cdata': '2'
                    }, {
                        'tag': 'td',
                        'attr': {},
                        'cdata': '3'
                    }]
                }, {
                    'tag':
                    'tr',
                    'attr': {},
                    'cdata': [{
                        'tag': 'td',
                        'attr': {},
                        'cdata': '4'
                    }, {
                        'tag': 'td',
                        'attr': {},
                        'cdata': '5'
                    }, {
                        'tag': 'td',
                        'attr': {},
                        'cdata': '6'
                    }]
                }]
            }), 'colgroup tag correct')