Add ipalib.messages

The messages module contains message classes that can be added
to a RPC response to provide additional information or warnings.

This patch adds only the module with a single public message,
VersionMissing, and unit tests.
Since message classes are very similar to public errors, some
functionality and unit tests were shared.

Design page: http://freeipa.org/page/V3/Messages
Ticket: https://fedorahosted.org/freeipa/ticket/2732

2 files changed, 102 insertions, 30 deletions

diff --git a/tests/test_ipalib/test_errors.py b/tests/test_ipalib/test_errors.py
index 1421e784..49bed710 100644
--- a/tests/test_ipalib/test_errors.py
+++ b/tests/test_ipalib/test_errors.py
@@ -23,6 +23,7 @@ Test the `ipalib.errors` module.
 
 import re
 import inspect
+
 from tests.util import assert_equal, raises
 from ipalib import errors, text
 from ipalib.constants import TYPE_ERROR
@@ -210,8 +211,8 @@ class PublicExceptionTester(object):
         for (key, value) in kw.iteritems():
             assert not hasattr(self.klass, key), key
         inst = self.klass(format=format, message=message, **kw)
-        assert isinstance(inst, StandardError)
-        assert isinstance(inst, errors.PublicError)
+        for required_class in self.required_classes:
+            assert isinstance(inst, required_class)
         assert isinstance(inst, self.klass)
         assert not isinstance(inst, errors.PrivateError)
         for (key, value) in kw.iteritems():
@@ -224,11 +225,9 @@ class test_PublicError(PublicExceptionTester):
     Test the `ipalib.errors.PublicError` exception.
     """
     _klass = errors.PublicError
+    required_classes = StandardError, errors.PublicError
 
     def test_init(self):
-        """
-        Test the `ipalib.errors.PublicError.__init__` method.
-        """
         message = u'The translated, interpolated message'
         format = 'key=%(key1)r and key2=%(key2)r'
         uformat = u'Translated key=%(key1)r and key2=%(key2)r'
@@ -259,8 +258,8 @@ class test_PublicError(PublicExceptionTester):
 
         # Test with format=None, message=None
         e = raises(ValueError, self.klass, **kw)
-        assert str(e) == \
-            'PublicError.format is None yet format=None, message=None'
+        assert (str(e) == '%s.format is None yet format=None, message=None' %
+            self.klass.__name__)
 
 
         ######################################
@@ -336,27 +335,40 @@ class test_PublicError(PublicExceptionTester):
         assert_equal(list(inst_match),list(instructions))
 
 
-def test_public_errors():
-    """
-    Test the `ipalib.errors.public_errors` module variable.
+class BaseMessagesTest(object):
+    """Generic test for all of a module's errors or messages
     """
-    i = 0
-    for klass in errors.public_errors:
-        assert issubclass(klass, StandardError)
-        assert issubclass(klass, errors.PublicError)
-        assert not issubclass(klass, errors.PrivateError)
-        assert type(klass.errno) is int
-        assert 900 <= klass.errno <= 5999
-        doc = inspect.getdoc(klass)
-        assert doc is not None, 'need class docstring for %s' % klass.__name__
-        m = re.match(r'^\*{2}(\d+)\*{2} ', doc)
-        assert m is not None, "need '**ERRNO**' in %s docstring" % klass.__name__
-        errno = int(m.group(1))
-        assert errno == klass.errno, (
-            'docstring=%r but errno=%r in %s' % (errno, klass.errno, klass.__name__)
-        )
-
-        # Test format
-        if klass.format is not None:
-            assert klass.format is errors.__messages[i]
-            i += 1
+    def test_public_messages(self):
+        i = 0
+        for klass in self.message_list:
+            for required_class in self.required_classes:
+                assert issubclass(klass, required_class)
+            assert type(klass.errno) is int
+            assert klass.errno in self.errno_range
+            doc = inspect.getdoc(klass)
+            assert doc is not None, 'need class docstring for %s' % klass.__name__
+            m = re.match(r'^\*{2}(\d+)\*{2} ', doc)
+            assert m is not None, "need '**ERRNO**' in %s docstring" % klass.__name__
+            errno = int(m.group(1))
+            assert errno == klass.errno, (
+                'docstring=%r but errno=%r in %s' % (errno, klass.errno, klass.__name__)
+            )
+            self.extratest(klass)
+
+            # Test format
+            if klass.format is not None:
+                assert klass.format is self.texts[i]
+                i += 1
+
+    def extratest(self, cls):
+        pass
+
+
+class test_PublicErrors(object):
+    message_list = errors.public_errors
+    errno_range = xrange(900, 5999)
+    required_classes = (StandardError, errors.PublicError)
+    texts = errors._texts
+
+    def extratest(self, cls):
+        assert not issubclass(cls, errors.PrivateError)
diff --git a/tests/test_ipalib/test_messages.py b/tests/test_ipalib/test_messages.py
new file mode 100644
index 00000000..d6a4b9aa
--- /dev/null
+++ b/tests/test_ipalib/test_messages.py
@@ -0,0 +1,60 @@
+# Authors:
+#   Petr Viktorin <pviktori@redhat.com>
+#
+# Copyright (C) 1012  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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+"""
+Test the `ipalib.messages` module.
+"""
+
+from ipalib import messages
+from tests.test_ipalib import test_errors
+
+
+class HelloMessage(messages.PublicMessage):
+    type = 'info'
+    format = '%(greeting)s, %(object)s!'
+    errno = 1234
+
+
+class test_PublicMessage(test_errors.test_PublicError):
+    """Test public messages"""
+    # The messages are a lot like public errors; defer testing to that.
+    klass = messages.PublicMessage
+    required_classes = (UserWarning, messages.PublicMessage)
+
+
+class test_PublicMessages(test_errors.BaseMessagesTest):
+    message_list = messages.public_messages
+    errno_range = xrange(10000, 19999)
+    required_classes = (UserWarning, messages.PublicMessage)
+    texts = messages._texts
+
+    def extratest(self, cls):
+        if cls is not messages.PublicMessage:
+            assert cls.type in ('debug', 'info', 'warning', 'error')
+
+
+def test_to_dict():
+    expected = dict(
+        name='HelloMessage',
+        type='info',
+        message='Hello, world!',
+        code=1234,
+    )
+
+    assert HelloMessage(greeting='Hello', object='world').to_dict() == expected