bee_python 0.0.1

data/tools/common/common/test/unittest_compat.py

@@ -0,0 +1,239 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+"""provides unit tests for compat module"""
+
+from logilab.common.testlib import TestCase, unittest_main
+import sys
+import types
+import __builtin__
+import pprint
+
+class CompatTCMixIn:
+    MODNAMES = {}
+    BUILTINS = []
+    ALTERED_BUILTINS = {}
+
+    def setUp(self):
+        self.builtins_backup = {}
+        self.modules_backup = {}
+        self.remove_builtins()
+        self.alter_builtins()
+        self.remove_modules()
+
+    def tearDown(self):
+        for modname in self.MODNAMES:
+            del sys.modules[modname]
+        for funcname, func in self.builtins_backup.items():
+            setattr(__builtin__, funcname, func)
+            # delattr(__builtin__, 'builtin_%s' % funcname)
+        for modname, mod in self.modules_backup.items():
+            sys.modules[modname] = mod
+        try:
+            del sys.modules['logilab.common.compat']
+        except KeyError:
+            pass
+
+    def remove_builtins(self):
+        for builtin in self.BUILTINS:
+            func = getattr(__builtin__, builtin, None)
+            if func is not None:
+                self.builtins_backup[builtin] = func
+                delattr(__builtin__, builtin)
+                # setattr(__builtin__, 'builtin_%s' % builtin, func)
+    def alter_builtins(self):
+        for builtin, func in self.ALTERED_BUILTINS.iteritems():
+            old_func = getattr(__builtin__, builtin, None)
+            if func is not None:
+                self.builtins_backup[builtin] = old_func
+                setattr(__builtin__, builtin, func)
+                # setattr(__builtin__, 'builtin_%s' % builtin, func)
+
+    def remove_modules(self):
+        for modname in self.MODNAMES:
+            if modname in sys.modules:
+                self.modules_backup[modname] = sys.modules[modname]
+            sys.modules[modname] = types.ModuleType('faked%s' % modname)
+
+    def test_removed_builtins(self):
+        """tests that builtins are actually uncallable"""
+        for builtin in self.BUILTINS:
+            self.assertRaises(NameError, eval, builtin, {})
+
+    def test_removed_modules(self):
+        """tests that builtins are actually emtpy"""
+        for modname, funcnames in self.MODNAMES.items():
+            import_stmt = 'from %s import %s' % (modname, ', '.join(funcnames))
+            # FIXME: use __import__ instead
+            code = compile(import_stmt, 'foo.py', 'exec')
+            self.assertRaises(ImportError, eval, code)
+
+
+class Py23CompatTC(CompatTCMixIn, TestCase):
+    BUILTINS = ('enumerate', 'sum')
+    MODNAMES = {
+        'sets' : ('Set', 'ImmutableSet'),
+        'itertools' : ('izip', 'chain'),
+        }
+
+    def test_sum(self):
+        from logilab.common.compat import sum
+        self.assertEquals(sum(range(5)), 10)
+        self.assertRaises(TypeError, sum, 'abc')
+
+    def test_enumerate(self):
+        from logilab.common.compat import enumerate
+        self.assertEquals(list(enumerate([])), [])
+        self.assertEquals(list(enumerate('abc')),
+                          [(0, 'a'), (1, 'b'), (2, 'c')])
+
+    def test_basic_set(self):
+        from logilab.common.compat import set
+        s = set('abc')
+        self.assertEquals(len(s), 3)
+        s.remove('a')
+        self.assertEquals(len(s), 2)
+        s.add('a')
+        self.assertEquals(len(s), 3)
+        s.add('a')
+        self.assertEquals(len(s), 3)
+        self.assertRaises(KeyError, s.remove, 'd')
+
+    def test_basic_set(self):
+        from logilab.common.compat import set
+        s = set('abc')
+        self.assertEquals(len(s), 3)
+        s.remove('a')
+        self.assertEquals(len(s), 2)
+        s.add('a')
+        self.assertEquals(len(s), 3)
+        s.add('a')
+        self.assertEquals(len(s), 3)
+        self.assertRaises(KeyError, s.remove, 'd')
+        self.assertRaises(TypeError, dict, [(s, 'foo')])
+
+
+    def test_frozenset(self):
+        from logilab.common.compat import frozenset
+        s = frozenset('abc')
+        self.assertEquals(len(s), 3)
+        self.assertRaises(AttributeError, getattr, s, 'remove')
+        self.assertRaises(AttributeError, getattr, s, 'add')
+        d = {s : 'foo'} # frozenset should be hashable
+        d[s] = 'bar'
+        self.assertEquals(len(d), 1)
+        self.assertEquals(d[s], 'bar')
+
+
+class Py24CompatTC(CompatTCMixIn, TestCase):
+    BUILTINS = ('reversed', 'sorted', 'set', 'frozenset',)
+
+    def test_sorted(self):
+        from logilab.common.compat import sorted
+        l = [3, 1, 2, 5, 4]
+        s = sorted(l)
+        self.assertEquals(s, [1, 2, 3, 4, 5])
+        self.assertEquals(l, [3, 1, 2, 5, 4])
+        self.assertEquals(sorted('FeCBaD'), list('BCDFae'))
+        self.assertEquals(sorted('FeCBaD', key=str.lower), list('aBCDeF'))
+        self.assertEquals(sorted('FeCBaD', key=str.lower, reverse=True), list('FeDCBa'))
+        def strcmp(s1, s2):
+            return cmp(s1.lower(), s2.lower())
+        self.assertEquals(sorted('FeCBaD', cmp=strcmp), list('aBCDeF'))
+
+
+    def test_reversed(self):
+        from logilab.common.compat import reversed
+        l = range(5)
+        r = reversed(l)
+        self.assertEquals(r, [4, 3, 2, 1, 0])
+        self.assertEquals(l, range(5))
+
+    def test_set(self):
+        from logilab.common.compat import set
+        s1 = set(range(5))
+        s2 = set(range(2, 6))
+        self.assertEquals(len(s1), 5)
+        self.assertEquals(s1 & s2, set([2, 3, 4]))
+        self.assertEquals(s1 | s2, set(range(6)))
+
+
+
+class _MaxFaker(object):
+    def __init__(self, func):
+        self.func = func
+    def fake(self,*args,**kargs):
+        if kargs:
+            raise TypeError("max() takes no keyword argument")
+        return self.func(*args)
+
+
+class Py25CompatTC(CompatTCMixIn, TestCase):
+    BUILTINS = ('any', 'all',)
+    ALTERED_BUILTINS = {'max': _MaxFaker(max).fake}
+
+    def test_any(self):
+        from logilab.common.compat import any
+        testdata = ([], (), '', 'abc', xrange(0, 10), xrange(0, -10, -1))
+        self.assertEquals(any([]), False)
+        self.assertEquals(any(()), False)
+        self.assertEquals(any(''), False)
+        self.assertEquals(any('abc'), True)
+        self.assertEquals(any(xrange(10)), True)
+        self.assertEquals(any(xrange(0, -10, -1)), True)
+        # python2.5's any consumes iterables
+        irange = iter(range(10))
+        self.assertEquals(any(irange), True)
+        self.assertEquals(irange.next(), 2)
+
+
+    def test_all(self):
+        from logilab.common.compat import all
+        testdata = ([], (), '', 'abc', xrange(0, 10), xrange(0, -10, -1))
+        self.assertEquals(all([]), True)
+        self.assertEquals(all(()), True)
+        self.assertEquals(all(''), True)
+        self.assertEquals(all('abc'), True)
+        self.assertEquals(all(xrange(10)), False)
+        self.assertEquals(all(xrange(0, -10, -1)), False)
+        # python2.5's all consumes iterables
+        irange = iter(range(10))
+        self.assertEquals(all(irange), False)
+        self.assertEquals(irange.next(), 1)
+
+    def test_max(self):
+        from logilab.common.compat import max
+
+        # old apy
+        self.assertEquals(max("fdjkmhsgmdfhsg"),'s')
+        self.assertEquals(max(1,43,12,45,1337,34,2), 1337)
+        self.assertRaises(TypeError,max)
+        self.assertRaises(TypeError,max,1)
+        self.assertRaises(ValueError,max,[])
+        self.assertRaises(TypeError,max,bob=None)
+
+        # new apy
+        self.assertEquals(max("shorter","longer",key=len),"shorter")
+        self.assertEquals(max(((1,1),(2,3,5),(8,13,21)),key=len),(2,3,5))
+        self.assertEquals(max(((1,1),(42,),(2,3,5),(8,13,21)),key=max),(42,))
+        self.assertRaises(TypeError,max,key=None)
+        self.assertRaises(TypeError,max,1,key=len)
+        self.assertRaises(ValueError,max,[],key=max)
+        self.assertRaises(TypeError,max,"shorter","longer",key=len,kathy=None)
+
+if __name__ == '__main__':
+    unittest_main()

