Removed depreciated code in ipalib.plugable that has been moving into ipalib.base

tests/test_ipalib/test_plugable.py

@@ -28,100 +28,6 @@ from tests.util import ClassChecker, create_test_api
 from ipalib import plugable, errors
 
 
-class test_ReadOnly(ClassChecker):
-    """
-    Test the `ipalib.plugable.ReadOnly` class
-    """
-    _cls = plugable.ReadOnly
-
-    def test_class(self):
-        """
-        Test the `ipalib.plugable.ReadOnly` class
-        """
-        assert self.cls.__bases__ == (object,)
-        assert callable(self.cls.__lock__)
-        assert callable(self.cls.__islocked__)
-
-    def test_lock(self):
-        """
-        Test the `ipalib.plugable.ReadOnly.__lock__` method.
-        """
-        o = self.cls()
-        assert o._ReadOnly__locked is False
-        o.__lock__()
-        assert o._ReadOnly__locked is True
-        e = raises(AssertionError, o.__lock__) # Can only be locked once
-        assert str(e) == '__lock__() can only be called once'
-        assert o._ReadOnly__locked is True # This should still be True
-
-    def test_lock(self):
-        """
-        Test the `ipalib.plugable.ReadOnly.__islocked__` method.
-        """
-        o = self.cls()
-        assert o.__islocked__() is False
-        o.__lock__()
-        assert o.__islocked__() is True
-
-    def test_setattr(self):
-        """
-        Test the `ipalib.plugable.ReadOnly.__setattr__` method.
-        """
-        o = self.cls()
-        o.attr1 = 'Hello, world!'
-        assert o.attr1 == 'Hello, world!'
-        o.__lock__()
-        for name in ('attr1', 'attr2'):
-            e = raises(AttributeError, setattr, o, name, 'whatever')
-            assert str(e) == 'read-only: cannot set ReadOnly.%s' % name
-        assert o.attr1 == 'Hello, world!'
-
-    def test_delattr(self):
-        """
-        Test the `ipalib.plugable.ReadOnly.__delattr__` method.
-        """
-        o = self.cls()
-        o.attr1 = 'Hello, world!'
-        o.attr2 = 'How are you?'
-        assert o.attr1 == 'Hello, world!'
-        assert o.attr2 == 'How are you?'
-        del o.attr1
-        assert not hasattr(o, 'attr1')
-        o.__lock__()
-        e = raises(AttributeError, delattr, o, 'attr2')
-        assert str(e) == 'read-only: cannot del ReadOnly.attr2'
-        assert o.attr2 == 'How are you?'
-
-
-def test_lock():
-    """
-    Test the `ipalib.plugable.lock` function.
-    """
-    f = plugable.lock
-
-    # Test on a ReadOnly instance:
-    o = plugable.ReadOnly()
-    assert not o.__islocked__()
-    assert f(o) is o
-    assert o.__islocked__()
-
-    # Test on something not subclassed from ReadOnly:
-    class not_subclass(object):
-        def __lock__(self):
-            pass
-        def __islocked__(self):
-            return True
-    o = not_subclass()
-    raises(ValueError, f, o)
-
-    # Test that it checks __islocked__():
-    class subclass(plugable.ReadOnly):
-        def __islocked__(self):
-            return False
-    o = subclass()
-    raises(AssertionError, f, o)
-
-
 class test_SetProxy(ClassChecker):
     """
     Test the `ipalib.plugable.SetProxy` class.
@@ -472,7 +378,6 @@ class test_Plugin(ClassChecker):
         assert e.argv == ('/bin/false',)
 
 
-
 class test_PluginProxy(ClassChecker):
     """
     Test the `ipalib.plugable.PluginProxy` class.
@@ -595,102 +500,6 @@ class test_PluginProxy(ClassChecker):
         assert read_only(c, 'name') == 'another_name'
 
 
-def test_check_name():
-    """
-    Test the `ipalib.plugable.check_name` function.
-    """
-    f = plugable.check_name
-    okay = [
-        'user_add',
-        'stuff2junk',
-        'sixty9',
-    ]
-    nope = [
-        '_user_add',
-        '__user_add',
-        'user_add_',
-        'user_add__',
-        '_user_add_',
-        '__user_add__',
-        '60nine',
-    ]
-    for name in okay:
-        assert name is f(name)
-        e = raises(TypeError, f, unicode(name))
-        assert str(e) == errors.TYPE_FORMAT % ('name', str, unicode(name))
-    for name in nope:
-        raises(errors.NameSpaceError, f, name)
-    for name in okay:
-        raises(errors.NameSpaceError, f, name.upper())
-
-class DummyMember(object):
-    def __init__(self, i):
-        assert type(i) is int
-        self.name = 'member_%02d' % i
-
-
-class test_NameSpace(ClassChecker):
-    """
-    Test the `ipalib.plugable.NameSpace` class.
-    """
-    _cls = plugable.NameSpace
-
-    def test_class(self):
-        """
-        Test the `ipalib.plugable.NameSpace` class.
-        """
-        assert self.cls.__bases__ == (plugable.ReadOnly,)
-
-    def test_init(self):
-        """
-        Test the `ipalib.plugable.NameSpace.__init__` method.
-        """
-        o = self.cls(tuple())
-        assert list(o) == []
-        assert list(o()) == []
-        for cnt in (10, 25):
-            members = tuple(DummyMember(cnt - i) for i in xrange(cnt))
-            for sort in (True, False):
-                o = self.cls(members, sort=sort)
-                if sort:
-                    ordered = tuple(sorted(members, key=lambda m: m.name))
-                else:
-                    ordered = members
-                names = tuple(m.name for m in ordered)
-                assert o.__todict__() == dict((o.name, o) for o in ordered)
-
-                # Test __len__:
-                assert len(o) == cnt
-
-                # Test __contains__:
-                for name in names:
-                    assert name in o
-                assert ('member_00') not in o
-
-                # Test __iter__, __call__:
-                assert tuple(o) == names
-                assert tuple(o()) == ordered
-
-                # Test __getitem__, getattr:
-                for (i, member) in enumerate(ordered):
-                    assert o[i] is member
-                    name = member.name
-                    assert o[name] is member
-                    assert read_only(o, name) is member
-
-                # Test negative indexes:
-                for i in xrange(1, cnt + 1):
-                    assert o[-i] is ordered[-i]
-
-                # Test slices:
-                assert o[2:cnt-5] == ordered[2:cnt-5]
-                assert o[::3] == ordered[::3]
-
-                # Test __repr__:
-                assert repr(o) == \
-                    'NameSpace(<%d members>, sort=%r)' % (cnt, sort)
-
-
 def test_Registrar():
     """
     Test the `ipalib.plugable.Registrar` class