Migrate tools/* from constants to pathutils

[ganeti-local] / test / ganeti.serializer_unittest.py

diff --git a/test/ganeti.serializer_unittest.py b/test/ganeti.serializer_unittest.py
index b1612d6..46aafc2 100755 (executable)
--- a/test/ganeti.serializer_unittest.py
+++ b/test/ganeti.serializer_unittest.py
@@ -16,7 +16,7 @@
 # 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., 51 Franklin Street, Fifth Floor, Boston, MA
-# 0.0510-1301, USA.
+# 02110-1301, USA.
 
 
 """Script for unittesting the serializer module"""
@@ -27,16 +27,10 @@ import unittest
 from ganeti import serializer
 from ganeti import errors
 
+import testutils
 
-class SimplejsonMock(object):
-  def dumps(self, data, indent=None):
-    return repr(data)
 
-  def loads(self, data):
-    return eval(data)
-
-
-class TestSerializer(unittest.TestCase):
+class TestSerializer(testutils.GanetiTestCase):
   """Serializer tests"""
 
   _TESTDATA = [
@@ -44,61 +38,73 @@ class TestSerializer(unittest.TestCase):
     255,
     [1, 2, 3],
     (1, 2, 3),
-    { 1: 2, "foo": "bar", },
+    { "1": 2, "foo": "bar", },
+    ["abc", 1, 2, 3, 999,
+      {
+        "a1": ("Hello", "World"),
+        "a2": "This is only a test",
+        "a3": None,
+        },
+      {
+        "foo": "bar",
+        },
+      ]
     ]
 
-  def setUp(self):
-    self._orig_simplejson = serializer.simplejson
-    serializer.simplejson = SimplejsonMock()
-
-  def tearDown(self):
-    serializer.simplejson = self._orig_simplejson
+  def _TestSerializer(self, dump_fn, load_fn):
+    for data in self._TESTDATA:
+      self.failUnless(dump_fn(data).endswith("\n"))
+      self.assertEqualValues(load_fn(dump_fn(data)), data)
 
   def testGeneric(self):
-    return self._TestSerializer(serializer.Dump, serializer.Load)
+    self._TestSerializer(serializer.Dump, serializer.Load)
+
+  def testSignedGeneric(self):
+    self._TestSigned(serializer.DumpSigned, serializer.LoadSigned)
 
   def testJson(self):
-    return self._TestSerializer(serializer.DumpJson, serializer.LoadJson)
+    self._TestSerializer(serializer.DumpJson, serializer.LoadJson)
 
-  def testSignedMessage(self):
-    LoadSigned = serializer.LoadSigned
-    DumpSigned = serializer.DumpSigned
-    SaltEqualTo = serializer.SaltEqualTo
-    SaltIn = serializer.SaltIn
-    SaltInRange = serializer.SaltInRange
+  def testSignedJson(self):
+    self._TestSigned(serializer.DumpSignedJson, serializer.LoadSignedJson)
 
+  def _TestSigned(self, dump_fn, load_fn):
     for data in self._TESTDATA:
-      self.assertEqual(LoadSigned(DumpSigned(data, "mykey"), "mykey"), data)
-      self.assertEqual(LoadSigned(
-                         DumpSigned(data, "myprivatekey", "mysalt"),
-                         "myprivatekey", SaltEqualTo("mysalt")), data)
-      self.assertEqual(LoadSigned(
-                         DumpSigned(data, "myprivatekey", "mysalt"),
-                         "myprivatekey", SaltIn(["notmysalt", "mysalt"])), data)
-      self.assertEqual(LoadSigned(
-                         DumpSigned(data, "myprivatekey", "12345"),
-                         "myprivatekey", SaltInRange(12340, 12346)), data)
-    self.assertRaises(errors.SignatureError, serializer.LoadSigned,
-                      serializer.DumpSigned("test", "myprivatekey"),
+      self.assertEqualValues(load_fn(dump_fn(data, "mykey"), "mykey"),
+                             (data, ''))
+      self.assertEqualValues(load_fn(dump_fn(data, "myprivatekey",
+                                             salt="mysalt"),
+                                     "myprivatekey"),
+                             (data, "mysalt"))
+
+      keydict = {
+        "mykey_id": "myprivatekey",
+        }
+      self.assertEqualValues(load_fn(dump_fn(data, "myprivatekey",
+                                             salt="mysalt",
+                                             key_selector="mykey_id"),
+                                     keydict.get),
+                             (data, "mysalt"))
+      self.assertRaises(errors.SignatureError, load_fn,
+                        dump_fn(data, "myprivatekey",
+                                salt="mysalt",
+                                key_selector="mykey_id"),
+                        {}.get)
+
+    self.assertRaises(errors.SignatureError, load_fn,
+                      dump_fn("test", "myprivatekey"),
                       "myotherkey")
-    self.assertRaises(errors.SignatureError, serializer.LoadSigned,
-                      serializer.DumpSigned("test", "myprivatekey", "salt"),
-                      "myprivatekey")
-    self.assertRaises(errors.SignatureError, serializer.LoadSigned,
-                      serializer.DumpSigned("test", "myprivatekey", "salt"),
-                      "myprivatekey", SaltIn(["notmysalt", "morenotmysalt"]))
-    self.assertRaises(errors.SignatureError, serializer.LoadSigned,
-                      serializer.DumpSigned("test", "myprivatekey", "salt"),
-                      "myprivatekey", SaltInRange(1, 2))
-    self.assertRaises(errors.SignatureError, serializer.LoadSigned,
-                      serializer.DumpSigned("test", "myprivatekey", "12345"),
-                      "myprivatekey", SaltInRange(1, 2))
 
-  def _TestSerializer(self, dump_fn, load_fn):
-    for data in self._TESTDATA:
-      self.failUnless(dump_fn(data).endswith("\n"))
-      self.failUnlessEqual(load_fn(dump_fn(data)), data)
+    self.assertRaises(errors.SignatureError, load_fn,
+                      serializer.DumpJson("This is a test"), "mykey")
+    self.assertRaises(errors.SignatureError, load_fn,
+                      serializer.DumpJson({}), "mykey")
+
+    # Message missing salt and HMAC
+    tdata = { "msg": "Foo", }
+    self.assertRaises(errors.SignatureError, load_fn,
+                      serializer.DumpJson(tdata), "mykey")
 
 
 if __name__ == '__main__':
-  unittest.main()
+  testutils.GanetiTestProgram()