data/tools/common/common/test/unittest_configuration.py

@@ -0,0 +1,348 @@
+# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
+# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This file is part of logilab-common.
+#
+# logilab-common is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation, either version 2.1 of the License, or (at your option) any
+# later version.
+#
+# logilab-common is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Lesser General Public License along
+# with logilab-common.  If not, see <http://www.gnu.org/licenses/>.
+import tempfile
+import os
+from cStringIO import StringIO
+from sys import version_info
+
+from logilab.common.testlib import TestCase, unittest_main
+from logilab.common.optik_ext import OptionValueError
+from logilab.common.configuration import Configuration, \
+     OptionsManagerMixIn, OptionsProviderMixIn, Method, read_old_config
+
+options = [('dothis', {'type':'yn', 'action': 'store', 'default': True, 'metavar': '<y or n>'}),
+           ('value', {'type': 'string', 'metavar': '<string>', 'short': 'v'}),
+           ('multiple', {'type': 'csv', 'default': ('yop','yep'),
+                         'metavar': '<comma separated values>',
+                         'help': 'you can also document the option'}),
+           ('number', {'type': 'int', 'default':2, 'metavar':'<int>', 'help': 'boom'}),
+           ('choice', {'type': 'choice', 'default':'yo', 'choices': ('yo', 'ye'),
+                       'metavar':'<yo|ye>'}),
+           ('multiple-choice', {'type': 'multiple_choice', 'default':('yo', 'ye'),
+                                'choices': ('yo', 'ye', 'yu', 'yi', 'ya'),
+                                'metavar':'<yo|ye>'}),
+           ('named', {'type':'named', 'default':Method('get_named'),
+                      'metavar': '<key=val>'}),
+
+           ('diffgroup', {'type':'string', 'default':'pouet', 'metavar': '<key=val>',
+                          'group': 'agroup'}),
+
+           ]
+
+class MyConfiguration(Configuration):
+    """test configuration"""
+    def get_named(self):
+        return {'key': 'val'}
+
+class ConfigurationTC(TestCase):
+
+    def setUp(self):
+        self.cfg = MyConfiguration(name='test', options=options, usage='Just do it ! (tm)')
+
+    def test_default(self):
+        cfg = self.cfg
+        self.assertEquals(cfg['dothis'], True)
+        self.assertEquals(cfg['value'], None)
+        self.assertEquals(cfg['multiple'], ('yop','yep'))
+        self.assertEquals(cfg['number'], 2)
+        self.assertEquals(cfg['choice'], 'yo')
+        self.assertEquals(cfg['multiple-choice'], ('yo', 'ye'))
+        self.assertEquals(cfg['named'], {'key': 'val'})
+
+    def test_base(self):
+        cfg = self.cfg
+        cfg.set_option('number', '0')
+        self.assertEquals(cfg['number'], 0)
+        self.assertRaises(OptionValueError, cfg.set_option, 'number', 'youpi')
+        self.assertRaises(OptionValueError, cfg.set_option, 'choice', 'youpi')
+        self.assertRaises(OptionValueError, cfg.set_option, 'multiple-choice', ('yo', 'y', 'ya'))
+        cfg.set_option('multiple-choice', 'yo, ya')
+        self.assertEquals(cfg['multiple-choice'], ['yo', 'ya'])
+        self.assertEquals(cfg.get('multiple-choice'), ['yo', 'ya'])
+        self.assertEquals(cfg.get('whatever'), None)
+
+    def test_load_command_line_configuration(self):
+        cfg = self.cfg
+        args = cfg.load_command_line_configuration(['--choice', 'ye', '--number', '4',
+                                                    '--multiple=1,2,3', '--dothis=n',
+                                                    'other', 'arguments'])
+        self.assertEquals(args, ['other', 'arguments'])
+        self.assertEquals(cfg['dothis'], False)
+        self.assertEquals(cfg['multiple'], ['1', '2', '3'])
+        self.assertEquals(cfg['number'], 4)
+        self.assertEquals(cfg['choice'], 'ye')
+        self.assertEquals(cfg['value'], None)
+        args = cfg.load_command_line_configuration(['-v', 'duh'])
+        self.assertEquals(args, [])
+        self.assertEquals(cfg['value'], 'duh')
+        self.assertEquals(cfg['dothis'], False)
+        self.assertEquals(cfg['multiple'], ['1', '2', '3'])
+        self.assertEquals(cfg['number'], 4)
+        self.assertEquals(cfg['choice'], 'ye')
+
+    def test_load_configuration(self):
+        cfg = self.cfg
+        args = cfg.load_configuration(choice='ye', number='4',
+                                      multiple='1,2,3', dothis='n',
+                                      multiple_choice=('yo', 'ya'))
+        self.assertEquals(cfg['dothis'], False)
+        self.assertEquals(cfg['multiple'], ['1', '2', '3'])
+        self.assertEquals(cfg['number'], 4)
+        self.assertEquals(cfg['choice'], 'ye')
+        self.assertEquals(cfg['value'], None)
+        self.assertEquals(cfg['multiple-choice'], ('yo', 'ya'))
+
+    def test_load_configuration_file_case_insensitive(self):
+        file = tempfile.mktemp()
+        stream = open(file, 'w')
+        try:
+            stream.write("""[Test]
+
+dothis=no
+
+#value=
+
+# you can also document the option
+multiple=yop,yepii
+
+# boom
+number=3
+
+choice=yo
+
+multiple-choice=yo,ye
+
+named=key:val
+
+
+[agroup]
+
+diffgroup=zou
+""")
+            stream.close()
+            self.cfg.load_file_configuration(file)
+            self.assertEquals(self.cfg['dothis'], False)
+            self.assertEquals(self.cfg['value'], None)
+            self.assertEquals(self.cfg['multiple'], ['yop','yepii'])
+            self.assertEquals(self.cfg['diffgroup'], 'zou')
+        finally:
+            os.remove(file)
+
+    def test_generate_config(self):
+        stream = StringIO()
+        self.cfg.generate_config(stream)
+        self.assertLinesEquals(stream.getvalue().strip(), """[TEST]
+
+dothis=yes
+
+#value=
+
+# you can also document the option
+multiple=yop,yep
+
+# boom
+number=2
+
+choice=yo
+
+multiple-choice=yo,ye
+
+named=key:val
+
+
+[AGROUP]
+
+diffgroup=pouet
+""")
+
+    def test_generate_config_with_space_string(self):
+        self.cfg['value'] = '    '
+        stream = StringIO()
+        self.cfg.generate_config(stream)
+        self.assertLinesEquals(stream.getvalue().strip(), """[TEST]
+
+dothis=yes
+
+value='    '
+
+# you can also document the option
+multiple=yop,yep
+
+# boom
+number=2
+
+choice=yo
+
+multiple-choice=yo,ye
+
+named=key:val
+
+
+[AGROUP]
+
+diffgroup=pouet
+""")
+
+
+    def test_loopback(self):
+        cfg = self.cfg
+        f = tempfile.mktemp()
+        stream = open(f, 'w')
+        try:
+            cfg.generate_config(stream)
+            stream.close()
+            new_cfg = MyConfiguration(name='testloop', options=options)
+            new_cfg.load_file_configuration(f)
+            self.assertEquals(cfg['dothis'], new_cfg['dothis'])
+            self.assertEquals(cfg['multiple'], new_cfg['multiple'])
+            self.assertEquals(cfg['number'], new_cfg['number'])
+            self.assertEquals(cfg['choice'], new_cfg['choice'])
+            self.assertEquals(cfg['value'], new_cfg['value'])
+            self.assertEquals(cfg['multiple-choice'], new_cfg['multiple-choice'])
+        finally:
+            os.remove(f)
+
+    def test_setitem(self):
+        self.assertRaises(OptionValueError,
+                          self.cfg.__setitem__, 'multiple-choice', ('a', 'b'))
+        self.cfg['multiple-choice'] = ('yi', 'ya')
+        self.assertEquals(self.cfg['multiple-choice'], ('yi', 'ya'))
+
+    def test_help(self):
+        self.cfg.add_help_section('bonus', 'a nice additional help')
+        help = self.cfg.help().strip()
+        # at least in python 2.4.2 the output is:
+        # '  -v <string>, --value=<string>'
+        # it is not unlikely some optik/optparse versions do print -v<string>
+        # so accept both
+        help = help.replace(' -v <string>, ', ' -v<string>, ')
+        if version_info >= (2, 5):
+            self.assertLinesEquals(help, """Usage: Just do it ! (tm)
+
+Options:
+  -h, --help            show this help message and exit
+  --dothis=<y or n>
+  -v<string>, --value=<string>
+  --multiple=<comma separated values>
+                        you can also document the option [current: yop,yep]
+  --number=<int>        boom [current: 2]
+  --choice=<yo|ye>
+  --multiple-choice=<yo|ye>
+  --named=<key=val>
+
+  Agroup:
+    --diffgroup=<key=val>
+
+  Bonus:
+    a nice additional help
+""", striplines=True)
+        elif version_info >= (2, 4):
+            self.assertLinesEquals(help, """usage: Just do it ! (tm)
+
+options:
+  -h, --help            show this help message and exit
+  --dothis=<y or n>
+  -v<string>, --value=<string>
+  --multiple=<comma separated values>
+                        you can also document the option [current: yop,yep]
+  --number=<int>        boom [current: 2]
+  --choice=<yo|ye>
+  --multiple-choice=<yo|ye>
+  --named=<key=val>
+
+  Bonus:
+    a nice additional help
+""", striplines=True)
+        else:
+            self.assertLinesEquals(help, """usage: Just do it ! (tm)
+
+options:
+  -h, --help            show this help message and exit
+  --dothis=<y or n>
+  -v<string>, --value=<string>
+  --multiple=<comma separated values>
+                        you can also document the option
+  --number=<int>
+  --choice=<yo|ye>
+  --multiple-choice=<yo|ye>
+  --named=<key=val>
+
+  Bonus:
+    a nice additional help
+""", striplines=True)
+
+
+    def test_manpage(self):
+        from logilab.common import __pkginfo__
+        self.cfg.generate_manpage(__pkginfo__, stream=StringIO())
+
+    def test_rewrite_config(self):
+        changes = [('renamed', 'renamed', 'choice'),
+                   ('moved', 'named', 'old', 'test'),
+                   ]
+        read_old_config(self.cfg, changes, 'data/test.ini')
+        stream = StringIO()
+        self.cfg.generate_config(stream)
+        self.assertLinesEquals(stream.getvalue().strip(), """[TEST]
+
+dothis=yes
+
+value='    '
+
+# you can also document the option
+multiple=yop
+
+# boom
+number=2
+
+choice=yo
+
+multiple-choice=yo,ye
+
+named=key:val
+
+
+[AGROUP]
+
+diffgroup=pouet
+""")
+
+class Linter(OptionsManagerMixIn, OptionsProviderMixIn):
+    options = (
+        ('profile', {'type' : 'yn', 'metavar' : '<y_or_n>',
+                     'default': False,
+                     'help' : 'Profiled execution.'}),
+        )
+    def __init__(self):
+        OptionsManagerMixIn.__init__(self, usage="")
+        OptionsProviderMixIn.__init__(self)
+        self.register_options_provider(self)
+        self.load_provider_defaults()
+
+class RegrTC(TestCase):
+
+    def setUp(self):
+        self.linter = Linter()
+
+    def test_load_defaults(self):
+        self.linter.load_command_line_configuration([])
+        self.assertEquals(self.linter.config.profile, False)
+
+
+if __name__ == '__main__':
+    unittest_main()