Removed depreciated code from frontend.py; frontend.py no longer imports ipa_types

1 files changed, 0 insertions, 414 deletions

diff --git a/tests/test_ipalib/test_frontend.py b/tests/test_ipalib/test_frontend.py
index 94e586fe9..c40933175 100644
--- a/tests/test_ipalib/test_frontend.py
+++ b/tests/test_ipalib/test_frontend.py
@@ -70,420 +70,6 @@ def test_is_rule():
     assert not is_rule(call(None))
 
 
-class test_DefaultFrom(ClassChecker):
-    """
-    Test the `ipalib.frontend.DefaultFrom` class.
-    """
-    _cls = frontend.DefaultFrom
-
-    def test_class(self):
-        """
-        Test the `ipalib.frontend.DefaultFrom` class.
-        """
-        assert self.cls.__bases__ == (plugable.ReadOnly,)
-
-    def test_init(self):
-        """
-        Test the `ipalib.frontend.DefaultFrom.__init__` method.
-        """
-        def callback(*args):
-            return args
-        keys = ('givenname', 'sn')
-        o = self.cls(callback, *keys)
-        assert read_only(o, 'callback') is callback
-        assert read_only(o, 'keys') == keys
-        lam = lambda first, last: first[0] + last
-        o = self.cls(lam)
-        assert read_only(o, 'keys') == ('first', 'last')
-
-    def test_call(self):
-        """
-        Test the `ipalib.frontend.DefaultFrom.__call__` method.
-        """
-        def callback(givenname, sn):
-            return givenname[0] + sn[0]
-        keys = ('givenname', 'sn')
-        o = self.cls(callback, *keys)
-        kw = dict(
-            givenname='John',
-            sn='Public',
-            hello='world',
-        )
-        assert o(**kw) == 'JP'
-        assert o() is None
-        for key in ('givenname', 'sn'):
-            kw_copy = dict(kw)
-            del kw_copy[key]
-            assert o(**kw_copy) is None
-
-        # Test using implied keys:
-        o = self.cls(lambda first, last: first[0] + last)
-        assert o(first='john', last='doe') == 'jdoe'
-        assert o(first='', last='doe') is None
-        assert o(one='john', two='doe') is None
-
-        # Test that co_varnames slice is used:
-        def callback2(first, last):
-            letter = first[0]
-            return letter + last
-        o = self.cls(callback2)
-        assert o.keys == ('first', 'last')
-        assert o(first='john', last='doe') == 'jdoe'
-
-
-def test_parse_param_spec():
-    """
-    Test the `ipalib.frontend.parse_param_spec` function.
-    """
-    f = frontend.parse_param_spec
-
-    assert f('name') == ('name', dict(required=True, multivalue=False))
-    assert f('name?') == ('name', dict(required=False, multivalue=False))
-    assert f('name*') == ('name', dict(required=False, multivalue=True))
-    assert f('name+') == ('name', dict(required=True, multivalue=True))
-
-
-class test_Param(ClassChecker):
-    """
-    Test the `ipalib.frontend.Param` class.
-    """
-    _cls = frontend.Param
-
-    def test_class(self):
-        """
-        Test the `ipalib.frontend.Param` class.
-        """
-        assert self.cls.__bases__ == (plugable.ReadOnly,)
-
-    def test_init(self):
-        """
-        Test the `ipalib.frontend.Param.__init__` method.
-        """
-        name = 'sn'
-        o = self.cls(name)
-        assert o.__islocked__() is True
-
-        # Test default values
-        assert read_only(o, 'name') is name
-        assert read_only(o, 'cli_name') is name
-        assert isinstance(read_only(o, 'type'), ipa_types.Unicode)
-        assert read_only(o, 'doc') == ''
-        assert read_only(o, 'required') is True
-        assert read_only(o, 'multivalue') is False
-        assert read_only(o, 'default') is None
-        assert read_only(o, 'default_from') is None
-        assert read_only(o, 'flags') == frozenset()
-        assert read_only(o, 'rules') == tuple()
-        assert len(read_only(o, 'all_rules')) == 1
-        assert read_only(o, 'primary_key') is False
-
-        # Test all kw args:
-        t = ipa_types.Int()
-        assert self.cls(name, cli_name='last').cli_name == 'last'
-        assert self.cls(name, type=t).type is t
-        assert self.cls(name, doc='the doc').doc == 'the doc'
-        assert self.cls(name, required=False).required is False
-        assert self.cls(name, multivalue=True).multivalue is True
-        assert self.cls(name, default=u'Hello').default == u'Hello'
-        df = frontend.DefaultFrom(lambda f, l: f + l,
-            'first', 'last',
-        )
-        lam = lambda first, last: first + last
-        for cb in (df, lam):
-            o = self.cls(name, default_from=cb)
-            assert type(o.default_from) is frontend.DefaultFrom
-            assert o.default_from.keys == ('first', 'last')
-            assert o.default_from.callback('butt', 'erfly') == 'butterfly'
-        assert self.cls(name, flags=('one', 'two', 'three')).flags == \
-            frozenset(['one', 'two', 'three'])
-        rules = (lambda whatever: 'Not okay!',)
-        o = self.cls(name, rules=rules)
-        assert o.rules is rules
-        assert o.all_rules[1:] == rules
-        assert self.cls(name, primary_key=True).primary_key is True
-
-        # Test default type_:
-        o = self.cls(name)
-        assert isinstance(o.type, ipa_types.Unicode)
-
-        # Test param spec parsing:
-        o = self.cls('name?')
-        assert o.name == 'name'
-        assert o.required is False
-        assert o.multivalue is False
-
-        o = self.cls('name*')
-        assert o.name == 'name'
-        assert o.required is False
-        assert o.multivalue is True
-
-        o = self.cls('name+')
-        assert o.name == 'name'
-        assert o.required is True
-        assert o.multivalue is True
-
-        e = raises(TypeError, self.cls, name, whatever=True, another=False)
-        assert str(e) == \
-            'Param.__init__() takes no such kwargs: another, whatever'
-
-    def test_ispassword(self):
-        """
-        Test the `ipalib.frontend.Param.ispassword` method.
-        """
-        name = 'userpassword'
-        okay = 'password'
-        nope = ['', 'pass', 'word', 'passwd']
-        for flag in nope:
-            o = self.cls(name, flags=[flag])
-            assert o.ispassword() is False
-            o = self.cls(name, flags=[flag, okay])
-            assert o.ispassword() is True
-        assert self.cls(name).ispassword() is False
-        assert self.cls(name, flags=[okay]).ispassword() is True
-        assert self.cls(name, flags=[okay]+nope).ispassword() is True
-
-    def test_clone(self):
-        """
-        Test the `ipalib.frontend.Param.__clone__` method.
-        """
-        def compare(o, kw):
-            for (k, v) in kw.iteritems():
-                assert getattr(o, k) == v, (k, v, getattr(o, k))
-        default = dict(
-            required=False,
-            multivalue=False,
-            default=None,
-            default_from=None,
-            rules=tuple(),
-        )
-        name = 'hair_color?'
-        type_ = ipa_types.Int()
-        o = self.cls(name, type=type_)
-        compare(o, default)
-
-        override = dict(multivalue=True, default=42)
-        d = dict(default)
-        d.update(override)
-        clone = o.__clone__(**override)
-        assert clone.name == 'hair_color'
-        assert clone.type is o.type
-        compare(clone, d)
-
-    def test_convert(self):
-        """
-        Test the `ipalib.frontend.Param.convert` method.
-        """
-        name = 'some_number'
-        type_ = ipa_types.Int()
-        okay = (7, 7L, 7.0, ' 7 ')
-        fail = ('7.0', '7L', 'whatever', object)
-        none = (None, '', u'', tuple(), [])
-
-        # Scenario 1: multivalue=False
-        o = self.cls(name, type=type_)
-        for n in none:
-            assert o.convert(n) is None
-        for value in okay:
-            new = o.convert(value)
-            assert new == 7
-            assert type(new) is int
-        for value in fail:
-            e = raises(errors.ConversionError, o.convert, value)
-            assert e.name is name
-            assert e.value is value
-            assert e.error is type_.conversion_error
-            assert e.index is None
-
-        # Scenario 2: multivalue=True
-        o = self.cls(name, type=type_, multivalue=True)
-        for n in none:
-            assert o.convert(n) is None
-        for value in okay:
-            assert o.convert((value,)) == (7,)
-            assert o.convert([value]) == (7,)
-        assert o.convert(okay) == tuple(int(v) for v in okay)
-        cnt = 5
-        for value in fail:
-            for i in xrange(cnt):
-                others = list(7 for x in xrange(cnt))
-                others[i] = value
-                for v in [tuple(others), list(others)]:
-                    e = raises(errors.ConversionError, o.convert, v)
-                    assert e.name is name
-                    assert e.value is value
-                    assert e.error is type_.conversion_error
-                    assert e.index == i
-
-    def test_normalize(self):
-        """
-        Test the `ipalib.frontend.Param.normalize` method.
-        """
-        name = 'sn'
-        callback = lambda value: value.lower()
-        values = (None, u'Hello', (u'Hello',), 'hello', ['hello'])
-        none = (None, '', u'', tuple(), [])
-
-        # Scenario 1: multivalue=False, normalize=None
-        o = self.cls(name)
-        for v in values:
-            # When normalize=None, value is returned, no type checking:
-            assert o.normalize(v) is v
-
-        # Scenario 2: multivalue=False, normalize=callback
-        o = self.cls(name, normalize=callback)
-        for v in (u'Hello', u'hello', 'Hello'): # Okay
-            assert o.normalize(v) == 'hello'
-        for v in [None, 42, (u'Hello',)]: # Not basestring
-            assert o.normalize(v) is v
-        for n in none:
-            assert o.normalize(n) is None
-
-        # Scenario 3: multivalue=True, normalize=None
-        o = self.cls(name, multivalue=True)
-        for v in values:
-            # When normalize=None, value is returned, no type checking:
-            assert o.normalize(v) is v
-
-        # Scenario 4: multivalue=True, normalize=callback
-        o = self.cls(name, multivalue=True, normalize=callback)
-        assert o.normalize([]) is None
-        assert o.normalize(tuple()) is None
-        for value in [(u'Hello',), (u'hello',), 'Hello', ['Hello']]: # Okay
-            assert o.normalize(value) == (u'hello',)
-        fail = 42 # Not basestring
-        for v in [[fail], (u'hello', fail)]: # Non basestring member
-            assert o.normalize(v) == tuple(v)
-        for n in none:
-            assert o.normalize(n) is None
-
-    def test_validate(self):
-        """
-        Test the `ipalib.frontend.Param.validate` method.
-        """
-        name = 'sn'
-        type_ = ipa_types.Unicode()
-        def case_rule(value):
-            if not value.islower():
-                return 'Must be lower case'
-        my_rules = (case_rule,)
-        okay = u'whatever'
-        fail_case = u'Whatever'
-        fail_type = 'whatever'
-
-        # Scenario 1: multivalue=False
-        o = self.cls(name, type=type_, rules=my_rules)
-        assert o.rules == my_rules
-        assert o.all_rules == (type_.validate, case_rule)
-        o.validate(okay)
-        e = raises(errors.RuleError, o.validate, fail_case)
-        assert e.name is name
-        assert e.value is fail_case
-        assert e.error == 'Must be lower case'
-        assert e.rule is case_rule
-        assert e.index is None
-        check_TypeError(fail_type, unicode, 'value', o.validate, fail_type)
-
-        ## Scenario 2: multivalue=True
-        o = self.cls(name, type=type_, multivalue=True, rules=my_rules)
-        o.validate((okay,))
-        cnt = 5
-        for i in xrange(cnt):
-            others = list(okay for x in xrange(cnt))
-            others[i] = fail_case
-            value = tuple(others)
-            e = raises(errors.RuleError, o.validate, value)
-            assert e.name is name
-            assert e.value is fail_case
-            assert e.error == 'Must be lower case'
-            assert e.rule is case_rule
-            assert e.index == i
-        for not_tuple in (okay, [okay]):
-            check_TypeError(not_tuple, tuple, 'value', o.validate, not_tuple)
-        for has_str in [(fail_type,), (okay, fail_type)]:
-            check_TypeError(fail_type, unicode, 'value', o.validate, has_str)
-
-    def test_get_default(self):
-        """
-        Test the `ipalib.frontend.Param.get_default` method.
-        """
-        name = 'greeting'
-        default = u'Hello, world!'
-        default_from = frontend.DefaultFrom(
-            lambda first, last: u'Hello, %s %s!' % (first, last),
-            'first', 'last'
-        )
-
-        # Scenario 1: multivalue=False
-        o = self.cls(name,
-            default=default,
-            default_from=default_from,
-        )
-        assert o.default is default
-        assert o.default_from is default_from
-        assert o.get_default() == default
-        assert o.get_default(first='John', last='Doe') == 'Hello, John Doe!'
-
-        # Scenario 2: multivalue=True
-        default = (default,)
-        o = self.cls(name,
-            default=default,
-            default_from=default_from,
-            multivalue=True,
-        )
-        assert o.default is default
-        assert o.default_from is default_from
-        assert o.get_default() == default
-        assert o.get_default(first='John', last='Doe') == ('Hello, John Doe!',)
-
-    def test_get_value(self):
-        """
-        Test the `ipalib.frontend.Param.get_values` method.
-        """
-        name = 'status'
-        values = (u'Active', u'Inactive')
-        o = self.cls(name, type=ipa_types.Unicode())
-        assert o.get_values() == tuple()
-        o = self.cls(name, type=ipa_types.Enum(*values))
-        assert o.get_values() == values
-
-    def test_repr(self):
-        """
-        Test the `ipalib.frontend.Param.__repr__` method.
-        """
-        for name in ['name', 'name?', 'name*', 'name+']:
-            o = self.cls(name)
-            assert repr(o) == 'Param(%r)' % name
-        o = self.cls('name', required=False)
-        assert repr(o) == "Param('name', required=False)"
-        o = self.cls('name', multivalue=True)
-        assert repr(o) == "Param('name', multivalue=True)"
-
-
-def test_create_param():
-    """
-    Test the `ipalib.frontend.create_param` function.
-    """
-    f = frontend.create_param
-    for name in ['arg', 'arg?', 'arg*', 'arg+']:
-        o = f(name)
-        assert type(o) is frontend.Param
-        assert type(o.type) is ipa_types.Unicode
-        assert o.name == 'arg'
-        assert f(o) is o
-    o = f('arg')
-    assert o.required is True
-    assert o.multivalue is False
-    o = f('arg?')
-    assert o.required is False
-    assert o.multivalue is False
-    o = f('arg*')
-    assert o.required is False
-    assert o.multivalue is True
-    o = f('arg+')
-    assert o.required is True
-    assert o.multivalue is True
-
-
 class test_Command(ClassChecker):
     """
     Test the `ipalib.frontend.Command` class.