tests: add some more helper function tests.

tests/call_error_test.py

@@ -16,15 +16,18 @@ class ConstructorTest(testlib.TestCase):
     def test_string_noargs(self):
         e = self.klass('%s%s')
         self.assertEquals(e.args[0], '%s%s')
+        self.assertTrue(isinstance(e.args[0], mitogen.core.UnicodeType))
 
     def test_string_args(self):
         e = self.klass('%s%s', 1, 1)
         self.assertEquals(e.args[0], '11')
+        self.assertTrue(isinstance(e.args[0], mitogen.core.UnicodeType))
 
     def test_from_exc(self):
         ve = plain_old_module.MyError('eek')
         e = self.klass(ve)
         self.assertEquals(e.args[0], 'plain_old_module.MyError: eek')
+        self.assertTrue(isinstance(e.args[0], mitogen.core.UnicodeType))
 
     def test_form_base_exc(self):
         ve = SystemExit('eek')
@@ -32,6 +35,7 @@ class ConstructorTest(testlib.TestCase):
         self.assertEquals(e.args[0],
             # varies across 2/3.
             '%s.%s: eek' % (type(ve).__module__, type(ve).__name__))
+        self.assertTrue(isinstance(e.args[0], mitogen.core.UnicodeType))
 
     def test_from_exc_tb(self):
         try:
@@ -41,8 +45,39 @@ class ConstructorTest(testlib.TestCase):
             e = self.klass(ve)
 
         self.assertTrue(e.args[0].startswith('plain_old_module.MyError: eek'))
+        self.assertTrue(isinstance(e.args[0], mitogen.core.UnicodeType))
         self.assertTrue('test_from_exc_tb' in e.args[0])
 
+    def test_bytestring_conversion(self):
+        e = self.klass(mitogen.core.b('bytes'))
+        self.assertEquals(u'bytes', e.args[0])
+        self.assertTrue(isinstance(e.args[0], mitogen.core.UnicodeType))
+
+    def test_reduce(self):
+        e = self.klass('eek')
+        func, (arg,) = e.__reduce__()
+        self.assertTrue(func is mitogen.core._unpickle_call_error)
+        self.assertEquals(arg, e.args[0])
+
+
+class UnpickleCallErrorTest(testlib.TestCase):
+    func = staticmethod(mitogen.core._unpickle_call_error)
+
+    def test_not_unicode(self):
+        self.assertRaises(TypeError,
+            lambda: self.func(mitogen.core.b('bad')))
+
+    def test_oversized(self):
+        self.assertRaises(TypeError,
+            lambda: self.func(mitogen.core.b('b'*10001)))
+
+    def test_reify(self):
+        e = self.func(u'some error')
+        self.assertEquals(mitogen.core.CallError, type(e))
+        self.assertEquals(1, len(e.args))
+        self.assertEquals(mitogen.core.UnicodeType, type(e.args[0]))
+        self.assertEquals(u'some error', e.args[0])
+
 
 class PickleTest(testlib.TestCase):
     klass = mitogen.core.CallError

tests/error_test.py

@@ -0,0 +1,40 @@
+
+import logging
+import subprocess
+import time
+import zlib
+
+import unittest2
+
+import testlib
+import mitogen.master
+import mitogen.parent
+import mitogen.utils
+
+
+class ConstructorTest(testlib.TestCase):
+    klass = mitogen.core.Error
+
+    def test_literal_no_format(self):
+        e = self.klass('error')
+        self.assertEquals(e.args[0], 'error')
+        self.assertTrue(isinstance(e.args[0], mitogen.core.UnicodeType))
+
+    def test_literal_format_chars_present(self):
+        e = self.klass('error%s')
+        self.assertEquals(e.args[0], 'error%s')
+        self.assertTrue(isinstance(e.args[0], mitogen.core.UnicodeType))
+
+    def test_format(self):
+        e = self.klass('error%s', 123)
+        self.assertEquals(e.args[0], 'error123')
+        self.assertTrue(isinstance(e.args[0], mitogen.core.UnicodeType))
+
+    def test_bytes_to_unicode(self):
+        e = self.klass(mitogen.core.b('error'))
+        self.assertEquals(e.args[0], 'error')
+        self.assertTrue(isinstance(e.args[0], mitogen.core.UnicodeType))
+
+
+if __name__ == '__main__':
+    unittest2.main()

