[Checkins] SVN: zope.i18nmessageid/branches/tseaver-no_2to3/ 100% unit test coverage.

[Tres Seaver]

Log message for revision 125050:
  100% unit test coverage.

Changed:
  U   zope.i18nmessageid/branches/tseaver-no_2to3/CHANGES.txt
  U   zope.i18nmessageid/branches/tseaver-no_2to3/src/zope/i18nmessageid/tests.py

-=-
Modified: zope.i18nmessageid/branches/tseaver-no_2to3/CHANGES.txt
===================================================================
--- zope.i18nmessageid/branches/tseaver-no_2to3/CHANGES.txt	2012-04-06 22:49:03 UTC (rev 125049)
+++ zope.i18nmessageid/branches/tseaver-no_2to3/CHANGES.txt	2012-04-06 22:49:07 UTC (rev 125050)
@@ -5,6 +5,8 @@
 4.0.0 (unreleased)
 ------------------
 
+- 100% unit test coverage.
+
 - Move doctest examples into Sphinx documentation.
 
 - Dropped explicit support for Python 2.4 / 2.5 / 3.1.

Modified: zope.i18nmessageid/branches/tseaver-no_2to3/src/zope/i18nmessageid/tests.py
===================================================================
--- zope.i18nmessageid/branches/tseaver-no_2to3/src/zope/i18nmessageid/tests.py	2012-04-06 22:49:03 UTC (rev 125049)
+++ zope.i18nmessageid/branches/tseaver-no_2to3/src/zope/i18nmessageid/tests.py	2012-04-06 22:49:07 UTC (rev 125050)
@@ -90,15 +90,9 @@
         message = self._makeOne('testing')
         def _try():
             message.unknown = 'unknown'
-        self.assertRaises(TypeError, _try)
+        # C version raises AttributeError, Python version TypeError
+        self.assertRaises((TypeError, AttributeError), _try)
 
-    def test___getstate__(self):
-        mapping = {'key': 'value'}
-        source = self._makeOne('testing')
-        message = self._makeOne(source, 'domain', 'default', mapping)
-        state = message.__getstate__()
-        self.assertEqual(state, ('testing', 'domain', 'default', mapping))
-
     def test___reduce__(self):
         mapping = {'key': 'value'}
         source = self._makeOne('testing')
@@ -107,6 +101,7 @@
         self.assertTrue(klass is self._getTargetClass())
         self.assertEqual(state, ('testing', 'domain', 'default', mapping))
 
+
 class MessageTests(PyMessageTests):
 
     _TEST_REAOONLY = False
@@ -116,99 +111,40 @@
         return Message
 
 
-class Functional(unittest.TestCase):
+class MessageFactoryTests(unittest.TestCase):
 
-    def test_message_pickling(self):
-        from zope.i18nmessageid.message import pyMessage as Message
-        robot = Message(u"robot-message", 'futurama', u"${name} is a robot.")
+    def _getTargetClass(self):
+        from zope.i18nmessageid.message import MessageFactory
+        return MessageFactory
 
-        self.assertEqual(robot, u'robot-message')
-        self.assertTrue(isinstance(robot, unicode))
-        self.assertEqual(robot.default, u'${name} is a robot.')
-        self.assertEqual(robot.mapping, None)
+    def _makeOne(self, *args, **kw):
+        return self._getTargetClass()(*args, **kw)
 
-        # Only the python implementation has a _readonly attribute
-        self.assertEqual(robot._readonly, True)
-        self.assertRaises(
-            TypeError,
-            robot.__setattr__, 'domain', "planetexpress")
-        self.assertRaises(
-            TypeError,
-            robot.__setattr__, 'default', u"${name} is not a robot.")
-        self.assertRaises(
-            TypeError,
-            robot.__setattr__, 'mapping', {u'name': u'Bender'})
-        
-        new_robot = Message(robot, mapping={u'name': u'Bender'})
-        self.assertEqual(new_robot, u'robot-message')
-        self.assertEqual(new_robot.domain, 'futurama')
-        self.assertEqual(new_robot.default, u'${name} is a robot.')
-        self.assertEqual(new_robot.mapping, {u'name': u'Bender'})
+    def test___call___defaults(self):
+        from zope.i18nmessageid.message import Message
+        factory = self._makeOne('domain')
+        message = factory('testing')
+        self.assertTrue(isinstance(message, Message))
+        self.assertEqual(message, 'testing')
+        self.assertEqual(message.domain, 'domain')
+        self.assertEqual(message.default, None)
+        self.assertEqual(message.mapping, None)
 
