X-Git-Url: https://git.distorted.org.uk/~mdw/catacomb-python/blobdiff_plain/740847afe208bb8f33e7d6cf642acaf4aa739f6a..f5a133608a72a96b2023024043dc00480192bcc7:/t/t-key.py

diff --git a/t/t-key.py b/t/t-key.py
index e81217e..000dc11 100644
--- a/t/t-key.py
+++ b/t/t-key.py
@@ -169,10 +169,14 @@ class TestKeyFile (U.TestCase):
     me.assertRaises(TypeError, kf.bytype, 12345)
     me.assertRaises(C.KeyError, kf.byid, 0x12345678)
 
+    me.assertRaises(C.KeyError, kf.mergeline, "nowhere", 2, "")
+
     ## The keyring should be readonly.
     me.assertRaises(C.KeyError, kf.newkey, 0x12345678, "fail")
     me.assertRaises(C.KeyError, setattr, k, "tag", "foo")
     me.assertRaises(C.KeyError, delattr, k, "tag")
+    me.assertRaises(C.KeyError, kf.mergeline, "notexist", 1,
+                    "22222222:test integer,public:32519164 forever forever -")
     me.assertRaises(C.KeyError, setattr, k, "data", C.KeyDataString("foo"))
 
   def test_keywrite(me):
@@ -184,7 +188,7 @@ class TestKeyFile (U.TestCase):
     k = kf.newkey(0x11111111, "first", exp)
     me.assertEqual(kf.modifiedp, True)
 
-    me.assertEqual(kf[0x11111111].id, 0x11111111)
+    me.assertEqual(k, kf[0x11111111])
     me.assertEqual(k.exptime, exp)
     me.assertEqual(k.deltime, exp)
     me.assertRaises(ValueError, setattr, k, "deltime", C.KEXP_FOREVER)
@@ -204,25 +208,10 @@ class TestKeyFile (U.TestCase):
     del k.comment
     me.assertEqual(k.comment, None)
 
-###--------------------------------------------------------------------------
-
-def keydata_equalp(kd0, kd1):
-  if type(kd0) is not type(kd1): return False
-  elif type(kd0) is C.KeyDataBinary: return kd0.bin == kd1.bin
-  elif type(kd0) is C.KeyDataMP: return kd0.mp == kd1.mp
-  elif type(kd0) is C.KeyDataEncrypted: return kd0.ct == kd1.ct
-  elif type(kd0) is C.KeyDataECPt: return kd0.ecpt == kd1.ecpt
-  elif type(kd0) is C.KeyDataString: return kd0.str == kd1.str
-  elif type(kd0) is C.KeyDataStructured:
-    if len(kd0) != len(kd1): return False
-    for t, v0 in T.iteritems(kd0):
-      try: v1 = kd1[t]
-      except KeyError: return False
-      if not keydata_equalp(v0, v1): return False
-    return True
-  else:
-    raise SystemError("unexpected keydata type")
+    kf.mergeline("notexist", 1,
+                 "22222222:test integer,public:32519164 forever forever -")
 
+###--------------------------------------------------------------------------
 class TestKeyData (U.TestCase):
 
   def test_flags(me):
@@ -259,10 +248,8 @@ class TestKeyData (U.TestCase):
     me.assertEqual(set(T.iterkeys(kd2)), set(["b"]))
 
   def check_encode(me, kd):
-    me.assertTrue(keydata_equalp(C.KeyData.decode(kd.encode()), kd))
-    kd1, tail = C.KeyData.read(kd.write())
-    me.assertEqual(tail, "")
-    me.assertTrue(keydata_equalp(kd, kd1))
+    me.assertEqual(C.KeyData.decode(kd.encode()), kd)
+    me.assertEqual(C.KeyData.read(kd.write()), (kd, ""))
 
   def test_bin(me):
     rng = T.detrand("kd-bin")
@@ -301,13 +288,16 @@ class TestKeyData (U.TestCase):
   def test_struct(me):
     rng = T.detrand("kd-struct")
     kd = C.KeyDataStructured({ "a": C.KeyDataString("a"),
-                               "b": C.KeyDataString("b"),
-                               "c": C.KeyDataString("c"),
-                               "d": C.KeyDataString("d") })
+                               "b": C.KeyDataString("b") },
+                             c = C.KeyDataString("c"),
+                             d = C.KeyDataString("d"))
     for i in ["a", "b", "c", "d"]: me.assertEqual(kd[i].str, i)
     me.assertEqual(len(kd), 4)
     me.check_encode(kd)
     me.assertRaises(TypeError, C.KeyDataStructured, { "a": "a" })
+    me.assertRaises(ValueError, C.KeyDataStructured,
+                    { "a": C.KeyDataString("a") },
+                    a = C.KeyDataString("b"))
 
 ###--------------------------------------------------------------------------
 ### Mappings.
@@ -324,8 +314,17 @@ class TestKeyFileMapping (T.ImmutableMappingTextMixin):
       model[i] = 100 + i
       kf.newkey(i, "k#%d" % i).data = C.KeyDataMP(100 + i)
 
+    me.assertEqual(kf[1], kf[1])
+
     me.check_immutable_mapping(kf, model)
 
+class TestKeyStructMapping (T.MutableMappingTestMixin):
+  def _mkvalue(me, i): return C.KeyDataMP(i)
+  def _getvalue(me, v): return v.mp
+
+  def test_keystructmap(me):
+    me.check_mapping(C.KeyDataStructured)
+
 class TestKeyAttrMapping (T.MutableMappingTestMixin):
 
   def test_attrmap(me):