tests/policy_function_test.py

@@ -0,0 +1,40 @@
+
+import mock
+import unittest2
+
+import mitogen.core
+import mitogen.parent
+
+import testlib
+
+
+class HasParentAuthorityTest(testlib.TestCase):
+    func = staticmethod(mitogen.core.has_parent_authority)
+
+    def call(self, auth_id):
+        msg = mitogen.core.Message(auth_id=auth_id)
+        return self.func(msg)
+
+    @mock.patch('mitogen.context_id', 5555)
+    @mock.patch('mitogen.parent_ids', [111, 222])
+    def test_okay(self):
+        self.assertFalse(self.call(0))
+        self.assertTrue(self.call(5555))
+        self.assertTrue(self.call(111))
+
+
+class IsImmediateChildTest(testlib.TestCase):
+    func = staticmethod(mitogen.core.has_parent_authority)
+
+    def call(self, auth_id, remote_id):
+        msg = mitogen.core.Message(auth_id=auth_id)
+        stream = mock.Mock(remote_id=remote_id)
+        return self.func(msg, stream)
+
+    def test_okay(self):
+        self.assertFalse(0, 1)
+        self.assertTrue(1, 1)
+
+
+if __name__ == '__main__':
+    unittest2.main()

tests/types_test.py

@@ -76,5 +76,59 @@ class SecretTest(testlib.TestCase):
                           mitogen.core.b(secret2))
 
 
+class KwargsTest(testlib.TestCase):
+    klass = mitogen.core.Kwargs
+
+    def test_empty(self):
+        kw = self.klass({})
+        self.assertEquals({}, kw)
+        self.assertEquals('Kwargs({})', repr(kw))
+        klass, (dct,) = kw.__reduce__()
+        self.assertTrue(klass is self.klass)
+        self.assertTrue(type(dct) is dict)
+        self.assertEquals({}, dct)
+
+    @unittest2.skipIf(condition=lambda: not mitogen.core.PY3,
+                      reason='py3 only')
+    def test_unicode_conversion(self):
+        kw = self.klass({mitogen.core.b('key'): 123})
+        self.assertEquals({mitogen.core.b('key'): 123}, kw)
+        self.assertEquals("Kwargs({'key': 123})", repr(kw))
+        klass, (dct,) = kw.__reduce__()
+        self.assertTrue(klass is self.klass)
+        self.assertTrue(type(dct) is dict)
+        self.assertEquals({u'key': 123}, dct)
+        key, = dct
+        self.assertTrue(type(key) is mitogen.core.UnicodeType)
+
+
+class AdornedUnicode(mitogen.core.UnicodeType):
+    pass
+
+
+class ToTextTest(testlib.TestCase):
+    func = staticmethod(mitogen.core.to_text)
+
+    def test_bytes(self):
+        s = self.func(mitogen.core.b('bytes'))
+        self.assertEquals(mitogen.core.UnicodeType, type(s))
+        self.assertEquals(s, u'bytes')
+
+    def test_unicode(self):
+        s = self.func(u'text')
+        self.assertEquals(mitogen.core.UnicodeType, type(s))
+        self.assertEquals(s, u'text')
+
+    def test_adorned_unicode(self):
+        s = self.func(AdornedUnicode(u'text'))
+        self.assertEquals(mitogen.core.UnicodeType, type(s))
+        self.assertEquals(s, u'text')
+
+    def test_integer(self):
+        s = self.func(123)
+        self.assertEquals(mitogen.core.UnicodeType, type(s))
+        self.assertEquals(s, u'123')
+
+
 if __name__ == '__main__':
     unittest2.main()