-        callable, args = new_robot.__reduce__()
-        self.assertTrue(callable is Message)
-        self.assertEqual(
-            args,
-            (u'robot-message', 'futurama', u'${name} is a robot.',
-             {u'name': u'Bender'}))
+    def test___call___explicit(self):
+        from zope.i18nmessageid.message import Message
+        mapping = {'key': 'value'}
+        factory = self._makeOne('domain')
+        message = factory('testing', 'default', mapping)
+        self.assertTrue(isinstance(message, Message))
+        self.assertEqual(message, 'testing')
+        self.assertEqual(message.domain, 'domain')
+        self.assertEqual(message.default, 'default')
+        self.assertEqual(message.mapping, mapping)
 
-        fembot = Message(u'fembot')
-        callable, args = fembot.__reduce__()
-        self.assertTrue(callable is Message)
-        self.assertEqual(args, (u'fembot', None, None, None))
 
-        import zope.i18nmessageid.message
-        zope.i18nmessageid.message.Message = Message
-
-        # First check if pickling and unpickling from pyMessage to
-        # pyMessage works
-        from pickle import dumps, loads
-        pystate = dumps(new_robot)
-        pickle_bot = loads(pystate)
-        self.assertEqual(pickle_bot, u'robot-message')
-        self.assertEqual(pickle_bot.domain, 'futurama')
-        self.assertEqual(pickle_bot.default, u'${name} is a robot.')
-        self.assertEqual(pickle_bot.mapping, {u'name': u'Bender'})
-        self.assertEqual(pickle_bot._readonly, True)
-
-        from zope.i18nmessageid.message import pyMessage
-        self.assertTrue(pickle_bot.__reduce__()[0] is pyMessage)
-        del pickle_bot
-
-        # Second check if cMessage is able to load the state of a pyMessage
-        try:
-            from zope.i18nmessageid._zope_i18nmessageid_message import Message
-        except ImportError:
-            return
-        from zope.i18nmessageid._zope_i18nmessageid_message import (
-                                                        Message as cMessage)
-        zope.i18nmessageid.message.Message = Message
-        c_bot = loads(pystate) 
-        self.assertEqual(c_bot, u'robot-message')
-        self.assertEqual(c_bot.domain, 'futurama')
-        self.assertEqual(c_bot.default, u'${name} is a robot.')
-        self.assertEqual(c_bot.mapping, {u'name': u'Bender'})
-        self.assertFalse(hasattr(c_bot, '_readonly'))
-        self.assertTrue(c_bot.__reduce__()[0] is cMessage)
-
-        # Last check if pyMessage can load a state of cMessage
-        cstate = dumps(c_bot)
-        del c_bot
-        from zope.i18nmessageid.message import pyMessage as Message
-        zope.i18nmessageid.message.Message = Message
-        py_bot = loads(cstate)
-        self.assertEqual(py_bot, u'robot-message')
-        self.assertEqual(py_bot.domain, 'futurama')
-        self.assertEqual(py_bot.default, u'${name} is a robot.')
-        self.assertEqual(py_bot.mapping, {u'name': u'Bender'})
-        self.assertEqual(py_bot._readonly, True)
-        self.assertTrue(py_bot.__reduce__()[0] is pyMessage)
-
-        # Both pickle states should be equal
-        self.assertEqual(pystate, cstate)
-
-
 def test_suite():
     return unittest.TestSuite((
         unittest.makeSuite(PyMessageTests),
+        unittest.makeSuite(MessageTests),
+        unittest.makeSuite(MessageFactoryTests),
     ))