Finish work replacing the errors module with errors2

Once this is committed we can start the process of renaming errors2 as errors.
I thought that combinig this into one commit would be more difficult to
review.

3 files changed, 2 insertions, 291 deletions

diff --git a/tests/test_ipalib/test_errors.py b/tests/test_ipalib/test_errors.py
deleted file mode 100644
index f1dd5dc8e..000000000
--- a/tests/test_ipalib/test_errors.py
+++ /dev/null
@@ -1,289 +0,0 @@
-# Authors:
-#   Jason Gerard DeRose <jderose@redhat.com>
-#
-# Copyright (C) 2008  Red Hat
-# see file 'COPYING' for use and warranty information
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation; version 2 only
-#
-# This program 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 General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-"""
-Test the `ipalib.errors` module.
-"""
-
-from tests.util import raises, ClassChecker
-from ipalib import errors
-
-
-type_format = '%s: need a %r; got %r'
-
-
-def check_TypeError(f, value, type_, name, **kw):
-    e = raises(TypeError, f, value, type_, name, **kw)
-    assert e.value is value
-    assert e.type is type_
-    assert e.name is name
-    assert str(e) == type_format % (name, type_, value)
-
-
-def test_raise_TypeError():
-    """
-    Test the `ipalib.errors.raise_TypeError` function.
-    """
-    f = errors.raise_TypeError
-    value = 'Hello.'
-    type_ = unicode
-    name = 'message'
-
-    check_TypeError(f, value, type_, name)
-
-    # name not an str
-    fail_name = 42
-    e = raises(AssertionError, f, value, type_, fail_name)
-    assert str(e) == type_format % ('name', str, fail_name), str(e)
-
-    # type_ not a type:
-    fail_type = unicode()
-    e = raises(AssertionError, f, value, fail_type, name)
-    assert str(e) == type_format % ('type_', type, fail_type)
-
-    # type(value) is type_:
-    fail_value = u'How are you?'
-    e = raises(AssertionError, f, fail_value, type_, name)
-    assert str(e) == 'value: %r is a %r' % (fail_value, type_)
-
-
-def test_check_type():
-    """
-    Test the `ipalib.errors.check_type` function.
-    """
-    f = errors.check_type
-    value = 'How are you?'
-    type_ = str
-    name = 'greeting'
-
-    # Should pass:
-    assert value is f(value, type_, name)
-    assert None is f(None, type_, name, allow_none=True)
-
-    # Should raise TypeError
-    check_TypeError(f, None, type_, name)
-    check_TypeError(f, value, basestring, name)
-    check_TypeError(f, value, unicode, name)
-
-    # name not an str
-    fail_name = unicode(name)
-    e = raises(AssertionError, f, value, type_, fail_name)
-    assert str(e) == type_format % ('name', str, fail_name)
-
-    # type_ not a type:
-    fail_type = 42
-    e = raises(AssertionError, f, value, fail_type, name)
-    assert str(e) == type_format % ('type_', type, fail_type)
-
-    # allow_none not a bool:
-    fail_bool = 0
-    e = raises(AssertionError, f, value, type_, name, allow_none=fail_bool)
-    assert str(e) == type_format % ('allow_none', bool, fail_bool)
-
-
-def test_check_isinstance():
-    """
-    Test the `ipalib.errors.check_isinstance` function.
-    """
-    f = errors.check_isinstance
-    value = 'How are you?'
-    type_ = str
-    name = 'greeting'
-
-    # Should pass:
-    assert value is f(value, type_, name)
-    assert value is f(value, basestring, name)
-    assert None is f(None, type_, name, allow_none=True)
-
-    # Should raise TypeError
-    check_TypeError(f, None, type_, name)
-    check_TypeError(f, value, unicode, name)
-
-    # name not an str
-    fail_name = unicode(name)
-    e = raises(AssertionError, f, value, type_, fail_name)
-    assert str(e) == type_format % ('name', str, fail_name)
-
-    # type_ not a type:
-    fail_type = 42
-    e = raises(AssertionError, f, value, fail_type, name)
-    assert str(e) == type_format % ('type_', type, fail_type)
-
-    # allow_none not a bool:
-    fail_bool = 0
-    e = raises(AssertionError, f, value, type_, name, allow_none=fail_bool)
-    assert str(e) == type_format % ('allow_none', bool, fail_bool)
-
-
-class test_IPAError(ClassChecker):
-    """
-    Test the `ipalib.errors.IPAError` exception.
-    """
-    _cls = errors.IPAError
-
-    def test_class(self):
-        """
-        Test the `ipalib.errors.IPAError` exception.
-        """
-        assert self.cls.__bases__ == (StandardError,)
-
-    def test_init(self):
-        """
-        Test the `ipalib.errors.IPAError.__init__` method.
-        """
-        args = ('one fish', 'two fish')
-        e = self.cls(*args)
-        assert e.args == args
-        assert self.cls().args == tuple()
-
-    def test_str(self):
-        """
-        Test the `ipalib.errors.IPAError.__str__` method.
-        """
-        f = 'The %s color is %s.'
-        class custom_error(self.cls):
-            format = f
-        for args in [('sexiest', 'red'), ('most-batman-like', 'black')]:
-            e = custom_error(*args)
-            assert e.args == args
-            assert str(e) == f % args
-
-
-class test_ValidationError(ClassChecker):
-    """
-    Test the `ipalib.errors.ValidationError` exception.
-    """
-    _cls = errors.ValidationError
-
-    def test_class(self):
-        """
-        Test the `ipalib.errors.ValidationError` exception.
-        """
-        assert self.cls.__bases__ == (errors.IPAError,)
-
-    def test_init(self):
-        """
-        Test the `ipalib.errors.ValidationError.__init__` method.
-        """
-        name = 'login'
-        value = 'Whatever'
-        error = 'Must be lowercase.'
-        for index in (None, 3):
-            e = self.cls(name, value, error, index=index)
-            assert e.name is name
-            assert e.value is value
-            assert e.error is error
-            assert e.index is index
-            assert str(e) == 'invalid %r value %r: %s' % (name, value, error)
-        # Check that index default is None:
-        assert self.cls(name, value, error).index is None
-        # Check non str name raises AssertionError:
-        raises(AssertionError, self.cls, unicode(name), value, error)
-        # Check non int index raises AssertionError:
-        raises(AssertionError, self.cls, name, value, error, index=5.0)
-        # Check negative index raises AssertionError:
-        raises(AssertionError, self.cls, name, value, error, index=-2)
-
-
-class test_ConversionError(ClassChecker):
-    """
-    Test the `ipalib.errors.ConversionError` exception.
-    """
-    _cls = errors.ConversionError
-
-    def test_class(self):
-        """
-        Test the `ipalib.errors.ConversionError` exception.
-        """
-        assert self.cls.__bases__ == (errors.ValidationError,)
-
-    def test_init(self):
-        """
-        Test the `ipalib.errors.ConversionError.__init__` method.
-        """
-        name = 'some_arg'
-        value = '42.0'
-        class type_(object):
-            conversion_error = 'Not an integer'
-        for index in (None, 7):
-            e = self.cls(name, value, type_, index=index)
-            assert e.name is name
-            assert e.value is value
-            assert e.type is type_
-            assert e.error is type_.conversion_error
-            assert e.index is index
-            assert str(e) == 'invalid %r value %r: %s' % (name, value,
-                type_.conversion_error)
-        # Check that index default is None:
-        assert self.cls(name, value, type_).index is None
-
-
-class test_RuleError(ClassChecker):
-    """
-    Test the `ipalib.errors.RuleError` exception.
-    """
-    _cls = errors.RuleError
-
-    def test_class(self):
-        """
-        Test the `ipalib.errors.RuleError` exception.
-        """
-        assert self.cls.__bases__ == (errors.ValidationError,)
-
-    def test_init(self):
-        """
-        Test the `ipalib.errors.RuleError.__init__` method.
-        """
-        name = 'whatever'
-        value = 'The smallest weird number.'
-        def my_rule(value):
-            return 'Value is bad.'
-        error = my_rule(value)
-        for index in (None, 42):
-            e = self.cls(name, value, error, my_rule, index=index)
-            assert e.name is name
-            assert e.value is value
-            assert e.error is error
-            assert e.rule is my_rule
-        # Check that index default is None:
-        assert self.cls(name, value, error, my_rule).index is None
-
-
-class test_RequirementError(ClassChecker):
-    """
-    Test the `ipalib.errors.RequirementError` exception.
-    """
-    _cls = errors.RequirementError
-
-    def test_class(self):
-        """
-        Test the `ipalib.errors.RequirementError` exception.
-        """
-        assert self.cls.__bases__ == (errors.ValidationError,)
-
-    def test_init(self):
-        """
-        Test the `ipalib.errors.RequirementError.__init__` method.
-        """
-        name = 'givenname'
-        e = self.cls(name)
-        assert e.name is name
-        assert e.value is None
-        assert e.error == 'Required'
-        assert e.index is None
diff --git a/tests/test_ipalib/test_frontend.py b/tests/test_ipalib/test_frontend.py
index 7be94c4fd..744370415 100644
--- a/tests/test_ipalib/test_frontend.py
+++ b/tests/test_ipalib/test_frontend.py
@@ -26,7 +26,7 @@ from tests.util import check_TypeError, ClassChecker, create_test_api
 from tests.util import assert_equal
 from ipalib.constants import TYPE_ERROR
 from ipalib.base import NameSpace
-from ipalib import frontend, backend, plugable, errors2, errors, parameters, config
+from ipalib import frontend, backend, plugable, errors2, parameters, config
 
 def test_RULE_FLAG():
     assert frontend.RULE_FLAG == 'validation_rule'
diff --git a/tests/test_ipalib/test_plugable.py b/tests/test_ipalib/test_plugable.py
index c6c84fa16..4f54d3f7e 100644
--- a/tests/test_ipalib/test_plugable.py
+++ b/tests/test_ipalib/test_plugable.py
@@ -25,7 +25,7 @@ import inspect
 from tests.util import raises, no_set, no_del, read_only
 from tests.util import getitem, setitem, delitem
 from tests.util import ClassChecker, create_test_api
-from ipalib import plugable, errors, errors2
+from ipalib import plugable, errors2
 
 
 class test_SetProxy(ClassChecker):