git.samba.org / ira / wip.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
s4:ldb Add hooks to get/set the flags on a ldb_message_element
[ira/wip.git] / source4 / lib / ldb / tests / python / api.py
diff --git a/source4/lib/ldb/tests/python/api.py b/source4/lib/ldb/tests/python/api.py
index 07500e23728d9c86bc9640fdcacfc2c195a17ebc..9bcb2251905561f92b5af8a387027e007d56538b 100755 (executable)
--- a/source4/lib/ldb/tests/python/api.py
+++ b/source4/lib/ldb/tests/python/api.py
@@ -14,6 +14,7 @@ def filename():
     return os.tempnam()
 
 class NoContextTests(unittest.TestCase):
+
     def test_valid_attr_name(self):
         self.assertTrue(ldb.valid_attr_name("foo"))
         self.assertFalse(ldb.valid_attr_name("24foo"))
@@ -28,6 +29,7 @@ class NoContextTests(unittest.TestCase):
 
 
 class SimpleLdb(unittest.TestCase):
+
     def test_connect(self):
         ldb.Ldb(filename())
 
@@ -86,23 +88,23 @@ class SimpleLdb(unittest.TestCase):
 
     def test_search_scope_base(self):
         l = ldb.Ldb(filename())
-        self.assertEquals(len(l.search(ldb.Dn(l, "dc=foo"), 
+        self.assertEquals(len(l.search(ldb.Dn(l, "dc=foo1"), 
                           ldb.SCOPE_ONELEVEL)), 0)
 
     def test_delete(self):
         l = ldb.Ldb(filename())
-        self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo")))
+        self.assertRaises(ldb.LdbError, lambda: l.delete(ldb.Dn(l, "dc=foo2")))
 
     def test_contains(self):
         l = ldb.Ldb(filename())
-        self.assertFalse(ldb.Dn(l, "dc=foo") in l)
+        self.assertFalse(ldb.Dn(l, "dc=foo3") in l)
         l = ldb.Ldb(filename())
         m = ldb.Message()
-        m.dn = ldb.Dn(l, "dc=foo")
+        m.dn = ldb.Dn(l, "dc=foo3")
         m["b"] = ["a"]
         l.add(m)
         try:
-            self.assertTrue(ldb.Dn(l, "dc=foo") in l)
+            self.assertTrue(ldb.Dn(l, "dc=foo3") in l)
         finally:
             l.delete(m.dn)
 
@@ -125,45 +127,45 @@ class SimpleLdb(unittest.TestCase):
     def test_add(self):
         l = ldb.Ldb(filename())
         m = ldb.Message()
-        m.dn = ldb.Dn(l, "dc=foo")
+        m.dn = ldb.Dn(l, "dc=foo4")
         m["bla"] = "bla"
         self.assertEquals(len(l.search()), 1)
         l.add(m)
         try:
             self.assertEquals(len(l.search()), 2)
         finally:
-            l.delete(ldb.Dn(l, "dc=foo"))
+            l.delete(ldb.Dn(l, "dc=foo4"))
 
     def test_add_dict(self):
         l = ldb.Ldb(filename())
-        m = {"dn": ldb.Dn(l, "dc=foo"),
+        m = {"dn": ldb.Dn(l, "dc=foo5"),
              "bla": "bla"}
         self.assertEquals(len(l.search()), 1)
         l.add(m)
         try:
             self.assertEquals(len(l.search()), 2)
         finally:
-            l.delete(ldb.Dn(l, "dc=foo"))
+            l.delete(ldb.Dn(l, "dc=foo5"))
 
     def test_add_dict_string_dn(self):
         l = ldb.Ldb(filename())
-        m = {"dn": "dc=foo", "bla": "bla"}
+        m = {"dn": "dc=foo6", "bla": "bla"}
         self.assertEquals(len(l.search()), 1)
         l.add(m)
         try:
             self.assertEquals(len(l.search()), 2)
         finally:
-            l.delete(ldb.Dn(l, "dc=foo"))
+            l.delete(ldb.Dn(l, "dc=foo6"))
 
     def test_rename(self):
         l = ldb.Ldb(filename())
         m = ldb.Message()
-        m.dn = ldb.Dn(l, "dc=foo")
+        m.dn = ldb.Dn(l, "dc=foo7")
         m["bla"] = "bla"
         self.assertEquals(len(l.search()), 1)
         l.add(m)
         try:
-            l.rename(ldb.Dn(l, "dc=foo"), ldb.Dn(l, "dc=bar"))
+            l.rename(ldb.Dn(l, "dc=foo7"), ldb.Dn(l, "dc=bar"))
             self.assertEquals(len(l.search()), 2)
         finally:
             l.delete(ldb.Dn(l, "dc=bar"))
@@ -171,13 +173,13 @@ class SimpleLdb(unittest.TestCase):
     def test_rename_string_dns(self):
         l = ldb.Ldb(filename())
         m = ldb.Message()
-        m.dn = ldb.Dn(l, "dc=foo")
+        m.dn = ldb.Dn(l, "dc=foo8")
         m["bla"] = "bla"
         self.assertEquals(len(l.search()), 1)
         l.add(m)
         self.assertEquals(len(l.search()), 2)
         try:
-            l.rename("dc=foo", "dc=bar")
+            l.rename("dc=foo8", "dc=bar")
             self.assertEquals(len(l.search()), 2)
         finally:
             l.delete(ldb.Dn(l, "dc=bar"))
@@ -193,10 +195,13 @@ class SimpleLdb(unittest.TestCase):
         try:
             m = ldb.Message()
             m.dn = ldb.Dn(l, "dc=modifydelete")
-            m["bla"] = ldb.MessageElement([], ldb.CHANGETYPE_DELETE, "bla")
+            m["bla"] = ldb.MessageElement([], ldb.FLAG_MOD_DELETE, "bla")
+            self.assertEquals(ldb.FLAG_MOD_DELETE, m["bla"].flags())
             l.modify(m)
             rm = l.search(m.dn)[0]
             self.assertEquals(1, len(rm))
+            rm = l.search(m.dn, attrs=["bla"])[0]
+            self.assertEquals(0, len(rm))
         finally:
             l.delete(ldb.Dn(l, "dc=modifydelete"))
 
@@ -209,7 +214,8 @@ class SimpleLdb(unittest.TestCase):
         try:
             m = ldb.Message()
             m.dn = ldb.Dn(l, "dc=add")
-            m["bla"] = ldb.MessageElement(["456"], ldb.CHANGETYPE_ADD, "bla")
+            m["bla"] = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
+            self.assertEquals(ldb.FLAG_MOD_ADD, m["bla"].flags())
             l.modify(m)
             rm = l.search(m.dn)[0]
             self.assertEquals(2, len(rm))
@@ -217,7 +223,7 @@ class SimpleLdb(unittest.TestCase):
         finally:
             l.delete(ldb.Dn(l, "dc=add"))
 
-    def test_modify_modify(self):
+    def test_modify_replace(self):
         l = ldb.Ldb(filename())
         m = ldb.Message()
         m.dn = ldb.Dn(l, "dc=modify2")
@@ -226,18 +232,48 @@ class SimpleLdb(unittest.TestCase):
         try:
             m = ldb.Message()
             m.dn = ldb.Dn(l, "dc=modify2")
-            m["bla"] = ldb.MessageElement(["456"], ldb.CHANGETYPE_MODIFY, "bla")
+            m["bla"] = ldb.MessageElement(["789"], ldb.FLAG_MOD_REPLACE, "bla")
+            self.assertEquals(ldb.FLAG_MOD_REPLACE, m["bla"].flags())
             l.modify(m)
             rm = l.search(m.dn)[0]
             self.assertEquals(2, len(rm))
-            self.assertEquals(["1234"], list(rm["bla"]))
+            self.assertEquals(["789"], list(rm["bla"]))
+            rm = l.search(m.dn, attrs=["bla"])[0]
+            self.assertEquals(1, len(rm))
         finally:
             l.delete(ldb.Dn(l, "dc=modify2"))
 
+    def test_modify_flags_change(self):
+        l = ldb.Ldb(filename())
+        m = ldb.Message()
+        m.dn = ldb.Dn(l, "dc=add")
+        m["bla"] = ["1234"]
+        l.add(m)
+        try:
+            m = ldb.Message()
+            m.dn = ldb.Dn(l, "dc=add")
+            m["bla"] = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
+            self.assertEquals(ldb.FLAG_MOD_ADD, m["bla"].flags())
+            l.modify(m)
+            rm = l.search(m.dn)[0]
+            self.assertEquals(2, len(rm))
+            self.assertEquals(["1234", "456"], list(rm["bla"]))
+            
+            #Now create another modify, but switch the flags before we do it
+            m["bla"] = ldb.MessageElement(["456"], ldb.FLAG_MOD_ADD, "bla")
+            m["bla"].set_flags(ldb.FLAG_MOD_DELETE)
+            l.modify(m)
+            rm = l.search(m.dn, attrs=["bla"])[0]
+            self.assertEquals(1, len(rm))
+            self.assertEquals(["1234"], list(rm["bla"]))
+            
+        finally:
+            l.delete(ldb.Dn(l, "dc=add"))
+
     def test_transaction_commit(self):
         l = ldb.Ldb(filename())
         l.transaction_start()
-        m = ldb.Message(ldb.Dn(l, "dc=foo"))
+        m = ldb.Message(ldb.Dn(l, "dc=foo9"))
         m["foo"] = ["bar"]
         l.add(m)
         l.transaction_commit()
@@ -246,11 +282,11 @@ class SimpleLdb(unittest.TestCase):
     def test_transaction_cancel(self):
         l = ldb.Ldb(filename())
         l.transaction_start()
-        m = ldb.Message(ldb.Dn(l, "dc=foo"))
+        m = ldb.Message(ldb.Dn(l, "dc=foo10"))
         m["foo"] = ["bar"]
         l.add(m)
         l.transaction_cancel()
-        self.assertEquals(0, len(l.search(ldb.Dn(l, "dc=foo"))))
+        self.assertEquals(0, len(l.search(ldb.Dn(l, "dc=foo10"))))
 
     def test_set_debug(self):
         def my_report_fn(level, text):
@@ -273,43 +309,54 @@ class SimpleLdb(unittest.TestCase):
 
 
 class DnTests(unittest.TestCase):
+
     def setUp(self):
         self.ldb = ldb.Ldb(filename())
 
+    def test_set_dn_invalid(self):
+        x = ldb.Message()
+        def assign():
+            x.dn = "astring"
+        self.assertRaises(TypeError, assign)
+
     def test_eq(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
-        y = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo11,bar=bloe")
+        y = ldb.Dn(self.ldb, "dc=foo11,bar=bloe")
         self.assertEquals(x, y)
 
     def test_str(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
-        self.assertEquals(x.__str__(), "dc=foo,bar=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo12,bar=bloe")
+        self.assertEquals(x.__str__(), "dc=foo12,bar=bloe")
 
     def test_repr(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bla=blie")
-        self.assertEquals(x.__repr__(), "Dn('dc=foo,bla=blie')")
+        x = ldb.Dn(self.ldb, "dc=foo13,bla=blie")
+        self.assertEquals(x.__repr__(), "Dn('dc=foo13,bla=blie')")
 
     def test_get_casefold(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
-        self.assertEquals(x.get_casefold(), "DC=FOO,BAR=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo14,bar=bloe")
+        self.assertEquals(x.get_casefold(), "DC=FOO14,BAR=bloe")
 
     def test_validate(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo15,bar=bloe")
         self.assertTrue(x.validate())
 
     def test_parent(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo16,bar=bloe")
         self.assertEquals("bar=bloe", x.parent().__str__())
 
+    def test_parent_nonexistant(self):
+        x = ldb.Dn(self.ldb, "@BLA")
+        self.assertEquals(None, x.parent())
+
     def test_compare(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
-        y = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo17,bar=bloe")
+        y = ldb.Dn(self.ldb, "dc=foo17,bar=bloe")
         self.assertEquals(x, y)
-        z = ldb.Dn(self.ldb, "dc=foo,bar=blie")
+        z = ldb.Dn(self.ldb, "dc=foo17,bar=blie")
         self.assertNotEquals(z, y)
 
     def test_is_valid(self):
-        x = ldb.Dn(self.ldb, "dc=foo,dc=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo18,dc=bloe")
         self.assertTrue(x.is_valid())
         x = ldb.Dn(self.ldb, "")
         # is_valid()'s return values appears to be a side effect of 
@@ -317,38 +364,38 @@ class DnTests(unittest.TestCase):
         # self.assertFalse(x.is_valid())
 
     def test_is_special(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo19,bar=bloe")
         self.assertFalse(x.is_special())
         x = ldb.Dn(self.ldb, "@FOOBAR")
         self.assertTrue(x.is_special())
 
     def test_check_special(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo20,bar=bloe")
         self.assertFalse(x.check_special("FOOBAR"))
         x = ldb.Dn(self.ldb, "@FOOBAR")
         self.assertTrue(x.check_special("@FOOBAR"))
 
     def test_len(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo21,bar=bloe")
         self.assertEquals(2, len(x))
-        x = ldb.Dn(self.ldb, "dc=foo")
+        x = ldb.Dn(self.ldb, "dc=foo21")
         self.assertEquals(1, len(x))
 
     def test_add_child(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo22,bar=bloe")
         self.assertTrue(x.add_child(ldb.Dn(self.ldb, "bla=bloe")))
-        self.assertEquals("bla=bloe,dc=foo,bar=bloe", x.__str__())
+        self.assertEquals("bla=bloe,dc=foo22,bar=bloe", x.__str__())
 
     def test_add_base(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
+        x = ldb.Dn(self.ldb, "dc=foo23,bar=bloe")
         base = ldb.Dn(self.ldb, "bla=bloe")
         self.assertTrue(x.add_base(base))
-        self.assertEquals("dc=foo,bar=bloe,bla=bloe", x.__str__())
+        self.assertEquals("dc=foo23,bar=bloe,bla=bloe", x.__str__())
 
     def test_add(self):
-        x = ldb.Dn(self.ldb, "dc=foo")
+        x = ldb.Dn(self.ldb, "dc=foo24")
         y = ldb.Dn(self.ldb, "bar=bla")
-        self.assertEquals("dc=foo,bar=bla", str(y + x))
+        self.assertEquals("dc=foo24,bar=bla", str(y + x))
 
     def test_parse_ldif(self):
         msgs = self.ldb.parse_ldif("dn: foo=bar\n")
@@ -364,31 +411,32 @@ class DnTests(unittest.TestCase):
         self.assertEquals("bar=bar", str(msg[1].dn))
 
     def test_canonical_string(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
-        self.assertEquals("/bloe/foo", x.canonical_str())
+        x = ldb.Dn(self.ldb, "dc=foo25,bar=bloe")
+        self.assertEquals("/bloe/foo25", x.canonical_str())
 
     def test_canonical_ex_string(self):
-        x = ldb.Dn(self.ldb, "dc=foo,bar=bloe")
-        self.assertEquals("/bloe\nfoo", x.canonical_ex_str())
+        x = ldb.Dn(self.ldb, "dc=foo26,bar=bloe")
+        self.assertEquals("/bloe\nfoo26", x.canonical_ex_str())
 
 
 class LdbMsgTests(unittest.TestCase):
+
     def setUp(self):
         self.msg = ldb.Message()
 
     def test_init_dn(self):
-        self.msg = ldb.Message(ldb.Dn(ldb.Ldb(), "dc=foo"))
-        self.assertEquals("dc=foo", str(self.msg.dn))
+        self.msg = ldb.Message(ldb.Dn(ldb.Ldb(), "dc=foo27"))
+        self.assertEquals("dc=foo27", str(self.msg.dn))
 
     def test_iter_items(self):
         self.assertEquals(0, len(self.msg.items()))
-        self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo")
+        self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo28")
         self.assertEquals(1, len(self.msg.items()))
 
     def test_repr(self):
-        self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo")
+        self.msg.dn = ldb.Dn(ldb.Ldb("foo.tdb"), "dc=foo29")
         self.msg["dc"] = "foo"
-        self.assertEquals("Message({'dn': Dn('dc=foo'), 'dc': MessageElement(['foo'])})", repr(self.msg))
+        self.assertEquals("Message({'dn': Dn('dc=foo29'), 'dc': MessageElement(['foo'])})", repr(self.msg))
 
     def test_len(self):
         self.assertEquals(0, len(self.msg))
@@ -437,8 +485,20 @@ class LdbMsgTests(unittest.TestCase):
     def test_get_unknown(self):
         self.assertEquals(None, self.msg.get("lalalala"))
 
+    def test_msg_diff(self):
+        l = ldb.Ldb()
+        msgs = l.parse_ldif("dn: foo=bar\nfoo: bar\nbaz: do\n\ndn: foo=bar\nfoo: bar\nbaz: dont\n")
+        msg1 = msgs.next()[1]
+        msg2 = msgs.next()[1]
+        msgdiff = l.msg_diff(msg1, msg2)
+        self.assertEquals("foo=bar", msgdiff.get("dn").__str__())
+        self.assertRaises(KeyError, lambda: msgdiff["foo"])
+        self.assertEquals(1, len(msgdiff))
+
+
 
 class MessageElementTests(unittest.TestCase):
+
     def test_cmp_element(self):
         x = ldb.MessageElement(["foo"])
         y = ldb.MessageElement(["foo"])
@@ -479,6 +539,7 @@ class MessageElementTests(unittest.TestCase):
 
 
 class ModuleTests(unittest.TestCase):
+
     def test_register_module(self):
         class ExampleModule:
             name = "example"
@@ -505,6 +566,7 @@ class ModuleTests(unittest.TestCase):
         l = ldb.Ldb("usemodule.ldb")
         self.assertEquals(["init"], ops)
 
+
 if __name__ == '__main__':
     import unittest
     unittest.TestProgram()
Unnamed repository; edit this file 'description' to name the repository.