source4/lib/ldb/tests/python/deletetest.py

   1 #!/usr/bin/python
   2 # -*- coding: utf-8 -*-
   3
   4 import getopt
   5 import optparse
   6 import sys
   7 import os
   8
   9 sys.path.append("bin/python")
  10 sys.path.append("../lib/subunit/python")
  11
  12 import samba.getopt as options
  13
  14 from samba.auth import system_session
  15 from ldb import SCOPE_BASE, LdbError
  16 from ldb import ERR_NO_SUCH_OBJECT
  17 from samba import Ldb
  18
  19 from subunit.run import SubunitTestRunner
  20 import unittest
  21
  22 parser = optparse.OptionParser("deletetest.py [options] <host|file>")
  23 sambaopts = options.SambaOptions(parser)
  24 parser.add_option_group(sambaopts)
  25 parser.add_option_group(options.VersionOptions(parser))
  26 # use command line creds if available
  27 credopts = options.CredentialsOptions(parser)
  28 parser.add_option_group(credopts)
  29 opts, args = parser.parse_args()
  30
  31 if len(args) < 1:
  32     parser.print_usage()
  33     sys.exit(1)
  34
  35 host = args[0]
  36
  37 lp = sambaopts.get_loadparm()
  38 creds = credopts.get_credentials(lp)
  39
  40 class BasicDeleteTests(unittest.TestCase):
  41
  42     def delete_force(self, ldb, dn):
  43         try:
  44             ldb.delete(dn)
  45         except LdbError, (num, _):
  46             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
  47
  48     def GUID_string(self, guid):
  49         return self.ldb.schema_format_value("objectGUID", guid)
  50
  51     def find_basedn(self, ldb):
  52         res = ldb.search(base="", expression="", scope=SCOPE_BASE,
  53                          attrs=["defaultNamingContext"])
  54         self.assertEquals(len(res), 1)
  55         return res[0]["defaultNamingContext"][0]
  56
  57     def setUp(self):
  58         self.ldb = ldb
  59         self.base_dn = self.find_basedn(ldb)
  60
  61     def search_guid(self,guid):
  62         print "SEARCH by GUID %s" % self.GUID_string(guid)
  63
  64         expression = "(objectGUID=%s)" % self.GUID_string(guid)
  65         res = ldb.search(expression=expression,
  66                          controls=["show_deleted:1"])
  67         self.assertEquals(len(res), 1)
  68         return res[0]
  69
  70     def search_dn(self,dn):
  71         print "SEARCH by DN %s" % dn
  72
  73         res = ldb.search(expression="(objectClass=*)",
  74                          base=dn,
  75                          scope=SCOPE_BASE,
  76                          controls=["show_deleted:1"])
  77         self.assertEquals(len(res), 1)
  78         return res[0]
  79
  80     def del_attr_values(self, delObj):
  81         print "Checking attributes for %s" % delObj["dn"]
  82
  83         self.assertEquals(delObj["isDeleted"][0],"TRUE")
  84         self.assertTrue(not("objectCategory" in delObj))
  85         self.assertTrue(not("sAMAccountType" in delObj))
  86
  87     def preserved_attributes_list(self, liveObj, delObj):
  88         print "Checking for preserved attributes list"
  89
  90         preserved_list = ["nTSecurityDescriptor", "attributeID", "attributeSyntax", "dNReferenceUpdate", "dNSHostName",
  91         "flatName", "governsID", "groupType", "instanceType", "lDAPDisplayName", "legacyExchangeDN",
  92         "isDeleted", "isRecycled", "lastKnownParent", "msDS-LastKnownRDN", "mS-DS-CreatorSID",
  93         "mSMQOwnerID", "nCName", "objectClass", "distinguishedName", "objectGUID", "objectSid",
  94         "oMSyntax", "proxiedObjectName", "name", "replPropertyMetaData", "sAMAccountName",
  95         "securityIdentifier", "sIDHistory", "subClassOf", "systemFlags", "trustPartner", "trustDirection",
  96         "trustType", "trustAttributes", "userAccountControl", "uSNChanged", "uSNCreated", "whenCreated"]
  97
  98         for a in liveObj:
  99             if a in preserved_list:
 100                 self.assertTrue(a in delObj)
 101
 102     def check_rdn(self, liveObj, delObj, rdnName):
 103         print "Checking for correct rDN"
 104         rdn=liveObj[rdnName][0]
 105         rdn2=delObj[rdnName][0]
 106         name2=delObj[rdnName][0]
 107         guid=liveObj["objectGUID"][0]
 108         self.assertEquals(rdn2, rdn + "\nDEL:" + self.GUID_string(guid))
 109         self.assertEquals(name2, rdn + "\nDEL:" + self.GUID_string(guid))
 110
 111     def delete_deleted(self, ldb, dn):
 112         print "Testing the deletion of the already deleted dn %s" % dn
 113
 114         try:
 115             ldb.delete(dn)
 116             self.fail()
 117         except LdbError, (num, _):
 118             self.assertEquals(num, ERR_NO_SUCH_OBJECT)
 119
 120     def test_all(self):
 121         """Basic delete tests"""
 122
 123         print self.base_dn
 124
 125         dn1="cn=testuser,cn=users," + self.base_dn
 126         dn2="cn=testuser2,cn=users," + self.base_dn
 127         grp1="cn=testdelgroup1,cn=users," + self.base_dn
 128
 129         self.delete_force(self.ldb, dn1)
 130         self.delete_force(self.ldb, dn2)
 131         self.delete_force(self.ldb, grp1)
 132
 133         ldb.add({
 134             "dn": dn1,
 135             "objectclass": "user",
 136             "cn": "testuser",
 137             "description": "test user description",
 138             "samaccountname": "testuser"})
 139
 140         ldb.add({
 141             "dn": dn2,
 142             "objectclass": "user",
 143             "cn": "testuser2",
 144             "description": "test user 2 description",
 145             "samaccountname": "testuser2"})
 146
 147         ldb.add({
 148             "dn": grp1,
 149             "objectclass": "group",
 150             "cn": "testdelgroup1",
 151             "description": "test group",
 152             "samaccountname": "testdelgroup1",
 153             "member": [ dn1, dn2 ] })
 154
 155         objLive1 = self.search_dn(dn1)
 156         guid1=objLive1["objectGUID"][0]
 157
 158         objLive2 = self.search_dn(dn2)
 159         guid2=objLive2["objectGUID"][0]
 160
 161         objLive3 = self.search_dn(grp1)
 162         guid3=objLive3["objectGUID"][0]
 163
 164         ldb.delete(dn1)
 165         ldb.delete(dn2)
 166         ldb.delete(grp1)
 167
 168         objDeleted1 = self.search_guid(guid1)
 169         objDeleted2 = self.search_guid(guid2)
 170         objDeleted3 = self.search_guid(guid3)
 171
 172         self.del_attr_values(objDeleted1)
 173         self.del_attr_values(objDeleted2)
 174         self.del_attr_values(objDeleted3)
 175
 176         self.preserved_attributes_list(objLive1, objDeleted1)
 177         self.preserved_attributes_list(objLive2, objDeleted2)
 178
 179         self.check_rdn(objLive1, objDeleted1, "cn")
 180         self.check_rdn(objLive2, objDeleted2, "cn")
 181         self.check_rdn(objLive3, objDeleted3, "cn")
 182
 183         self.delete_deleted(ldb, dn1)
 184         self.delete_deleted(ldb, dn2)
 185         self.delete_deleted(ldb, grp1)
 186
 187 if not "://" in host:
 188     if os.path.isfile(host):
 189         host = "tdb://%s" % host
 190     else:
 191         host = "ldap://%s" % host
 192
 193 ldb = Ldb(host, credentials=creds, session_info=system_session(), lp=lp)
 194
 195 runner = SubunitTestRunner()
 196 rc = 0
 197 if not runner.run(unittest.makeSuite(BasicDeleteTests)).wasSuccessful():
 198     rc = 1
 199
 200 sys.exit(rc)