test/test_utils.py

   1 #! /usr/bin/env python
   2
   3 # Author: David Goodger
   4 # Contact: goodger@users.sourceforge.net
   5 # Revision: $Revision$
   6 # Date: $Date$
   7 # Copyright: This module has been placed in the public domain.
   8
   9 """
  10 Test module for utils.py.
  11 """
  12
  13 import unittest
  14 import StringIO
  15 import sys
  16 from DocutilsTestSupport import utils, nodes
  17
  18
  19 class ReporterTests(unittest.TestCase):
  20
  21     stream = StringIO.StringIO()
  22     reporter = utils.Reporter('test data', 2, 4, stream, 1)
  23
  24     def setUp(self):
  25         self.stream.seek(0)
  26         self.stream.truncate()
  27
  28     def test_level0(self):
  29         sw = self.reporter.system_message(0, 'debug output')
  30         self.assertEquals(sw.pformat(), """\
  31 <system_message level="0" source="test data" type="DEBUG">
  32     <paragraph>
  33         debug output
  34 """)
  35         self.assertEquals(self.stream.getvalue(),
  36                           'test data:: (DEBUG/0) debug output\n')
  37
  38     def test_level1(self):
  39         sw = self.reporter.system_message(1, 'a little reminder')
  40         self.assertEquals(sw.pformat(), """\
  41 <system_message level="1" source="test data" type="INFO">
  42     <paragraph>
  43         a little reminder
  44 """)
  45         self.assertEquals(self.stream.getvalue(), '')
  46
  47     def test_level2(self):
  48         sw = self.reporter.system_message(2, 'a warning')
  49         self.assertEquals(sw.pformat(), """\
  50 <system_message level="2" source="test data" type="WARNING">
  51     <paragraph>
  52         a warning
  53 """)
  54         self.assertEquals(self.stream.getvalue(),
  55                           'test data:: (WARNING/2) a warning\n')
  56
  57     def test_level3(self):
  58         sw = self.reporter.system_message(3, 'an error')
  59         self.assertEquals(sw.pformat(), """\
  60 <system_message level="3" source="test data" type="ERROR">
  61     <paragraph>
  62         an error
  63 """)
  64         self.assertEquals(self.stream.getvalue(),
  65                           'test data:: (ERROR/3) an error\n')
  66
  67     def test_level4(self):
  68         self.assertRaises(utils.SystemMessage, self.reporter.system_message, 4,
  69                           'a severe error, raises an exception')
  70         self.assertEquals(self.stream.getvalue(), 'test data:: (SEVERE/4) '
  71                           'a severe error, raises an exception\n')
  72
  73
  74 class QuietReporterTests(unittest.TestCase):
  75
  76     stream = StringIO.StringIO()
  77     reporter = utils.Reporter('test data', 5, 5, stream, 0)
  78
  79     def setUp(self):
  80         self.stream.seek(0)
  81         self.stream.truncate()
  82
  83     def test_debug(self):
  84         sw = self.reporter.debug('a debug message')
  85         self.assertEquals(sw.pformat(), """\
  86 <system_message level="0" source="test data" type="DEBUG">
  87     <paragraph>
  88         a debug message
  89 """)
  90         self.assertEquals(self.stream.getvalue(), '')
  91
  92     def test_info(self):
  93         sw = self.reporter.info('an informational message')
  94         self.assertEquals(sw.pformat(), """\
  95 <system_message level="1" source="test data" type="INFO">
  96     <paragraph>
  97         an informational message
  98 """)
  99         self.assertEquals(self.stream.getvalue(), '')
 100
 101     def test_warning(self):
 102         sw = self.reporter.warning('a warning')
 103         self.assertEquals(sw.pformat(), """\
 104 <system_message level="2" source="test data" type="WARNING">
 105     <paragraph>
 106         a warning
 107 """)
 108         self.assertEquals(self.stream.getvalue(), '')
 109
 110     def test_error(self):
 111         sw = self.reporter.error('an error')
 112         self.assertEquals(sw.pformat(), """\
 113 <system_message level="3" source="test data" type="ERROR">
 114     <paragraph>
 115         an error
 116 """)
 117         self.assertEquals(self.stream.getvalue(), '')
 118
 119     def test_severe(self):
 120         sw = self.reporter.severe('a severe error')
 121         self.assertEquals(sw.pformat(), """\
 122 <system_message level="4" source="test data" type="SEVERE">
 123     <paragraph>
 124         a severe error
 125 """)
 126         self.assertEquals(self.stream.getvalue(), '')
 127
 128
 129 class ReporterCategoryTests(unittest.TestCase):
 130
 131     stream = StringIO.StringIO()
 132
 133     def setUp(self):
 134         self.stream.seek(0)
 135         self.stream.truncate()
 136         self.reporter = utils.Reporter('test data', 2, 4, self.stream, 1)
 137         self.reporter.set_conditions('lemon', 1, 3, self.stream, 0)
 138
 139     def test_getset(self):
 140         self.reporter.set_conditions('test', 5, 5, None, 0)
 141         self.assertEquals(self.reporter.get_conditions('other').astuple(),
 142                           (1, 2, 4, self.stream))
 143         self.assertEquals(self.reporter.get_conditions('test').astuple(),
 144                           (0, 5, 5, sys.stderr))
 145         self.assertEquals(self.reporter.get_conditions('test.dummy').astuple(),
 146                           (0, 5, 5, sys.stderr))
 147         self.reporter.set_conditions('test.dummy.spam', 1, 2, self.stream, 1)
 148         self.assertEquals(
 149               self.reporter.get_conditions('test.dummy.spam').astuple(),
 150               (1, 1, 2, self.stream))
 151         self.assertEquals(self.reporter.get_conditions('test.dummy').astuple(),
 152                           (0, 5, 5, sys.stderr))
 153         self.assertEquals(
 154               self.reporter.get_conditions('test.dummy.spam.eggs').astuple(),
 155               (1, 1, 2, self.stream))
 156         self.reporter.unset_conditions('test.dummy.spam')
 157         self.assertEquals(
 158               self.reporter.get_conditions('test.dummy.spam.eggs').astuple(),
 159               (0, 5, 5, sys.stderr))
 160
 161     def test_debug(self):
 162         sw = self.reporter.debug('debug output', category='lemon.curry')
 163         self.assertEquals(self.stream.getvalue(), '')
 164         sw = self.reporter.debug('debug output')
 165         self.assertEquals(self.stream.getvalue(),
 166                           'test data:: (DEBUG/0) debug output\n')
 167
 168     def test_info(self):
 169         sw = self.reporter.info('some info')
 170         self.assertEquals(self.stream.getvalue(), '')
 171         sw = self.reporter.info('some info', category='lemon.curry')
 172         self.assertEquals(
 173               self.stream.getvalue(),
 174               'test data:: (INFO/1) some info [lemon.curry]\n')
 175
 176     def test_warning(self):
 177         sw = self.reporter.warning('a warning')
 178         self.assertEquals(self.stream.getvalue(),
 179                           'test data:: (WARNING/2) a warning\n')
 180         sw = self.reporter.warning('a warning', category='lemon.curry')
 181         self.assertEquals(self.stream.getvalue(), """\
 182 test data:: (WARNING/2) a warning
 183 test data:: (WARNING/2) a warning [lemon.curry]
 184 """)
 185
 186     def test_error(self):
 187         sw = self.reporter.error('an error')
 188         self.assertEquals(self.stream.getvalue(),
 189                           'test data:: (ERROR/3) an error\n')
 190         self.assertRaises(utils.SystemMessage, self.reporter.error,
 191                           'an error', category='lemon.curry')
 192         self.assertEquals(self.stream.getvalue(), """\
 193 test data:: (ERROR/3) an error
 194 test data:: (ERROR/3) an error [lemon.curry]
 195 """)
 196
 197     def test_severe(self):
 198         self.assertRaises(utils.SystemMessage, self.reporter.severe,
 199                           'a severe error')
 200         self.assertEquals(self.stream.getvalue(),
 201                           'test data:: (SEVERE/4) a severe error\n')
 202         self.assertRaises(utils.SystemMessage, self.reporter.severe,
 203                           'a severe error', category='lemon.curry')
 204         self.assertEquals(self.stream.getvalue(), """\
 205 test data:: (SEVERE/4) a severe error
 206 test data:: (SEVERE/4) a severe error [lemon.curry]
 207 """)
 208
 209
 210 class NameValueTests(unittest.TestCase):
 211
 212     def test_extract_name_value(self):
 213         self.assertRaises(utils.NameValueError, utils.extract_name_value,
 214                           'hello')
 215         self.assertRaises(utils.NameValueError, utils.extract_name_value,
 216                           'hello')
 217         self.assertRaises(utils.NameValueError, utils.extract_name_value,
 218                           '=hello')
 219         self.assertRaises(utils.NameValueError, utils.extract_name_value,
 220                           'hello=')
 221         self.assertRaises(utils.NameValueError, utils.extract_name_value,
 222                           'hello="')
 223         self.assertRaises(utils.NameValueError, utils.extract_name_value,
 224                           'hello="something')
 225         self.assertRaises(utils.NameValueError, utils.extract_name_value,
 226                           'hello="something"else')
 227         output = utils.extract_name_value(
 228               """att1=val1 att2=val2 att3="value number '3'" att4=val4""")
 229         self.assertEquals(output, [('att1', 'val1'), ('att2', 'val2'),
 230                                    ('att3', "value number '3'"),
 231                                    ('att4', 'val4')])
 232
 233
 234 class ExtensionOptionTests(unittest.TestCase):
 235
 236     optionspec = {'a': int, 'bbb': float, 'cdef': (lambda x: x),
 237                   'empty': (lambda x: x)}
 238
 239     def test_assemble_option_dict(self):
 240         input = utils.extract_name_value('a=1 bbb=2.0 cdef=hol%s' % chr(224))
 241         self.assertEquals(
 242               utils.assemble_option_dict(input, self.optionspec),
 243               {'a': 1, 'bbb': 2.0, 'cdef': ('hol%s' % chr(224))})
 244         input = utils.extract_name_value('a=1 b=2.0 c=hol%s' % chr(224))
 245         self.assertRaises(KeyError, utils.assemble_option_dict,
 246                           input, self.optionspec)
 247         input = utils.extract_name_value('a=1 bbb=two cdef=hol%s' % chr(224))
 248         self.assertRaises(ValueError, utils.assemble_option_dict,
 249                           input, self.optionspec)
 250
 251     def test_extract_extension_options(self):
 252         field_list = nodes.field_list()
 253         field_list += nodes.field(
 254               '', nodes.field_name('', 'a'),
 255               nodes.field_body('', nodes.paragraph('', '1')))
 256         field_list += nodes.field(
 257               '', nodes.field_name('', 'bbb'),
 258               nodes.field_body('', nodes.paragraph('', '2.0')))
 259         field_list += nodes.field(
 260               '', nodes.field_name('', 'cdef'),
 261               nodes.field_body('', nodes.paragraph('', 'hol%s' % chr(224))))
 262         field_list += nodes.field(
 263               '', nodes.field_name('', 'empty'), nodes.field_body())
 264         self.assertEquals(
 265               utils.extract_extension_options(field_list, self.optionspec),
 266               {'a': 1, 'bbb': 2.0, 'cdef': ('hol%s' % chr(224)),
 267                'empty': None})
 268         self.assertRaises(KeyError, utils.extract_extension_options,
 269                           field_list, {})
 270         field_list += nodes.field(
 271               '', nodes.field_name('', 'cdef'),
 272               nodes.field_body('', nodes.paragraph('', 'one'),
 273                                nodes.paragraph('', 'two')))
 274         self.assertRaises(utils.BadOptionDataError,
 275                           utils.extract_extension_options,
 276                           field_list, self.optionspec)
 277         field_list[-1] = nodes.field(
 278               '', nodes.field_name('', 'cdef bad'),
 279               nodes.field_body('', nodes.paragraph('', 'no arguments')))
 280         self.assertRaises(utils.BadOptionError,
 281                           utils.extract_extension_options,
 282                           field_list, self.optionspec)
 283         field_list[-1] = nodes.field(
 284               '', nodes.field_name('', 'cdef'),
 285               nodes.field_body('', nodes.paragraph('', 'duplicate')))
 286         self.assertRaises(utils.DuplicateOptionError,
 287                           utils.extract_extension_options,
 288                           field_list, self.optionspec)
 289         field_list[-2] = nodes.field(
 290               '', nodes.field_name('', 'unkown'),
 291               nodes.field_body('', nodes.paragraph('', 'unknown')))
 292         self.assertRaises(KeyError, utils.extract_extension_options,
 293                           field_list, self.optionspec)
 294
 295
 296 if __name__ == '__main__':
 297     unittest.main()